Bubberstation/code/modules/projectiles/projectile.dm

/// Not actually hitscan but close as we get without actual hitscan.
#define MOVES_HITSCAN -1
/// How many pixels to move the muzzle flash up so your character doesn't look like they're shitting out lasers.
#define MUZZLE_EFFECT_PIXEL_INCREMENT 17

/obj/projectile
	name = "projectile"
	icon = 'icons/obj/weapons/guns/projectiles.dmi'
	icon_state = "bullet"
	density = FALSE
	anchored = TRUE
	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
	movement_type = FLYING
	wound_bonus = CANT_WOUND // can't wound by default
	generic_canpass = FALSE
	blocks_emissive = EMISSIVE_BLOCK_GENERIC
	layer = MOB_LAYER
	/// The sound this plays on impact.
	var/hitsound = 'sound/items/weapons/pierce.ogg'
	/// Sound played when the projectile hits a wall
	var/hitsound_wall

	resistance_flags = LAVA_PROOF | FIRE_PROOF | UNACIDABLE | ACID_PROOF
	/// Zone at which the projectile is aimed at
	var/def_zone = ""
	/// Atom who shot the projectile (Not the gun, the guy who shot the gun)
	var/atom/movable/firer = null
	/// The thing that the projectile was fired from (gun, turret, spell)
	var/datum/fired_from = null
	/// One of three suppression states: NONE displays the hit message and produces a loud sound,
	/// QUIET makes a quiet sound and only lets the victim know they've been shot, and VERY only makes a very quiet sound with no messages
	var/suppressed = SUPPRESSED_NONE
	/// Original clicked target
	var/atom/original = null
	/// Initial target x coordinate offset of the projectile
	VAR_FINAL/xo = null
	/// Initial target y coordinate offset of the projectile
	VAR_FINAL/yo = null
	/// Projectile's starting turf
	var/turf/starting = null
	/// pixel_x where the player clicked. Default is the center.
	var/p_x = 16
	/// pixel_y where the player clicked. Default is the center
	var/p_y = 16
	/// X coordinate at which the projectile entered a new turf
	var/entry_x
	/// Y coordinate at which the projectile entered a new turf
	var/entry_y
	/// X coordinate at which the projectile visually impacted the target
	var/impact_x
	/// Y coordinate at which the projectile visually impacted the target
	var/impact_y
	/// Turf of the last atom we've impacted
	VAR_FINAL/turf/last_impact_turf = null

	/// If the projectile was fired already
	var/fired = FALSE
	/// If the projectile is suspended mid-air
	var/paused = FALSE
	/// Last time the projectile moved, used for lag compensation if SSprojectiles starts chugging
	VAR_PRIVATE/last_projectile_move = 0
	/// Last time the projectile was processed, also used for lag compensation
	VAR_PRIVATE/last_process = 0
	/// How many pixels we missed last tick due to lag or speed cap
	VAR_PRIVATE/overrun = 0
	/// Projectile's movement vector - this caches sine/cosine of our angle to cut down on trig calculations
	var/datum/vector/movement_vector
	/// We already impacted these things, do not impact them again. Used to make sure we can pierce things we want to pierce. Lazylist, typecache style (object = TRUE) for performance.
	var/list/impacted = list()
	/// If TRUE, we can hit our firer.
	var/ignore_source_check = FALSE
	/// We are flagged PHASING temporarily to not stop moving when we Bump something but want to keep going anyways.
	var/temporary_unstoppable_movement = FALSE

	/** PROJECTILE PIERCING
	  * WARNING:
	  * Projectile piercing MUST be done using these variables.
	  * Ordinary passflags will result in can_hit_target being false unless directly clicked on - similar to projectile_phasing but without even going to process_hit.
	  * The two flag variables below both use pass flags.
	  * In the context of LETPASStHROW, it means the projectile will ignore things that are currently "in the air" from a throw.
	  *
	  * Also, projectiles sense hits using Bump(), and then pierce them if necessary.
	  * They simply do not follow conventional movement rules.
	  * NEVER flag a projectile as PHASING movement type.
	  * If you so badly need to make one go through *everything*, override check_pierce() for your projectile to always return PROJECTILE_PIERCE_PHASE/HIT.
	  */
	/// The "usual" flags of pass_flags is used in that can_hit_target ignores these unless they're specifically targeted/clicked on. This behavior entirely bypasses process_hit if triggered, rather than phasing which uses prehit_pierce() to check.
	pass_flags = PASSTABLE
	/// If FALSE, allow us to hit something directly targeted/clicked/whatnot even if we're able to phase through it
	var/phasing_ignore_direct_target = FALSE
	/// Bitflag for things the projectile should just phase through entirely - No hitting unless direct target and [phasing_ignore_direct_target] is FALSE. Uses pass_flags flags.
	var/projectile_phasing = NONE
	/// Bitflag for things the projectile should hit, but pierce through without deleting itself. Defers to projectile_phasing. Uses pass_flags flags.
	var/projectile_piercing = NONE
	/// Number of times we've pierced something. Incremented BEFORE bullet_act and on_hit proc!
	var/pierces = 0
	/// How many times this projectile can pierce something before deleting
	var/max_pierces = 0

	/// If objects are below this layer, we pass through them
	var/hit_threshhold = PROJECTILE_HIT_THRESHHOLD_LAYER

	/// How many tiles we pass in a single SSprojectiles tick
	var/speed = 1.25

	/// The current angle of the projectile. Initially null, so if the arg is missing from [/fire()], we can calculate it from firer and target as fallback.
	var/angle
	/// Angle at the moment of firing
	var/original_angle = 0
	/// Set TRUE to prevent projectiles from having their sprites rotated based on firing angle
	var/nondirectional_sprite = FALSE
	/// Random spread done projectile-side for convinience
	var/spread = 0
	/// Additional rotation for the projectile, in case it uses some object's sprite
	var/projectile_angle = 0
	/// Gliding does not enjoy something getting moved multiple turfs in a tick, which is why we animate it manually
	animate_movement = NO_STEPS

	// Ricochet logic
	/// How many times we've ricochet'd so far (instance variable, not a stat)
	var/ricochets = 0
	/// How many times we can ricochet max
	var/ricochets_max = 0
	/// How many times we have to ricochet min (unless we hit an atom we can ricochet off)
	var/min_ricochets = 0
	/// 0-100 (or more, I guess), the base chance of ricocheting, before being modified by the atom we shoot and our chance decay
	var/ricochet_chance = 0
	/// 0-1 (or more, I guess) multiplier, the ricochet_chance is modified by multiplying this after each ricochet
	var/ricochet_decay_chance = 0.7
	/// 0-1 (or more, I guess) multiplier, the projectile's damage is modified by multiplying this after each ricochet
	var/ricochet_decay_damage = 0.7
	/// On ricochet, if nonzero, we consider all mobs within this range of our projectile at the time of ricochet to home in on like Revolver Ocelot, as governed by ricochet_auto_aim_angle
	var/ricochet_auto_aim_range = 0
	/// On ricochet, if ricochet_auto_aim_range is nonzero, we'll consider any mobs within this range of the normal angle of incidence to home in on, higher = more auto aim
	var/ricochet_auto_aim_angle = 30
	/// the angle of impact must be within this many degrees of the struck surface, set to 0 to allow any angle
	var/ricochet_incidence_leeway = 40
	/// Can our ricochet autoaim hit our firer?
	var/ricochet_shoots_firer = TRUE

	// Hitscan logic
	/// Wherever this projectile is hitscan. Hitscan projectiles are processed until the end of their path instantly upon being fired and leave a tracer in their path
	var/hitscan = FALSE
	/// Associated list of coordinate points in which we changed trajectories in order to calculate hitscan tracers
	/// Value points to the next point in the beam
	var/list/datum/point/beam_points
	/// Last point in the beam
	var/datum/point/last_point
	/// Next forceMove will not create tracer end/start effects
	var/free_hitscan_forceMove = FALSE
	// Used to prevent duplicate effects during lag chunking
	/// If a hitscan muzzle effect has been created for this "path", reset during forceMoves.
	var/spawned_muzzle = FALSE

	/// Hitscan tracer effect left behind the projectile
	var/tracer_type
	/// Hitscan muzzle effect spawned on the firer
	var/muzzle_type
	/// Hitscan impact effect spawned on the target
	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
	/// If the projectile is currently homing. Warning - this changes projectile's processing logic, reverting it to segmented processing instead of new raymarching logic
	/// This does not actually set up the projectile to home in on a target - you need to set that up with set_homing_target() on the projectile!
	VAR_FINAL/homing = FALSE
	/// Target the projectile is homing on
	var/atom/homing_target
	/// Angles per move segment, distance is based on SSprojectiles.pixels_per_decisecond
	/// With pixels_per_decisecond set to 16 and homing_turn_speed, the projectile can turn up to 20 pixels per turf passed
	var/homing_turn_speed = 10
	// Allowed leeway in pixels
	var/homing_inaccuracy_min = 0
	var/homing_inaccuracy_max = 0
	var/homing_offset_x = 0
	var/homing_offset_y = 0

	var/damage = 10
	var/damage_type = BRUTE //BRUTE, BURN, TOX, OXY are the only things that should be in here

	/// Defines what armor to use when it hits things.  Must be set to bullet, laser, energy, or bomb
	var/armor_flag = BULLET
	/// How much armor this projectile pierces.
	var/armour_penetration = 0
	/// Whether or not our projectile doubles the value of affecting armour
	var/weak_against_armour = FALSE
	/// This will de-increment every step. When 0, it will delete the projectile.
	var/range = 50
	/// Original range upon being fired/reflected
	var/maximum_range
	/// Amount of original range that falls off when reflecting, so it doesn't go forever
	var/reflect_range_decrease = 5
	/// If this projectile can be reflected
	var/reflectable = FALSE

	// Status effects applied on hit
	var/stun = 0 SECONDS
	var/knockdown = 0 SECONDS
	var/paralyze = 0 SECONDS
	var/immobilize = 0 SECONDS
	var/unconscious = 0 SECONDS
	/// Seconds of blurry eyes applied on projectile hit
	var/eyeblur = 0 SECONDS
	/// Drowsiness applied on projectile hit
	var/drowsy = 0 SECONDS
	/// Jittering applied on projectile hit
	var/jitter = 0 SECONDS
	/// Extra stamina damage applied on projectile hit (in addition to the main damage)
	var/stamina = 0
	/// Stuttering applied on projectile hit
	var/stutter = 0 SECONDS
	/// Slurring applied on projectile hit
	var/slur = 0 SECONDS

	/// Damage the limb must have for it to be dismembered upon getting hit. 0 will prevent dismembering altogether
	var/dismemberment = 0
	/// If TRUE, this projectile deals its damage to the chest if it dismembers a limb.
	var/catastropic_dismemberment = FALSE
	/// Impact VFX created upon hitting something
	var/impact_effect_type
	/// If the act of firing this projectile does not create logs
	var/log_override = FALSE
	/// If true, the projectile won't cause any logging whatsoever. Used for hallucinations and shit.
	var/do_not_log = FALSE
	/// We ignore mobs with these factions.
	var/list/ignored_factions
	/// Turf that we have registered connect_loc signal - this is done for performance, as we're moving ~a dozen turfs per tick
	/// and registering and unregistering signal for every single one of them is stupid. Unregistering the signal from the correct turf in case we get moved by smth else is important
	var/turf/last_tick_turf
	/// Remaining pixel movement last tick - used for precise range calculations
	var/pixels_moved_last_tile = 0
	/// In order to preserve animations, projectiles are only deleted the tick *after* they impact something.
	/// Same is applied to reaching the range limit
	var/deletion_queued = NONE
	/// How many ticks should we wait in queued deletion mode before qdeleting? Sometimes increased in animations
	var/ticks_to_deletion = 1

	/// If defined, on hit we create an item of this type then call hitby() on the hit target with this, mainly used for embedding items (bullets) in targets
	var/shrapnel_type
	/// If we have a shrapnel_type defined, these embedding stats will be passed to the spawned shrapnel type, which will roll for embedding on the target
	var/embed_type
	/// Saves embedding data
	VAR_PROTECTED/datum/embedding/embed_data
	/// If TRUE, hit mobs, even if they are lying on the floor and are not our target within MAX_RANGE_HIT_PRONE_TARGETS tiles
	var/hit_prone_targets = FALSE
	/// If TRUE, ignores the range of MAX_RANGE_HIT_PRONE_TARGETS tiles of hit_prone_targets
	var/ignore_range_hit_prone_targets = FALSE
	/// For what kind of brute wounds we're rolling for, if we're doing such a thing. Lasers obviously don't care since they do burn instead.
	var/sharpness = NONE
	/// How much we want to drop damage per tile as it travels through the air
	var/damage_falloff_tile
	/// How much we want to drop stamina damage (defined by the stamina variable) per tile as it travels through the air
	var/stamina_falloff_tile
	/// How much we want to drop both wound_bonus and exposed_wound_bonus (to a minimum of 0 for the latter) per tile, for falloff purposes
	var/wound_falloff_tile
	/// How much we want to drop the embed_chance value, if we can embed, per tile, for falloff purposes
	var/embed_falloff_tile
	/// How much accuracy is lost for each tile travelled
	var/accuracy_falloff = 7
	/// How much accuracy before falloff starts to matter. Formula is range - falloff * tiles travelled
	var/accurate_range = 100
	/// If true directly targeted turfs can be hit
	var/can_hit_turfs = FALSE

/obj/projectile/Initialize(mapload)
	. = ..()
	maximum_range = range
	if (embed_type)
		set_embed(embed_type)
	add_traits(list(TRAIT_FREE_HYPERSPACE_MOVEMENT, TRAIT_FREE_HYPERSPACE_SOFTCORDON_MOVEMENT), INNATE_TRAIT)

/obj/projectile/Destroy()
	if (hitscan)
		generate_hitscan_tracers()
	STOP_PROCESSING(SSprojectiles, src)
	firer = null
	original = null
	QDEL_NULL(embed_data)
	if (movement_vector)
		QDEL_NULL(movement_vector)
	if (beam_points)
		QDEL_LIST(beam_points)
	if (last_point)
		QDEL_NULL(last_point)
	return ..()

/// Called every time a projectile passes one tile worth of movement
/obj/projectile/proc/reduce_range()
	range--
	pixels_moved_last_tile -= ICON_SIZE_ALL
	if(wound_falloff_tile && wound_bonus != CANT_WOUND)
		wound_bonus += wound_falloff_tile
		exposed_wound_bonus = max(0, exposed_wound_bonus + wound_falloff_tile)
	if(embed_falloff_tile && get_embed())
		embed_data.embed_chance += embed_falloff_tile
	if(damage_falloff_tile && damage >= 0)
		damage += damage_falloff_tile
	if(stamina_falloff_tile && stamina >= 0)
		stamina += stamina_falloff_tile

	SEND_SIGNAL(src, COMSIG_PROJECTILE_RANGE)
	if(range <= 0 && loc)
		if (hitscan)
			qdel(src)
			return
		deletion_queued = PROJECTILE_RANGE_DELETE

	if(damage_falloff_tile && damage <= 0 || stamina_falloff_tile && stamina <= 0)
		if (hitscan)
			qdel(src)
			return
		deletion_queued = PROJECTILE_RANGE_DELETE

/// Called next tick after the projectile reaches its maximum range so the animation has time to fully play out
/obj/projectile/proc/on_range()
	SEND_SIGNAL(src, COMSIG_PROJECTILE_RANGE_OUT)
	qdel(src)

/**
 * Called when the projectile hits something
 *
 * By default parent call will always return [BULLET_ACT_HIT] (unless qdeleted)
 * so it is save to assume a successful hit in children (though not necessarily successfully damaged - it could've been blocked)
 *
 * Arguments
 * * target - thing hit
 * * blocked - percentage of hit blocked (0 to 100)
 * * pierce_hit - boolean, are we piercing through or regular hitting
 *
 * Returns
 * * Returns [BULLET_ACT_HIT] if we hit something. Default return value.
 * * Returns [BULLET_ACT_BLOCK] if we were hit but sustained no effects (blocked it). Note, Being "blocked" =/= "blocked is 100".
 * * Returns [BULLET_ACT_FORCE_PIERCE] to have the projectile keep going instead of "hitting", as if we were not hit at all.
 */
/obj/projectile/proc/on_hit(atom/target, blocked = 0, pierce_hit)
	SHOULD_CALL_PARENT(TRUE)

	// i know that this is probably more with wands and gun mods in mind, but it's a bit silly that the projectile on_hit signal doesn't ping the projectile itself.
	// maybe we care what the projectile thinks! See about combining these via args some time when it's not 5AM
	var/hit_limb_zone
	if(isliving(target))
		var/mob/living/victim = target
		hit_limb_zone = victim.check_hit_limb_zone_name(def_zone)

	if(fired_from)
		SEND_SIGNAL(fired_from, COMSIG_PROJECTILE_ON_HIT, firer, target, angle, hit_limb_zone, blocked, pierce_hit)
	SEND_SIGNAL(src, COMSIG_PROJECTILE_SELF_ON_HIT, firer, target, angle, hit_limb_zone, blocked, pierce_hit)

	if(QDELETED(src) || deletion_queued) // in case one of the above signals deleted the projectile for whatever reason
		return BULLET_ACT_BLOCK

	var/turf/target_turf = get_turf(target)
	if(target == original)
		impact_x = target.pixel_x + p_x - ICON_SIZE_X / 2
		impact_y = target.pixel_y + p_y - ICON_SIZE_Y / 2
	else
		impact_x = entry_x + movement_vector?.pixel_x * rand(0, ICON_SIZE_X / 2)
		impact_y = entry_y + movement_vector?.pixel_y * rand(0, ICON_SIZE_Y / 2)

	if(isturf(target) && hitsound_wall)
		playsound(src, hitsound_wall, clamp(vol_by_damage() + (suppressed ? 0 : 20), 0, 100), TRUE, -1)

	if(damage > 0 && (damage_type == BRUTE || damage_type == BURN) && iswallturf(target_turf) && prob(75))
		var/turf/closed/wall/target_wall = target_turf
		if(impact_effect_type && !hitscan)
			new impact_effect_type(target_wall, impact_x, impact_y)

		target_wall.add_dent(WALL_DENT_SHOT, impact_x, impact_y)
		return BULLET_ACT_HIT

	if (hitsound)
		playsound(src, hitsound, vol_by_damage(), TRUE, -1)

	if (!isliving(target))
		if(impact_effect_type && !hitscan)
			new impact_effect_type(target_turf, impact_x, impact_y)
		return BULLET_ACT_HIT

	if((blocked >= 100 || (damage && damage_type != BRUTE)) && impact_effect_type && !hitscan)
		new impact_effect_type(target_turf, impact_x, impact_y)

	var/mob/living/living_target = target
	get_embed()?.try_embed_projectile(src, target, hit_limb_zone, blocked, pierce_hit)
	var/reagent_note
	if(reagents?.reagent_list)
		reagent_note = "REAGENTS: [pretty_string_from_reagent_list(reagents.reagent_list)]"

	if(ismob(firer) && !do_not_log)
		log_combat(firer, living_target, "shot", src, reagent_note)
		return BULLET_ACT_HIT

	if(isvehicle(firer))
		var/obj/vehicle/firing_vehicle = firer
		var/list/logging_mobs = firing_vehicle.return_controllers_with_flag(VEHICLE_CONTROL_EQUIPMENT)
		if(!LAZYLEN(logging_mobs))
			logging_mobs = firing_vehicle.return_drivers()
		if(!do_not_log)
			for(var/mob/logged_mob as anything in logging_mobs)
				log_combat(logged_mob, living_target, "shot", src, "from inside [firing_vehicle][logging_mobs.len > 1 ? " with multiple occupants" : null][reagent_note ? " and contained [reagent_note]" : null]")
		return BULLET_ACT_HIT

	if(!do_not_log)
		living_target.log_message("has been shot by [firer] with [src][reagent_note ? " containing [reagent_note]" : null]", LOG_ATTACK, color="orange")
	return BULLET_ACT_HIT

/obj/projectile/proc/vol_by_damage()
	if (suppressed)
		return 5
	if (!damage)
		return 50 //if the projectile doesn't do damage, play its hitsound at 50% volume
	return clamp(damage * 0.67, 30, 100) // Multiply projectile damage by 0.67, then CLAMP the value between 30 and 1

/obj/projectile/proc/firer_deleted(datum/source)
	SIGNAL_HANDLER
	// Shooting yourself point-blank
	if (firer == original)
		original = null
	if (firer == fired_from)
		fired_from = null
	firer = null

/obj/projectile/proc/original_deleted(datum/source)
	SIGNAL_HANDLER
	original = null

/obj/projectile/proc/fired_from_deleted(datum/source)
	SIGNAL_HANDLER
	fired_from = null

/obj/projectile/proc/on_ricochet(atom/target)
	ricochets++
	if(!ricochet_auto_aim_angle || !ricochet_auto_aim_range)
		return

	var/mob/living/unlucky_sob
	var/best_angle = ricochet_auto_aim_angle
	if(firer && HAS_TRAIT(firer, TRAIT_NICE_SHOT))
		best_angle += NICE_SHOT_RICOCHET_BONUS
	for(var/mob/living/potential_target in range(ricochet_auto_aim_range, loc))
		if(potential_target.stat == DEAD || !is_in_sight(src, potential_target) || (!ricochet_shoots_firer && potential_target == firer))
			continue
		var/our_angle = abs(closer_angle_difference(angle, get_angle(loc, potential_target.loc)))
		if(our_angle < best_angle)
			best_angle = our_angle
			unlucky_sob = potential_target

	if(unlucky_sob)
		set_angle(get_angle(src, unlucky_sob.loc))
		original = unlucky_sob

/obj/projectile/Bump(atom/bumped_atom)
	SEND_SIGNAL(src, COMSIG_MOVABLE_BUMP, bumped_atom)
	if (can_hit_target(bumped_atom, bumped_atom == original, TRUE, TRUE))
		impact(bumped_atom)

/**
 * Called when the projectile hits something
 * This can either be from it bumping something,
 * or it passing over a turf/being crossed and scanning that there is infact
 * a valid target it needs to hit.
 * This target isn't however necessarily WHAT it hits
 * that is determined by process_hit and select_target.
 *
 * Furthermore, this proc shouldn't check can_hit_target - this should only be called if can hit target is already checked.
 * Also, we select_target to find what to process_hit first.
 */
/obj/projectile/proc/impact(atom/target)
	// Don't impact anything if we've been queued for deletion
	if (deletion_queued)
		return

	// never doublehit, otherwise someone may end up running into a projectile from the back
	if(impacted[target.weak_reference])
		return

	if(ricochets < ricochets_max && check_ricochet_flag(target) && check_ricochet(target) && target.handle_ricochet(src))
		on_ricochet(target)
		impacted = list() // Shoot a x-ray laser at a pair of mirrors I dare you
		ignore_source_check = TRUE // Firer is no longer immune
		maximum_range = max(0, maximum_range - reflect_range_decrease)
		ricochet_chance *= ricochet_decay_chance
		damage *= ricochet_decay_damage
		stamina *= ricochet_decay_damage
		range = maximum_range
		return

	last_impact_turf = get_turf(target)
	// Lower accurancy/longer range tradeoff. 7 is a balanced number to use.
	def_zone = ran_zone(def_zone, clamp(accurate_range - (accuracy_falloff * get_dist(last_impact_turf, starting)), 5, 100))
	var/impact_result = process_hit_loop(select_target(last_impact_turf, target))
	if (impact_result == PROJECTILE_IMPACT_PASSED)
		return
	if (hitscan)
		qdel(src)
		return
	deletion_queued = PROJECTILE_IMPACT_DELETE

/*
 * Main projectile hit loop code
 * As long as there are valid targets on the hit target's tile, we will loop through all the ones that we have not hit
 * (and thus invalidated) and try to hit them until either no targets remain or we've been deleted.
 * Should *never* be called directly, as impact() is the proc queueing projectiles for deletion
 * If you need to call this directly, you should reconsider the choices that led you to this point
 */
/obj/projectile/proc/process_hit_loop(atom/target)
	SHOULD_NOT_SLEEP(TRUE)
	PRIVATE_PROC(TRUE)

	// Don't impact anything if we've been queued for deletion
	if (deletion_queued)
		return PROJECTILE_IMPACT_PASSED

	var/turf/target_turf = get_turf(target)
	while (target && !QDELETED(src) && !deletion_queued)
		// Doublehitting can be an issue with slow projectiles or when the server is chugging
		impacted[WEAKREF(target)] = TRUE
		var/mode = prehit_pierce(target)
		if(mode == PROJECTILE_DELETE_WITHOUT_HITTING)
			return PROJECTILE_IMPACT_INTERRUPTED

		// If we've phasing through a target, first set ourselves as phasing and then try to locate a new one
		if(mode == PROJECTILE_PIERCE_PHASE)
			if(!(movement_type & PHASING))
				temporary_unstoppable_movement = TRUE
				movement_type |= PHASING
			target = select_target(target_turf, target)
			continue

		var/target_signal = SEND_SIGNAL(target, COMSIG_PROJECTILE_PREHIT, src)
		if (target_signal & PROJECTILE_INTERRUPT_HIT_PHASE)
			return PROJECTILE_IMPACT_PASSED
		if (target_signal & PROJECTILE_INTERRUPT_HIT)
			return PROJECTILE_IMPACT_INTERRUPTED

		var/self_signal = SEND_SIGNAL(src, COMSIG_PROJECTILE_SELF_PREHIT, target)
		if (self_signal & PROJECTILE_INTERRUPT_HIT_PHASE)
			return PROJECTILE_IMPACT_PASSED
		if (self_signal & PROJECTILE_INTERRUPT_HIT)
			return PROJECTILE_IMPACT_INTERRUPTED

		if(mode == PROJECTILE_PIERCE_HIT)
			pierces += 1

		// Targets should handle their impact logic on our own and if they decide that we hit them, they call our on_hit
		var/result = target.projectile_hit(src, def_zone, mode == PROJECTILE_PIERCE_HIT)
		if (result != BULLET_ACT_FORCE_PIERCE && max_pierces && pierces >= max_pierces)
			return PROJECTILE_IMPACT_SUCCESSFUL

		// If we're not piercing or phasing, delete ourselves
		if (result != BULLET_ACT_FORCE_PIERCE && mode != PROJECTILE_PIERCE_HIT && mode != PROJECTILE_PIERCE_PHASE)
			return PROJECTILE_IMPACT_SUCCESSFUL

		// We've piercing though this one, go look for a new target
		if(!(movement_type & PHASING))
			temporary_unstoppable_movement = TRUE
			movement_type |= PHASING

		target = select_target(target_turf, target)

	return PROJECTILE_IMPACT_PASSED

/**
 * Selects a target to hit from a turf
 *
 * @params
 * our_turf - Turf on which we hit the target
 * bumped - What we've impacted and why this selection was called in the first place.
 *    If set, this atom is always treated as dense by can_hit_target.
 *
 * Priority:
 * 0. Anything that is already in impacted is ignored no matter what. Furthermore, in any bracket, if the target atom parameter is in it, that's hit first.
 * Furthermore, can_hit_target is always checked. This (entire proc) is PERFORMANCE OVERHEAD!! But, it shouldn't be ""too"" bad and I frankly don't have a better *generic non snowflakey* way that I can think of right now at 3 AM.
 * FURTHERMORE, mobs/objs have a density check from can_hit_target - to hit non dense objects over a turf, you must click on them, same for mobs that usually wouldn't get hit.
 * 1. Special check on what we bumped to see if it's a border object that intercepts hitting anything behind it
 * 2. The thing originally aimed at/clicked on
 * 3. Mobs - picks lowest buckled mob to prevent scarp piggybacking memes
 * 4. Objs
 * 5. Turf
 * 6. Nothing
 */
/obj/projectile/proc/select_target(turf/our_turf, atom/bumped)
	// 1. special bumped border object check
	if((bumped?.flags_1 & ON_BORDER_1) && can_hit_target(bumped, original == bumped, TRUE, TRUE))
		return bumped
	// 2. original
	if(can_hit_target(original, TRUE, FALSE, original == bumped))
		return original
	var/list/atom/considering = list()  // let's define this ONCE
	// 3. mobs
	for(var/mob/living/iter_possible_target in our_turf)
		if(can_hit_target(iter_possible_target, iter_possible_target == original, TRUE, iter_possible_target == bumped))
			considering |= iter_possible_target
	if(length(considering))
		return pick(considering)
	// 4. objs and other dense things
	for(var/atom/potential_target as anything in our_turf)
		if(can_hit_target(potential_target, potential_target == original, TRUE, potential_target == bumped))
			considering += potential_target
	if(length(considering))
		return pick(considering)
	// 5. turf
	if(can_hit_target(our_turf, our_turf == original, TRUE, our_turf == bumped))
		return our_turf
	// 6. nothing
		// (returns null)

/// Returns true if the target atom is on our current turf and above the right layer
/// If direct target is true it's the originally clicked target.
/obj/projectile/proc/can_hit_target(atom/target, direct_target = FALSE, ignore_loc = FALSE, cross_failed = FALSE)
	if(QDELETED(target) || impacted[target.weak_reference])
		return FALSE
	if(!ignore_loc && (loc != target.loc) && !(can_hit_turfs && direct_target && loc == target))
		return FALSE
	// if pass_flags match, pass through entirely - unless direct target is set.
	if((target.pass_flags_self & pass_flags) && !direct_target)
		return FALSE
	if(HAS_TRAIT(target, TRAIT_UNHITTABLE_BY_PROJECTILES))
		if(!HAS_TRAIT(target, TRAIT_BLOCKING_PROJECTILES) && isliving(target))
			var/mob/living/living_target = target
			living_target.block_projectile_effects()
		return FALSE
	if(!ignore_source_check && firer && !direct_target)
		if(target == firer || (target == firer.loc && ismecha(firer.loc)) || (target in firer.buckled_mobs))
			return FALSE
		if(ismob(firer))
			var/mob/firer_mob = firer
			if (firer_mob.buckled == target)
				return FALSE
	if(ignored_factions?.len && ismob(target) && !direct_target)
		var/mob/target_mob = target
		if(faction_check(target_mob.faction, ignored_factions))
			return FALSE
	if(target.density || cross_failed) //This thing blocks projectiles, hit it regardless of layer/mob stuns/etc.
		return TRUE
	if(!isliving(target))
		if(isturf(target)) // non dense turfs
			return can_hit_turfs && direct_target
		if(target.layer < hit_threshhold)
			return FALSE
		else if(!direct_target) // non dense objects do not get hit unless specifically clicked
			return FALSE
	else
		var/mob/living/living_target = target
		if(direct_target)
			return TRUE
		if(living_target.stat == DEAD)
			return FALSE
		if(HAS_TRAIT(living_target, TRAIT_IMMOBILIZED) && HAS_TRAIT(living_target, TRAIT_FLOORED) && HAS_TRAIT(living_target, TRAIT_HANDS_BLOCKED))
			return FALSE
		if(hit_prone_targets)
			var/mob/living/buckled_to = living_target.lowest_buckled_mob()
			if((maximum_range - range) <= MAX_RANGE_HIT_PRONE_TARGETS) // after MAX_RANGE_HIT_PRONE_TARGETS tiles, auto-aim hit for mobs on the floor turns off
				return TRUE
			if(ignore_range_hit_prone_targets) // doesn't apply to projectiles that must hit the target in combat mode or something else, no matter what
				return TRUE
			if(buckled_to.density) // Will just be us if we're not buckled to another mob
				return TRUE
			return FALSE
		else if(living_target.body_position == LYING_DOWN)
			return FALSE
	return TRUE

/**
 * Scans if we should hit something on the turf we just moved to if we haven't already
 *
 * This proc is a little high in overhead but allows us to not snowflake CanPass in living and other things.
 */
/obj/projectile/proc/scan_moved_turf()
	// Optimally, we scan: mobs --> objs --> turf for impact
	// but, overhead is a thing and 2 for loops every time it moves is a no-go.
	// realistically, since we already do select_target in impact, we can not do that
	// and hope projectiles get refactored again in the future to have a less stupid impact detection system
	// that hopefully won't also involve a ton of overhead
	if(can_hit_target(original, TRUE, FALSE))
		impact(original) // try to hit thing clicked on
		return
	// else, try to hit mobs
	// because if we impacted original and pierced we'll already have select target'd and hit everything else we should be hitting
	for(var/mob/potential_target in loc) // so I guess we're STILL doing a for loop of mobs because living movement would otherwise have snowflake code for projectile CanPass
		// so the snowflake vs performance is pretty arguable here
		if(can_hit_target(potential_target, potential_target == original, TRUE))
			impact(potential_target)
			break

/**
 * Projectile crossed: When something enters a projectile's tile, make sure the projectile hits it if it should be hitting it.
 */
/obj/projectile/proc/on_entered(datum/source, atom/movable/entered_atom)
	SIGNAL_HANDLER
	if(can_hit_target(entered_atom, direct_target = (entered_atom == original)))
		impact(entered_atom)

/**
 * Projectile can pass through
 * Used to not even attempt to Bump() or fail to Cross() anything we already hit.
 */
/obj/projectile/CanPassThrough(atom/blocker, movement_dir, blocker_opinion)
	return impacted[blocker.weak_reference] || ..()

/**
 * Projectile moved:
 *
 * If not fired yet, do not do anything. Else,
 *
 * If temporary unstoppable movement used for piercing through things we already hit (impacted list) is set, unset it.
 * Scan turf we're now in for anything we can/should hit. This is useful for hitting non dense objects the user
 * directly clicks on, as well as for PHASING projectiles to be able to hit things at all as they don't ever Bump().
 */
/obj/projectile/Moved(atom/old_loc, movement_dir, forced, list/old_locs, momentum_change = TRUE)
	. = ..()
	if(!fired)
		return
	if(temporary_unstoppable_movement)
		temporary_unstoppable_movement = FALSE
		movement_type &= ~PHASING
	// Mostly used for making sure we can hit a non-dense object the user directly clicked on, and for penetrating projectiles that don't bump
	scan_moved_turf()

/**
 * Checks if we should pierce something.
 *
 * NOT meant to be a pure proc, since this replaces prehit() which was used to do things.
 * Return PROJECTILE_DELETE_WITHOUT_HITTING to delete projectile without hitting at all!
 */
/obj/projectile/proc/prehit_pierce(atom/target)
	if((projectile_phasing & target.pass_flags_self) && (phasing_ignore_direct_target || original != target))
		return PROJECTILE_PIERCE_PHASE
	if(projectile_piercing & target.pass_flags_self)
		return PROJECTILE_PIERCE_HIT
	if(ismovable(target))
		var/atom/movable/movable_target = target
		if(movable_target.throwing)
			return (projectile_phasing & LETPASSTHROW) ? PROJECTILE_PIERCE_PHASE : ((projectile_piercing & LETPASSTHROW)? PROJECTILE_PIERCE_HIT : PROJECTILE_PIERCE_NONE)
	return PROJECTILE_PIERCE_NONE

/obj/projectile/proc/check_ricochet(atom/target)
	var/chance = ricochet_chance * target.receive_ricochet_chance_mod
	if(firer && HAS_TRAIT(firer, TRAIT_NICE_SHOT))
		chance += NICE_SHOT_RICOCHET_BONUS
	if(ricochets < min_ricochets || prob(chance))
		return TRUE
	return FALSE

/obj/projectile/proc/check_ricochet_flag(atom/target)
	if((armor_flag in list(ENERGY, LASER)) && (target.flags_ricochet & RICOCHET_SHINY))
		return TRUE
	if((armor_flag in list(BOMB, BULLET)) && (target.flags_ricochet & RICOCHET_HARD))
		return TRUE
	return FALSE

/obj/projectile/Process_Spacemove(movement_dir = 0, continuous_move = FALSE)
	return TRUE //Bullets don't drift in space

/obj/projectile/proc/fire(fire_angle, atom/direct_target)
	LAZYINITLIST(impacted)
	if (firer)
		RegisterSignal(firer, COMSIG_QDELETING, PROC_REF(firer_deleted))
		SEND_SIGNAL(firer, COMSIG_PROJECTILE_FIRER_BEFORE_FIRE, src, fired_from, original)
	if (fired_from)
		if (firer != fired_from)
			RegisterSignal(fired_from, COMSIG_QDELETING, PROC_REF(fired_from_deleted))
		SEND_SIGNAL(fired_from, COMSIG_PROJECTILE_BEFORE_FIRE, src, original)
	if (original)
		if (firer != original)
			RegisterSignal(original, COMSIG_QDELETING, PROC_REF(original_deleted))
	if (!log_override && firer && original && !do_not_log)
		log_combat(firer, original, "fired at", src, "from [get_area_name(src, TRUE)]")
			//note: mecha projectile logging is handled in /obj/item/mecha_parts/mecha_equipment/weapon/action(). try to keep these messages roughly the sameish just for consistency's sake.
	if (direct_target && (get_dist(direct_target, get_turf(src)) <= 1)) // point blank shots
		impact(direct_target)
		if (QDELETED(src))
			return
	var/turf/starting = get_turf(src)
	if (isnum(fire_angle))
		set_angle(fire_angle)
	else 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.x + xo, 1, world.maxx), clamp(starting.y + yo, 1, world.maxy), starting.z)
		set_angle(get_angle(src, target))
	if (spread)
		set_angle(angle + (rand() - 0.5) * spread)
	original_angle = angle
	movement_vector = new(speed, angle)
	if (hitscan)
		beam_points = list()
	free_hitscan_forceMove = TRUE
	forceMove(starting)
	last_projectile_move = world.time
	fired = TRUE
	play_fov_effect(starting, 6, "gunfire", dir = NORTH, angle = angle)
	SEND_SIGNAL(src, COMSIG_PROJECTILE_FIRE)
	if (hitscan && !deletion_queued)
		record_hitscan_start()
		process_hitscan()
		if (QDELETED(src))
			return
	if (!(datum_flags & DF_ISPROCESSING))
		START_PROCESSING(SSprojectiles, src)
	// move it now to avoid potentially hitting yourself with firer-hitting projectiles
	if (!deletion_queued && !hitscan)
		process_movement(max(FLOOR(speed, 1), 1), tile_limit = TRUE)

/// Makes projectile home onto the passed target with minor inaccuracy
/obj/projectile/proc/set_homing_target(atom/target)
	if(!target || (!isturf(target) && !isturf(target.loc)))
		return FALSE
	homing = TRUE
	homing_target = target
	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/projectile/proc/set_angle(new_angle)
	if (angle == new_angle)
		return
	if(!nondirectional_sprite)
		transform = transform.TurnTo(angle, new_angle + projectile_angle)
	angle = new_angle
	if(movement_vector)
		movement_vector.set_angle(new_angle)
	if(fired && hitscan && isturf(loc))
		create_hitscan_point()

/// Same as set_angle, but the reflection continues from the center of the object that reflects it instead of the side
/obj/projectile/proc/set_angle_centered(center_turf, new_angle)
	if (angle == new_angle)
		return
	if(!nondirectional_sprite)
		transform = transform.TurnTo(angle, new_angle + projectile_angle)
	free_hitscan_forceMove = TRUE
	forceMove(center_turf)
	entry_x = 0
	entry_y = 0
	angle = new_angle
	if(movement_vector)
		movement_vector.set_angle(new_angle)
	if(fired && hitscan && isturf(loc))
		create_hitscan_point(tile_center = TRUE)

/obj/projectile/vv_edit_var(var_name, var_value)
	if(var_name == NAMEOF(src, angle))
		set_angle(var_value)
		return TRUE
	return ..()

/*
 * Projectile's process calculates the amount of pixels that it needs to move per tick and calls moveloop processing
 * There is a strict cap on how many pixels it can move in a tick to prevent them from turning into hitscans during lag
 * Path that the projectile could not finish would be stored in the overrun variable to be processed next tick
 */

/obj/projectile/process()
	last_process = world.time
	if(!loc || !fired || !movement_vector)
		fired = FALSE
		return PROCESS_KILL

	// If last tick the projectile impacted something or reached its range, don't process it
	if (deletion_queued == PROJECTILE_IMPACT_DELETE)
		ticks_to_deletion -= 1
		if (!ticks_to_deletion)
			qdel(src)
		return

	if (deletion_queued == PROJECTILE_RANGE_DELETE)
		on_range()
		return

	if(paused || !isturf(loc))
		// Compensates for pausing, so it doesn't become a hitscan projectile when unpaused from charged up ticks.
		last_projectile_move = last_process
		return

	if (hitscan)
		process_hitscan()
		return

	// Calculates how many pixels should be moved this tick, including overrun debt from the previous tick
	var/elapsed_time = world.time - last_projectile_move
	var/pixels_to_move = elapsed_time * SSprojectiles.pixels_per_decisecond * speed + overrun
	overrun = 0

	if (pixels_to_move > SSprojectiles.max_pixels_per_tick)
		overrun = pixels_to_move - SSprojectiles.max_pixels_per_tick
		pixels_to_move = SSprojectiles.max_pixels_per_tick

	overrun += MODULUS(pixels_to_move, 1)
	pixels_to_move = FLOOR(pixels_to_move, 1)
	SEND_SIGNAL(src, COMSIG_PROJECTILE_BEFORE_MOVE)

	// Registering turf entries is done here instead of a connect_loc because else it could be called multiple times per tick and waste performance
	if (last_tick_turf)
		UnregisterSignal(last_tick_turf, COMSIG_ATOM_ENTERED)

	process_movement(pixels_to_move)

	if (!QDELETED(src) && !deletion_queued && isturf(loc))
		RegisterSignal(loc, COMSIG_ATOM_ENTERED, PROC_REF(on_entered))
		last_tick_turf = loc

/*
 * Main projectile movement cycle.
 * Normal behavior moves projectiles in a straight line through tiles, but it gets trickier with homing.
 * Every pixels_per_decisecond we will stop and call process_homing(), which while a bit rough, does not have a significant performance impact
 * This proc needs to be very performant, so do not add overridable logic that can be handled in homing or animations here.
 * Return is how many tiles we've actually passed (or attempted to pass, if we ended up on a half-move)
 *
 * pixels_to_move determines how many pixels the projectile should move
 * hitscan prevents animation logic from running
 * tile_limit prevents any movements past the first tile change
 */
/obj/projectile/proc/process_movement(pixels_to_move, hitscan = FALSE, tile_limit = FALSE)
	if (!isturf(loc) || !movement_vector)
		return 0
	var/total_move_distance = pixels_to_move
	var/movements_done = 0
	last_projectile_move = world.time
	while (pixels_to_move > 0 && isturf(loc) && !QDELETED(src) && !deletion_queued)
		// Because pixel_x/y represents offset and not actual visual position of the projectile, we add 16 pixels to each and cut the excess because projectiles are not meant to be highly offset by default
		var/pixel_x_actual = pixel_x + ICON_SIZE_X / 2
		if(pixel_x_actual > ICON_SIZE_X)
			pixel_x_actual = pixel_x_actual % ICON_SIZE_X

		var/pixel_y_actual = pixel_y + ICON_SIZE_Y / 2
		if(pixel_y_actual > ICON_SIZE_Y)
			pixel_y_actual = pixel_y_actual % ICON_SIZE_Y

		var/distance_to_border = INFINITY
		// What distances do we need to move to hit the horizontal/vertical turf border
		var/x_to_border = INFINITY
		var/y_to_border = INFINITY
		// If we're moving strictly up/down/left/right then one of these can be 0 and produce div by zero
		if (movement_vector.pixel_x)
			var/x_border_dist = -pixel_x_actual
			if (movement_vector.pixel_x > 0)
				x_border_dist = ICON_SIZE_X - pixel_x_actual
			x_to_border = x_border_dist / movement_vector.pixel_x
			distance_to_border = x_to_border

		if (movement_vector.pixel_y)
			var/y_border_dist = -pixel_y_actual
			if (movement_vector.pixel_y > 0)
				y_border_dist = ICON_SIZE_Y - pixel_y_actual
			y_to_border = y_border_dist / movement_vector.pixel_y
			distance_to_border = min(distance_to_border, y_to_border)

		// Something went extremely wrong
		if (distance_to_border == INFINITY)
			stack_trace("WARNING: Projectile had an empty movement vector and tried to process")
			qdel(src)
			return movements_done

		var/distance_to_move = min(distance_to_border, pixels_to_move)
		// For homing we cap the maximum distance to move every loop
		if (homing && distance_to_move > SSprojectiles.pixels_per_decisecond)
			distance_to_move = SSprojectiles.pixels_per_decisecond

		// Figure out if we move to the next turf and if so, what its positioning relatively to us is
		var/x_shift = distance_to_move >= x_to_border ? SIGN(movement_vector.pixel_x) : 0
		var/y_shift = distance_to_move >= y_to_border ? SIGN(movement_vector.pixel_y) : 0
		var/moving_turfs = x_shift || y_shift
		// Calculate where in the turf we will be when we cross the edge.
		// This is a projectile variable because its also used in hit VFX
		entry_x = pixel_x + movement_vector.pixel_x * distance_to_move - x_shift * ICON_SIZE_X
		entry_y = pixel_y + movement_vector.pixel_y * distance_to_move - y_shift * ICON_SIZE_Y
		var/delete_distance = 0

		if (moving_turfs)
			var/turf/new_turf = locate(x + x_shift, y + y_shift, z)
			// We've hit an invalid turf, end of a z level or smth went wrong
			if (!istype(new_turf))
				qdel(src)
				return movements_done

			// Move to the next tile
			step_towards(src, new_turf)
			SEND_SIGNAL(src, COMSIG_PROJECTILE_MOVE_PROCESS_STEP)
			// We hit something and got deleted, stop the loop
			if (QDELETED(src))
				return movements_done
			if (loc != new_turf)
				moving_turfs = FALSE
			// If we've impacted something, we need to animate our movement until the actual hit
			// Otherwise the projectile visually disappears slightly before the actual impact
			// Not if we're hitscan, however, microop time!
			if (deletion_queued && !hitscan)
				// distance_to_move is how much we have to step to get to the next turf, hypotenuse is how much we need
				// to move in the next turf to get from entry to impact position
				delete_distance = distance_to_move + sqrt((impact_x - entry_x) ** 2 + (impact_y - entry_y) ** 2)

		movements_done += 1
		// We cannot move more than one turf worth of distance per loop, so this is a safe solution
		pixels_moved_last_tile += distance_to_move
		if (!deletion_queued && pixels_moved_last_tile >= ICON_SIZE_ALL)
			reduce_range()
			if (QDELETED(src))
				return movements_done
			// Similarly with range out deletion, need to calculate how many pixels we can actually move before deleting
			if (deletion_queued)
				delete_distance = distance_to_move - (ICON_SIZE_ALL - pixels_moved_last_tile)

		if (deletion_queued)
			// Hitscans don't need to wait before deleting
			if (hitscan)
				return movements_done

			// We moved to the next turf first, then impacted something
			// This means that we need to offset our visual position back to the previous turf, then figure out
			// how much we moved on the next turf (or we didn't move at all in which case we both shifts are 0 anyways)
			if (moving_turfs)
				pixel_x -= x_shift * ICON_SIZE_X
				pixel_y -= y_shift * ICON_SIZE_Y

			// Similarly to normal animate code, but use lowered deletion distance instead.
			var/delete_x = pixel_x + movement_vector.pixel_x * delete_distance
			var/delete_y = pixel_y + movement_vector.pixel_y * delete_distance
			// In order to keep a consistent speed, calculate at what point between ticks we get deleted
			var/animate_time = world.tick_lag * delete_distance / total_move_distance
			// Sometimes we need to move *just a bit* more than we can afford this tick - in this case, delete a tick after
			// so we don't disappear before impact. This shouldn't be more than 1, ever.
			if (delete_distance > pixels_to_move)
				ticks_to_deletion += 1
			// We can use animation chains to visually disappear between ticks.
			if (!move_animate(delete_x, delete_y, animate_time, deleting = TRUE))
				animate(src, pixel_x = delete_x, pixel_y = delete_y, time = animate_time, flags = ANIMATION_PARALLEL | ANIMATION_CONTINUE)
				animate(alpha = 0, time = 0, flags = ANIMATION_CONTINUE)
			return movements_done

		pixels_to_move -= distance_to_move
		// animate() instantly changes pixel_x/y values and just interpolates them client-side so next loop processes properly
		if (hitscan)
			pixel_x = entry_x
			pixel_y = entry_y
		else
			// We need to shift back to the tile we were on before moving
			pixel_x -= x_shift * ICON_SIZE_X
			pixel_y -= y_shift * ICON_SIZE_Y
			if (!move_animate(entry_x, entry_y))
				animate(src, pixel_x = entry_x, pixel_y = entry_y, time = world.tick_lag * distance_to_move / total_move_distance, flags = ANIMATION_PARALLEL | ANIMATION_CONTINUE)

		// Homing caps our movement speed per loop while leaving per tick speed intact, so we can just call process_homing every loop here
		if (homing)
			process_homing()

		// We've hit a timestop field, abort any remaining movement
		if (paused)
			return movements_done

		// Prevents long-range high-speed projectiles from ruining the server performance by moving 100 tiles per tick when subsystem is set to a high cap
		if (TICK_CHECK)
			// If we ran out of time, add whatever distance we're yet to pass to overrun debt to be processed next tick and break the loop
			overrun += pixels_to_move
			return movements_done

		if (tile_limit && moving_turfs)
			return movements_done

	return movements_done

/// Called every time projectile animates its movement, in case child wants to have custom animations.
/// Returning TRUE cancels normal animation
/obj/projectile/proc/move_animate(animate_x, animate_y, animate_time = world.tick_lag, deleting = FALSE)
	return FALSE

/// Called every projectile loop for homing or alternatively, custom trajectory changes.
/obj/projectile/proc/process_homing()
	if(!homing_target)
		return
	var/datum/point/new_point = RETURN_PRECISE_POINT(homing_target)
	new_point.pixel_x += homing_offset_x
	new_point.pixel_y += homing_offset_y
	var/new_angle = closer_angle_difference(angle, angle_between_points(RETURN_PRECISE_POINT(src), new_point))
	set_angle(angle + clamp(new_angle, -homing_turn_speed, homing_turn_speed))

/// Attempts to force the projectile to move until the subsystem runs out of processing time, the projectile impacts something or gets frozen by timestop
/obj/projectile/proc/process_hitscan()
	if (isnull(movement_vector))
		qdel(src)
		return

	while (isturf(loc) && !QDELETED(src))
		process_movement(ICON_SIZE_ALL, hitscan = TRUE)

		if (QDELETED(src))
			return

		if (!TICK_CHECK && !paused)
			continue

		create_hitscan_point()
		// Create tracers if we get timestopped or lagchunk so there aren't weird delays
		generate_hitscan_tracers(impact_point = FALSE, impact_visual = FALSE)
		record_hitscan_start(offset = FALSE)
		return

/// Creates (or wipes clean) list of tracer keypoints and creates a first point.
/obj/projectile/proc/record_hitscan_start(offset = TRUE)
	if (isnull(beam_points))
		beam_points = list()
	else
		QDEL_LIST_ASSOC(beam_points)
		QDEL_NULL(last_point)
	last_point = RETURN_PRECISE_POINT(src)
	// If moving, increment its position a bit to prevent it from looking like its coming from firer's ass
	if (offset && !isnull(movement_vector))
		last_point.increment(movement_vector.pixel_x * MUZZLE_EFFECT_PIXEL_INCREMENT, movement_vector.pixel_y * MUZZLE_EFFECT_PIXEL_INCREMENT)
	beam_points[last_point] = null

/// Creates a new keypoint in which the tracer will split
/obj/projectile/proc/create_hitscan_point(impact = FALSE, tile_center = FALSE, broken_segment = FALSE)
	var/atom/handle_atom = last_impact_turf || src
	var/atom/used_point = tile_center ? loc : src
	var/datum/point/new_point = impact ? new /datum/point(handle_atom.x, handle_atom.y, handle_atom.z, impact_x, impact_y) : RETURN_PRECISE_POINT(used_point)
	if (!broken_segment)
		beam_points[last_point] = new_point
	beam_points[new_point] = null
	last_point = new_point

/obj/projectile/forceMove(atom/target)
	if (!hitscan || isnull(beam_points))
		return ..()
	create_hitscan_point()
	. = ..()
	if(!isturf(loc) || !isturf(target) || !z || QDELETED(src) || deletion_queued)
		return
	if (isnull(movement_vector) || free_hitscan_forceMove)
		return
	// Create firing VFX and start a new chain because we most likely got teleported
	generate_hitscan_tracers(impact_point = FALSE)
	original_angle = angle
	spawned_muzzle = FALSE
	record_hitscan_start(offset = FALSE)

/obj/projectile/proc/generate_hitscan_tracers(impact_point = TRUE, impact_visual = TRUE)
	if (!length(beam_points))
		return

	if (impact_point)
		create_hitscan_point(impact = TRUE)

	if (tracer_type)
		// Stores all turfs we've created light effects on, in order to not dupe them if we enter a reflector loop
		// Uses an assoc list for performance reasons
		var/list/passed_turfs = list()
		for (var/beam_point in beam_points)
			generate_tracer(beam_point, passed_turfs)

	if (muzzle_type && !spawned_muzzle)
		spawned_muzzle = TRUE
		var/datum/point/start_point = beam_points[1]
		var/atom/movable/muzzle_effect = new muzzle_type(loc)
		start_point.move_atom_to_src(muzzle_effect)
		var/matrix/matrix = new
		matrix.Turn(original_angle)
		muzzle_effect.transform = matrix
		muzzle_effect.color =  color
		muzzle_effect.set_light(muzzle_flash_range, muzzle_flash_intensity, muzzle_flash_color_override || color)
		QDEL_IN(muzzle_effect, PROJECTILE_TRACER_DURATION)

	if (impact_type && impact_visual)
		var/atom/movable/impact_effect = new impact_type(loc)
		last_point.move_atom_to_src(impact_effect)
		var/matrix/matrix = new
		matrix.Turn(angle)
		impact_effect.transform = matrix
		impact_effect.color =  color
		impact_effect.set_light(impact_light_range, impact_light_intensity, impact_light_color_override || color)
		QDEL_IN(impact_effect, PROJECTILE_TRACER_DURATION)

/obj/projectile/proc/generate_tracer(datum/point/start_point, list/passed_turfs)
	if (isnull(beam_points[start_point]))
		return

	var/datum/point/end_point = beam_points[start_point]
	var/datum/point/midpoint = point_midpoint_points(start_point, end_point)
	var/obj/effect/projectile/tracer/tracer_effect = new tracer_type(midpoint.return_turf())
	tracer_effect.apply_vars(
		angle_override = angle_between_points(start_point, end_point),
		p_x = midpoint.pixel_x,
		p_y = midpoint.pixel_y,
		color_override = color,
		scaling = pixel_length_between_points(start_point, end_point) / ICON_SIZE_ALL
	)
	SET_PLANE_EXPLICIT(tracer_effect, GAME_PLANE, src)

	QDEL_IN(tracer_effect, PROJECTILE_TRACER_DURATION)

	if (!hitscan_light_range || !hitscan_light_intensity)
		return

	var/list/turf/light_line = get_line(start_point.return_turf(), end_point.return_turf())
	for (var/turf/light_turf as anything in light_line)
		if (passed_turfs[light_turf])
			continue
		passed_turfs[light_turf] = TRUE
		QDEL_IN(new /obj/effect/abstract/projectile_lighting(light_turf, hitscan_light_color_override || color, hitscan_light_range, hitscan_light_intensity), PROJECTILE_TRACER_DURATION)

/**
 * Aims the projectile at a target.
 *
 * Must be passed at least one of a target or a list of click parameters.
 * If only passed the click modifiers the source atom must be a mob with a client.
 *
 * Arguments:
 * - [target][/atom]: (Optional) The thing that the projectile will be aimed at.
 * - [source][/atom]: The initial location of the projectile or the thing firing it.
 * - [modifiers][/list]: (Optional) A list of click parameters to apply to this operation.
 * - deviation: (Optional) How the trajectory should deviate from the target in degrees.
 *   - //Spread is FORCED!
 */
/obj/projectile/proc/aim_projectile(atom/target, atom/source, list/modifiers = null, deviation = 0)
	if(!(isnull(modifiers) || islist(modifiers)))
		stack_trace("WARNING: Projectile [type] fired with non-list modifiers, likely was passed click params. Modifiers were the following: [modifiers]")
		modifiers = null

	var/turf/source_loc = get_turf(source)
	var/turf/target_loc = get_turf(target)

	if(isnull(source_loc))
		stack_trace("WARNING: Projectile [type] fired from nullspace.")
		qdel(src)
		return FALSE

	if(fired)
		stack_trace("WARNING: Projectile [type] was aimed after already being fired.")
		qdel(src)
		return FALSE

	free_hitscan_forceMove = TRUE
	forceMove(source_loc)
	starting = source_loc
	pixel_x = source.pixel_x
	pixel_y = source.pixel_y
	original = target

	// Trim off excess pixel_x/y by converting them into turf offset
	if (abs(pixel_x) > ICON_SIZE_X / 2)
		for (var/i in 1 to floor(abs(pixel_x) + ICON_SIZE_X / 2) / ICON_SIZE_X)
			var/turf/new_loc = get_step(source_loc, pixel_x > 0 ? EAST : WEST)
			if (!istype(new_loc))
				break
			source_loc = new_loc
		pixel_x = pixel_x % (ICON_SIZE_X / 2)

	if (abs(pixel_y) > ICON_SIZE_Y / 2)
		for (var/i in 1 to floor(abs(pixel_y) + ICON_SIZE_Y / 2) / ICON_SIZE_Y)
			var/turf/new_loc = get_step(source_loc, pixel_y > 0 ? NORTH : SOUTH)
			if (!istype(new_loc))
				break
			source_loc = new_loc
		pixel_y = pixel_y % (ICON_SIZE_X / 2)

	if(length(modifiers))
		var/list/calculated = calculate_projectile_angle_and_pixel_offsets(source, target_loc && target, modifiers)
		p_x = calculated[2]
		p_y = calculated[3]
		set_angle(calculated[1] + deviation)
		return TRUE

	if(target_loc)
		yo = target_loc.y - source_loc.y
		xo = target_loc.x - source_loc.x
		set_angle(get_angle(src, target_loc) + deviation)
		return TRUE

	stack_trace("WARNING: Projectile [type] fired without a target or mouse parameters to aim with.")
	qdel(src)
	return FALSE

/**
 * Calculates the pixel offsets and angle that a projectile should be launched at.
 *
 * Arguments:
 * - [source][/atom]: The thing that the projectile is being shot from.
 * - [target][/atom]: (Optional) The thing that the projectile is being shot at.
 *   - If this is not provided the  source atom must be a mob with a client.
 * - [modifiers][/list]: A list of click parameters used to modify the shot angle.
 */
/proc/calculate_projectile_angle_and_pixel_offsets(atom/source, atom/target, modifiers)
	var/angle = 0
	var/p_x = LAZYACCESS(modifiers, ICON_X) ? text2num(LAZYACCESS(modifiers, ICON_X)) : ICON_SIZE_X / 2 // ICON_(X|Y) are measured from the bottom left corner of the icon.
	var/p_y = LAZYACCESS(modifiers, ICON_Y) ? text2num(LAZYACCESS(modifiers, ICON_Y)) : ICON_SIZE_Y / 2 // This centers the target if modifiers aren't passed.

	if(target)
		var/turf/source_loc = get_turf(source)
		var/turf/target_loc = get_turf(target)
		var/dx = ((target_loc.x - source_loc.x) * ICON_SIZE_X) + (target.pixel_x - source.pixel_x) + (p_x - (ICON_SIZE_X / 2))
		var/dy = ((target_loc.y - source_loc.y) * ICON_SIZE_Y) + (target.pixel_y - source.pixel_y) + (p_y - (ICON_SIZE_Y / 2))

		angle = ATAN2(dy, dx)
		return list(angle, p_x, p_y)

	if(!ismob(source) || !LAZYACCESS(modifiers, SCREEN_LOC))
		CRASH("Can't make trajectory calculations without a target or click modifiers and a client.")

	var/mob/user = source
	if(!user.client)
		CRASH("Can't make trajectory calculations without a target or click modifiers and a client.")

	//Split screen-loc up into X+Pixel_X and Y+Pixel_Y
	var/list/screen_loc_params = splittext(LAZYACCESS(modifiers, 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/tx = (text2num(screen_loc_X[1]) - 1) * ICON_SIZE_X + text2num(screen_loc_X[2])
	var/ty = (text2num(screen_loc_Y[1]) - 1) * ICON_SIZE_Y + text2num(screen_loc_Y[2])

	//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 = view_to_pixels(user.client.view)

	var/ox = round(screenview[1] * 0.5) - user.client.pixel_x //"origin" x
	var/oy = round(screenview[2] * 0.5) - user.client.pixel_y //"origin" y
	angle = ATAN2(tx - oy, ty - ox)
	return list(angle, p_x, p_y)

/obj/projectile/experience_pressure_difference()
	return

/**
 * Is this projectile considered "hostile"?
 *
 * By default all projectiles which deal damage or impart crowd control effects (including stamina) are hostile
 *
 * This is NOT used for pacifist checks, that's handled by [/obj/item/ammo_casing/var/harmful]
 * This is used in places such as AI responses to determine if they're being threatened or not (among other places)
 */
/obj/projectile/proc/is_hostile_projectile()
	if(damage > 0 || stamina > 0)
		return TRUE

	if(paralyze + stun + immobilize + knockdown > 0 SECONDS)
		return TRUE

	return FALSE

///Checks if the projectile can embed into someone
/obj/projectile/proc/can_embed_into(atom/hit)
	return shrapnel_type && get_embed()?.can_embed(src, hit)

/// Reflects the projectile off of something
/obj/projectile/proc/reflect(atom/hit_atom)
	if(!starting)
		return
	var/new_x = starting.x + pick(0, 0, 0, 0, 0, -1, 1, -2, 2)
	var/new_y = starting.y + pick(0, 0, 0, 0, 0, -1, 1, -2, 2)
	var/turf/current_tile = get_turf(hit_atom)

	// redirect the projectile
	original = locate(new_x, new_y, z)
	starting = current_tile
	firer = hit_atom
	yo = new_y - current_tile.y
	xo = new_x - current_tile.x
	var/new_angle_s = angle + rand(120, 240)
	while(new_angle_s > 180) // Translate to regular projectile degrees
		new_angle_s -= 360
	set_angle(new_angle_s)

/// Fire a projectile from this atom at another atom
/atom/proc/fire_projectile(projectile_type, atom/target, sound, firer, list/ignore_targets = list())
	if (!isnull(sound))
		playsound(src, sound, vol = 100, vary = TRUE)

	var/turf/startloc = get_turf(src)
	var/obj/projectile/bullet = new projectile_type(startloc)
	bullet.starting = startloc
	for (var/atom/thing as anything in ignore_targets)
		bullet.impacted[WEAKREF(thing)] = TRUE
	bullet.firer = firer || src
	bullet.fired_from = src
	bullet.yo = target.y - startloc.y
	bullet.xo = target.x - startloc.x
	bullet.original = target
	bullet.aim_projectile(target, src)
	bullet.fire()
	return bullet

#undef MOVES_HITSCAN
#undef MUZZLE_EFFECT_PIXEL_INCREMENT

/// Fetches, or lazyloads, our embedding datum
/obj/projectile/proc/get_embed()
	RETURN_TYPE(/datum/embedding)
	if (embed_data)
		return embed_data
	if (embed_type)
		embed_data = new embed_type()
	return embed_data

/// Sets our embedding datum to a different one. Can also take types
/obj/projectile/proc/set_embed(datum/embedding/new_embed, dont_delete = FALSE)
	if (new_embed == embed_data)
		return

	if (!isnull(embed_data) && !dont_delete)
		qdel(embed_data)

	if (ispath(new_embed))
		new_embed = new new_embed()

	embed_data = new_embed