Merge branch 'master' of https://github.com/Citadel-Station-13/Citadel-Station-13 into master

code/modules/food_and_drinks/food/snacks.dm

@@ -97,9 +97,12 @@ All foods are distributed among various categories. Use common sense.
 	return
 
 
-/obj/item/reagent_containers/food/snacks/attack(mob/living/M, mob/living/user, def_zone)
+/obj/item/reagent_containers/food/snacks/attack(mob/living/M, mob/living/user, attackchain_flags = NONE, damage_multiplier = 1)
 	if(user.a_intent == INTENT_HARM)
 		return ..()
+	INVOKE_ASYNC(src, .proc/attempt_forcefeed, M, user)
+
+/obj/item/reagent_containers/food/snacks/proc/attempt_forcefeed(mob/living/M, mob/living/user)
 	if(!eatverb)
 		eatverb = pick("bite","chew","nibble","gnaw","gobble","chomp")
 	if(!reagents.total_volume)						//Shouldn't be needed but it checks to see if it has anything left in it.

code/modules/hydroponics/hydroitemdefines.dm

@@ -103,6 +103,7 @@
 	throwforce = 5
 	throw_speed = 2
 	throw_range = 3
+	attack_speed = CLICK_CD_MELEE
 	w_class = WEIGHT_CLASS_BULKY
 	flags_1 = CONDUCT_1
 	armour_penetration = 20
@@ -125,9 +126,12 @@
 			playsound(src,pick('sound/misc/desceration-01.ogg','sound/misc/desceration-02.ogg','sound/misc/desceration-01.ogg') ,50, 1, -1)
 	return (BRUTELOSS)
 
-/obj/item/scythe/pre_attack(atom/A, mob/living/user, params)
+/obj/item/scythe/pre_attack(atom/A, mob/living/user, params, attackchain_flags, damage_multiplier)
+	. = ..()
+	if(. & STOP_ATTACK_PROC_CHAIN)
+		return
 	if(swiping || !istype(A, /obj/structure/spacevine) || get_turf(A) == get_turf(user))
-		return ..()
+		return
 	else
 		var/turf/user_turf = get_turf(user)
 		var/dir_to_target = get_dir(user_turf, get_turf(A))
@@ -138,11 +142,12 @@
 			var/turf/T = get_step(user_turf, turn(dir_to_target, i))
 			for(var/obj/structure/spacevine/V in T)
 				if(user.Adjacent(V))
-					melee_attack_chain(user, V)
+					melee_attack_chain(user, V, attackchain_flags = ATTACK_IGNORE_CLICKDELAY)
 					stam_gain += 5					//should be hitcost
 		swiping = FALSE
 		stam_gain += 2								//Initial hitcost
 		user.adjustStaminaLoss(-stam_gain)
+		user.DelayNextAction()
 
 // *************************************
 // Nutrient defines for hydroponics
@@ -192,4 +197,4 @@
 /obj/item/reagent_containers/glass/bottle/killer/pestkiller
 	name = "bottle of pest spray"
 	desc = "Contains a pesticide."
-	list_reagents = list(/datum/reagent/toxin/pestkiller = 50)
+	list_reagents = list(/datum/reagent/toxin/pestkiller = 50)

code/modules/instruments/songs/_song.dm

@@ -2,6 +2,12 @@
 #define MUSIC_MAXLINES 1000
 #define MUSIC_MAXLINECHARS 300
 
+/**
+  * # Song datum
+  *
+  * These are the actual backend behind instruments.
+  * They attach to an atom and provide the editor + playback functionality.
+  */
 /datum/song
 	/// Name of the song
 	var/name = "Untitled"
@@ -15,6 +21,9 @@
 	/// delay between notes in deciseconds
 	var/tempo = 5
 
+	/// How far we can be heard
+	var/instrument_range = 15
+
 	/// Are we currently playing?
 	var/playing = FALSE
 
@@ -53,17 +62,24 @@
 
 	/////////////////// Playing variables ////////////////
 	/**
-	  * Only used in synthesized playback - The chords we compiled. Non assoc list of lists:
-	  * list(list(key1, key2, key3..., tempo_divisor), list(key1, key2..., tempo_divisor), ...)
-	  * tempo_divisor always exists
-	  * if key1 (and so if there's no keys) doesn't exist it's a rest
+	  * Build by compile_chords()
+	  * Must be rebuilt on instrument switch.
 	  * Compilation happens when we start playing and is cleared after we finish playing.
+	  * Format: list of chord lists, with chordlists having (key1, key2, key3, tempodiv)
 	  */
 	var/list/compiled_chords
+	/// Current section of a long chord we're on, so we don't need to make a billion chords, one for every unit ticklag.
+	var/elapsed_delay
+	/// Amount of delay to wait before playing the next chord
+	var/delay_by
+	/// Current chord we're on.
+	var/current_chord
 	/// Channel as text = current volume percentage but it's 0 to 100 instead of 0 to 1.
 	var/list/channels_playing = list()
 	/// List of channels that aren't being used, as text. This is to prevent unnecessary freeing and reallocations from SSsounds/SSinstruments.
 	var/list/channels_idle = list()
+	/// Person playing us
+	var/mob/user_playing
 	//////////////////////////////////////////////////////
 
 	/// Last world.time we checked for who can hear us
@@ -72,8 +88,6 @@
 	var/list/hearing_mobs
 	/// If this is enabled, some things won't be strictly cleared when they usually are (liked compiled_chords on play stop)
 	var/debug_mode = FALSE
-	/// Last time we processed decay
-	var/last_process_decay
 	/// Max sound channels to occupy
 	var/max_sound_channels = CHANNELS_PER_INSTRUMENT
 	/// Current channels, so we can save a length() call.
@@ -113,7 +127,7 @@
 	var/cached_exponential_dropoff = 1.045
 	/////////////////////////////////////////////////////////////////////////
 
-/datum/song/New(atom/parent, list/instrument_ids)
+/datum/song/New(atom/parent, list/instrument_ids, new_range)
 	SSinstruments.on_song_new(src)
 	lines = list()
 	tempo = sanitize_tempo(tempo)
@@ -125,6 +139,8 @@
 	hearing_mobs = list()
 	volume = clamp(volume, min_volume, max_volume)
 	update_sustain()
+	if(new_range)
+		instrument_range = new_range
 
 /datum/song/Destroy()
 	stop_playing()
@@ -135,12 +151,15 @@
 	parent = null
 	return ..()
 
+/**
+  * Checks and stores which mobs can hear us. Terminates sounds for mobs that leave our range.
+  */
 /datum/song/proc/do_hearcheck()
 	last_hearcheck = world.time
 	var/list/old = hearing_mobs.Copy()
 	hearing_mobs.len = 0
 	var/turf/source = get_turf(parent)
-	for(var/mob/M in get_hearers_in_view(15, source))
+	for(var/mob/M in get_hearers_in_view(instrument_range, source))
 		if(!(M?.client?.prefs?.toggles & SOUND_INSTRUMENTS))
 			continue
 		hearing_mobs[M] = get_dist(M, source)
@@ -148,10 +167,15 @@
 	for(var/i in exited)
 		terminate_sound_mob(i)
 
-/// I can either be a datum, id, or path (if the instrument has no id).
+/**
+  * Sets our instrument, caching anything necessary for faster accessing. Accepts an ID, typepath, or instantiated instrument datum.
+  */
 /datum/song/proc/set_instrument(datum/instrument/I)
+	terminate_all_sounds()
+	var/old_legacy
 	if(using_instrument)
 		using_instrument.songs_using -= src
+		old_legacy = (using_instrument.instrument_flags & INSTRUMENT_LEGACY)
 	using_instrument = null
 	cached_samples = null
 	cached_legacy_ext = null
@@ -162,7 +186,7 @@
 	if(istype(I))
 		using_instrument = I
 		I.songs_using += src
-		var/instrument_legacy = CHECK_BITFIELD(I.instrument_flags, INSTRUMENT_LEGACY)
+		var/instrument_legacy = (I.instrument_flags & INSTRUMENT_LEGACY)
 		if(instrument_legacy)
 			cached_legacy_ext = I.legacy_instrument_ext
 			cached_legacy_dir = I.legacy_instrument_path
@@ -170,23 +194,37 @@
 		else
 			cached_samples = I.samples
 			legacy = FALSE
+		if(isnull(old_legacy) || (old_legacy != instrument_legacy))
+			if(playing)
+				compile_chords()
 
-/// THIS IS A BLOCKING CALL.
+/**
+  * Attempts to start playing our song.
+  */
 /datum/song/proc/start_playing(mob/user)
 	if(playing)
 		return
 	if(!using_instrument?.ready())
 		to_chat(user, "<span class='warning'>An error has occured with [src]. Please reset the instrument.</span>")
 		return
+	compile_chords()
+	if(!length(compiled_chords))
+		to_chat(user, "<span class='warning'>Song is empty.</span>")
+		return
 	playing = TRUE
-	updateDialog()
+	updateDialog(user_playing)
 	//we can not afford to runtime, since we are going to be doing sound channel reservations and if we runtime it means we have a channel allocation leak.
 	//wrap the rest of the stuff to ensure stop_playing() is called.
-	last_process_decay = world.time
+	do_hearcheck()
+	elapsed_delay = 0
+	delay_by = 0
+	current_chord = 1
+	user_playing = user
 	START_PROCESSING(SSinstruments, src)
-	. = do_play_lines(user)
-	stop_playing()
 
+/**
+  * Stops playing, terminating all sounds if in synthesized mode. Clears hearing_mobs.
+  */
 /datum/song/proc/stop_playing()
 	if(!playing)
 		return
@@ -196,42 +234,93 @@
 	STOP_PROCESSING(SSinstruments, src)
 	terminate_all_sounds(TRUE)
 	hearing_mobs.len = 0
-	updateDialog()
+	user_playing = null
 
-/// THIS IS A BLOCKING CALL.
-/datum/song/proc/do_play_lines(user)
-	if(!playing)
+/**
+  * Processes our song.
+  */
+/datum/song/proc/process_song(wait)
+	if(!length(compiled_chords) || should_stop_playing(user_playing))
+		stop_playing()
 		return
-	do_hearcheck()
-	if(legacy)
-		do_play_lines_legacy(user)
-	else
-		do_play_lines_synthesized(user)
+	var/list/chord = compiled_chords[current_chord]
+	if(++elapsed_delay >= delay_by)
+		play_chord(chord)
+		elapsed_delay = 0
+		delay_by = tempodiv_to_delay(chord[length(chord)])
+		current_chord++
+		if(current_chord > length(compiled_chords))
+			if(repeat)
+				repeat--
+				current_chord = 1
+				return
+			else
+				stop_playing()
+				return
 
+/**
+  * Converts a tempodiv to ticks to elapse before playing the next chord, taking into account our tempo.
+  */
+/datum/song/proc/tempodiv_to_delay(tempodiv)
+	if(!tempodiv)
+		tempodiv = 1		// no division by 0. some song converters tend to use 0 for when it wants to have no div, for whatever reason.
+	return max(1, round((tempo/tempodiv) / world.tick_lag, 1))
+
+/**
+  * Compiles chords.
+  */
+/datum/song/proc/compile_chords()
+	legacy? compile_legacy() : compile_synthesized()
+
+/**
+  * Plays a chord.
+  */
+/datum/song/proc/play_chord(list/chord)
+	// last value is timing information
+	for(var/i in 1 to (length(chord) - 1))
+		legacy? playkey_legacy(chord[i][1], chord[i][2], chord[i][3], user_playing) : playkey_synth(chord[i], user_playing)
+
+/**
+  * Checks if we should halt playback.
+  */
 /datum/song/proc/should_stop_playing(mob/user)
 	return QDELETED(parent) || !using_instrument || !playing
 
+/**
+  * Sanitizes tempo to a value that makes sense and fits the current world.tick_lag.
+  */
 /datum/song/proc/sanitize_tempo(new_tempo)
 	new_tempo = abs(new_tempo)
 	return clamp(round(new_tempo, world.tick_lag), world.tick_lag, 5 SECONDS)
 
+/**
+  * Gets our beats per minute based on our tempo.
+  */
 /datum/song/proc/get_bpm()
 	return 600 / tempo
 
+/**
+  * Sets our tempo from a beats-per-minute, sanitizing it to a valid number first.
+  */
 /datum/song/proc/set_bpm(bpm)
 	tempo = sanitize_tempo(600 / bpm)
 
-/// Updates the window for our user. Override in subtypes.
-/datum/song/proc/updateDialog(mob/user = usr)
+/**
+  * Updates the window for our users. Override down the line.
+  */
+/datum/song/proc/updateDialog(mob/user)
 	ui_interact(user)
 
 /datum/song/process(wait)
 	if(!playing)
 		return PROCESS_KILL
-	var/delay = world.time - last_process_decay
-	process_decay(delay)
-	last_process_decay = world.time
+	// it's expected this ticks at every world.tick_lag. if it lags, do not attempt to catch up.
+	process_song(world.tick_lag)
+	process_decay(world.tick_lag)
 
+/**
+  * Updates our cached linear/exponential falloff stuff, saving calculations down the line.
+  */
 /datum/song/proc/update_sustain()
 	// Exponential is easy
 	cached_exponential_dropoff = sustain_exponential_dropoff
@@ -241,21 +330,33 @@
 	var/volume_decrease_per_decisecond = volume_diff / target_duration
 	cached_linear_dropoff = volume_decrease_per_decisecond
 
+/**
+  * Setter for setting output volume.
+  */
 /datum/song/proc/set_volume(volume)
 	src.volume = clamp(volume, max(0, min_volume), min(100, max_volume))
 	update_sustain()
 	updateDialog()
 
+/**
+  * Setter for setting how low the volume has to get before a note is considered "dead" and dropped
+  */
 /datum/song/proc/set_dropoff_volume(volume)
 	sustain_dropoff_volume = clamp(volume, INSTRUMENT_MIN_SUSTAIN_DROPOFF, 100)
 	update_sustain()
 	updateDialog()
 
+/**
+  * Setter for setting exponential falloff factor.
+  */
 /datum/song/proc/set_exponential_drop_rate(drop)
 	sustain_exponential_dropoff = clamp(drop, INSTRUMENT_EXP_FALLOFF_MIN, INSTRUMENT_EXP_FALLOFF_MAX)
 	update_sustain()
 	updateDialog()
 
+/**
+  * Setter for setting linear falloff duration.
+  */
 /datum/song/proc/set_linear_falloff_duration(duration)
 	sustain_linear_duration = clamp(duration, 0.1, INSTRUMENT_MAX_TOTAL_SUSTAIN)
 	update_sustain()
@@ -277,10 +378,8 @@
 // subtype for handheld instruments, like violin
 /datum/song/handheld
 
-/datum/song/handheld/updateDialog(mob/user = usr)
-	if(user.machine != src)
-		return
-	parent.ui_interact(user)
+/datum/song/handheld/updateDialog(mob/user)
+	parent.ui_interact(user || usr)
 
 /datum/song/handheld/should_stop_playing(mob/user)
 	. = ..()
@@ -292,10 +391,8 @@
 // subtype for stationary structures, like pianos
 /datum/song/stationary
 
-/datum/song/stationary/updateDialog(mob/user = usr)
-	if(user.machine != src)
-		return
-	parent.ui_interact(user)
+/datum/song/stationary/updateDialog(mob/user)
+	parent.ui_interact(user || usr)
 
 /datum/song/stationary/should_stop_playing(mob/user)
 	. = ..()

code/modules/instruments/songs/play_legacy.dm

@@ -1,48 +1,52 @@
-/// Playing legacy instruments - None of the "advanced" like sound reservations and decay are invoked.
-/datum/song/proc/do_play_lines_legacy(mob/user)
-	while(repeat >= 0)
-		var/cur_oct[7]
-		var/cur_acc[7]
-		for(var/i = 1 to 7)
-			cur_oct[i] = 3
-			cur_acc[i] = "n"
+/**
+  * Compiles our lines into "chords" with filenames for legacy playback. This makes there have to be a bit of lag at the beginning of the song, but repeats will not have to parse it again, and overall playback won't be impacted by as much lag.
+  */
+/datum/song/proc/compile_legacy()
+	if(!length(src.lines))
+		return
+	var/list/lines = src.lines		//cache for hyepr speed!
+	compiled_chords = list()
+	var/list/octaves = list(3, 3, 3, 3, 3, 3, 3)
+	var/list/accents = list("n", "n", "n", "n", "n", "n", "n")
+	for(var/line in lines)
+		var/list/chords = splittext(lowertext(line), ",")
+		for(var/chord in chords)
+			var/list/compiled_chord = list()
+			var/tempodiv = 1
+			var/list/notes_tempodiv = splittext(chord, "/")
+			var/len = length(notes_tempodiv)
+			if(len >= 2)
+				tempodiv = text2num(notes_tempodiv[2])
+			if(len)			//some dunkass is going to do ,,,, to make 3 rests instead of ,/1 because there's no standardization so let's be prepared for that.
+				var/list/notes = splittext(notes_tempodiv[1], "-")
+				for(var/note in notes)
+					if(length(note) == 0)
+						continue
+					// 1-7, A-G
+					var/key = text2ascii(note) - 96
+					if((key < 1) || (key > 7))
+						continue
+					for(var/i in 2 to length(note))
+						var/oct_acc = copytext(note, i, i + 1)
+						var/num = text2num(oct_acc)
+						if(!num)		//it's an accidental
+							accents[key] = oct_acc		//if they misspelled it/fucked up that's on them lmao, no safety checks.
+						else	//octave
+							octaves[key] = clamp(num, octave_min, octave_max)
+					compiled_chord[++compiled_chord.len] = list(key, accents[key], octaves[key])
+			compiled_chord += tempodiv		//this goes last
+			if(length(compiled_chord))
+				compiled_chords[++compiled_chords.len] = compiled_chord
 
-		for(var/line in lines)
-			for(var/beat in splittext(lowertext(line), ","))
-				if(should_stop_playing(user))
-					return
-				var/list/notes = splittext(beat, "/")
-				if(length(notes))		//because some jack-butts are going to do ,,,, to symbolize 3 rests instead of something reasonable like ,/1.
-					for(var/note in splittext(notes[1], "-"))
-						if(length(note) == 0)
-							continue
-						var/cur_note = text2ascii(note) - 96
-						if(cur_note < 1 || cur_note > 7)
-							continue
-						for(var/i=2 to length(note))
-							var/ni = copytext(note,i,i+1)
-							if(!text2num(ni))
-								if(ni == "#" || ni == "b" || ni == "n")
-									cur_acc[cur_note] = ni
-								else if(ni == "s")
-									cur_acc[cur_note] = "#" // so shift is never required
-							else
-								cur_oct[cur_note] = text2num(ni)
-						playnote_legacy(cur_note, cur_acc[cur_note], cur_oct[cur_note])
-				if(notes.len >= 2 && text2num(notes[2]))
-					sleep(sanitize_tempo(tempo / text2num(notes[2])))
-				else
-					sleep(tempo)
-		if(should_stop_playing(user))
-			return
-		repeat--
-		updateDialog()
-	repeat = 0
-
-// note is a number from 1-7 for A-G
-// acc is either "b", "n", or "#"
-// oct is 1-8 (or 9 for C)
-/datum/song/proc/playnote_legacy(note, acc as text, oct)
+/**
+  * Proc to play a legacy note. Just plays the sound to hearing mobs (and does hearcheck if necessary), no fancy channel/sustain/management.
+  *
+  * Arguments:
+  * * note is a number from 1-7 for A-G
+  * * acc is either "b", "n", or "#"
+  * * oct is 1-8 (or 9 for C)
+  */
+/datum/song/proc/playkey_legacy(note, acc as text, oct, mob/user)
 	// handle accidental -> B<>C of E<>F
 	if(acc == "b" && (note == 3 || note == 6)) // C or F
 		if(note == 3)

code/modules/instruments/songs/play_synthesized.dm

@@ -1,27 +1,7 @@
-/datum/song/proc/do_play_lines_synthesized(mob/user)
-	compile_lines()
-	while(repeat >= 0)
-		if(should_stop_playing(user))
-			return
-		var/warned = FALSE
-		for(var/_chord in compiled_chords)
-			if(should_stop_playing(user))
-				return
-			var/list/chord = _chord
-			var/tempodiv = chord[chord.len]
-			for(var/i in 1 to chord.len - 1)
-				var/key = chord[i]
-				if(!playkey_synth(key))
-					if(!warned)
-						warned = TRUE
-						to_chat(user, "<span class='boldwarning'>Your instrument has ran out of channels. You might be playing your song too fast or be setting sustain to too high of a value. This warning will be suppressed for the rest of this cycle.</span>")
-			sleep(sanitize_tempo(tempo / (tempodiv || 1)))
-		repeat--
-		updateDialog()
-	repeat = 0
-
-/// C-Db2-A-A4/2,A-B#4-C/3,/4,A,A-B-C as an example
-/datum/song/proc/compile_lines()
+/**
+  * Compiles our lines into "chords" with numbers. This makes there have to be a bit of lag at the beginning of the song, but repeats will not have to parse it again, and overall playback won't be impacted by as much lag.
+  */
+/datum/song/proc/compile_synthesized()
 	if(!length(src.lines))
 		return
 	var/list/lines = src.lines		//cache for hyepr speed!
@@ -57,10 +37,12 @@
 			compiled_chord += tempodiv		//this goes last
 			if(length(compiled_chord))
 				compiled_chords[++compiled_chords.len] = compiled_chord
-		CHECK_TICK
-	return compiled_chords
 
-/datum/song/proc/playkey_synth(key)
+/**
+  * Plays a specific numerical key from our instrument to anyone who can hear us.
+  * Does a hearing check if enough time has passed.
+  */
+/datum/song/proc/playkey_synth(key, mob/user)
 	if(can_noteshift)
 		key = clamp(key + note_shift, key_min, key_max)
 	if((world.time - MUSICIAN_HEARCHECK_MINDELAY) > last_hearcheck)
@@ -83,6 +65,9 @@
 		M.playsound_local(get_turf(parent), null, volume, FALSE, K.frequency, INSTRUMENT_DISTANCE_NO_FALLOFF, channel, null, copy, distance_multiplier = INSTRUMENT_DISTANCE_FALLOFF_BUFF)
 		// Could do environment and echo later but not for now
 
+/**
+  * Stops all sounds we are "responsible" for. Only works in synthesized mode.
+  */
 /datum/song/proc/terminate_all_sounds(clear_channels = TRUE)
 	for(var/i in hearing_mobs)
 		terminate_sound_mob(i)
@@ -93,10 +78,16 @@
 		using_sound_channels = 0
 		SSsounds.free_datum_channels(src)
 
+/**
+  * Stops all sounds we are responsible for in a given person. Only works in synthesized mode.
+  */
 /datum/song/proc/terminate_sound_mob(mob/M)
 	for(var/channel in channels_playing)
 		M.stop_sound_channel(text2num(channel))
 
+/**
+  * Pops a channel we have reserved so we don't have to release and re-request them from SSsounds every time we play a note. This is faster.
+  */
 /datum/song/proc/pop_channel()
 	if(length(channels_idle))			//just pop one off of here if we have one available
 		. = text2num(channels_idle[1])
@@ -108,6 +99,12 @@
 	if(!isnull(.))
 		using_sound_channels++
 
+/**
+  * Decays our channels and updates their volumes to mobs who can hear us.
+  *
+  * Arguments:
+  * * wait_ds - the deciseconds we should decay by. This is to compensate for any lag, as otherwise songs would get pretty nasty during high time dilation.
+  */
 /datum/song/proc/process_decay(wait_ds)
 	var/linear_dropoff = cached_linear_dropoff * wait_ds
 	var/exponential_dropoff = cached_exponential_dropoff ** wait_ds

code/modules/mob/living/carbon/carbon.dm

@@ -87,7 +87,7 @@
 		if(user != src && (user.a_intent == INTENT_HELP || user.a_intent == INTENT_DISARM))
 			for(var/datum/surgery/S in surgeries)
 				if(S.next_step(user,user.a_intent))
-					return 1
+					return STOP_ATTACK_PROC_CHAIN
 
 	if(!all_wounds || !(user.a_intent == INTENT_HELP || user == src))
 		return ..()
@@ -95,7 +95,7 @@
 	for(var/i in shuffle(all_wounds))
 		var/datum/wound/W = i
 		if(W.try_treating(I, user))
-			return 1
+			return STOP_ATTACK_PROC_CHAIN
 
 	return ..()
 

code/modules/reagents/reagent_containers/spray.dm

@@ -19,6 +19,10 @@
 	var/stream_range = 1 //the range of tiles the sprayer will reach when in stream mode.
 	var/stream_amount = 10 //the amount of reagents transfered when in stream mode.
 	var/spray_delay = 3 //The amount of sleep() delay between each chempuff step.
+	/// Last world.time of spray
+	var/last_spray = 0
+	/// Spray cooldown
+	var/spray_cooldown = CLICK_CD_MELEE
 	var/can_fill_from_container = TRUE
 	amount_per_transfer_from_this = 5
 	volume = 250
@@ -27,8 +31,6 @@
 
 /obj/item/reagent_containers/spray/afterattack(atom/A, mob/user)
 	. = ..()
-	if(!user.CheckActionCooldown(CLICK_CD_MELEE))
-		return
 	if(istype(A, /obj/structure/sink) || istype(A, /obj/structure/janitorialcart) || istype(A, /obj/machinery/hydroponics))
 		return
 
@@ -49,7 +51,8 @@
 		to_chat(user, "<span class='warning'>[src] is empty!</span>")
 		return
 
-	spray(A)
+	if(!spray(A))
+		return
 
 	playsound(src.loc, 'sound/effects/spray2.ogg', 50, 1, -6)
 	user.last_action = world.time
@@ -64,10 +67,10 @@
 	if(reagents.has_reagent(/datum/reagent/lube))
 		message_admins("[ADMIN_LOOKUPFLW(user)] fired Space lube from \a [src] at [ADMIN_VERBOSEJMP(T)].")
 		log_game("[key_name(user)] fired Space lube from \a [src] at [AREACOORD(T)].")
-	return
-
 
 /obj/item/reagent_containers/spray/proc/spray(atom/A)
+	if((last_spray + spray_cooldown) > world.time)
+		return
 	var/range = clamp(get_dist(src, A), 1, current_range)
 	var/obj/effect/decal/chempuff/D = new /obj/effect/decal/chempuff(get_turf(src))
 	D.create_reagents(amount_per_transfer_from_this, NONE, NO_REAGENTS_VALUE)
@@ -79,10 +82,11 @@
 		reagents.trans_to(D, amount_per_transfer_from_this, 1/range)
 	D.color = mix_color_from_reagents(D.reagents.reagent_list)
 	var/wait_step = max(round(2+ spray_delay * INVERSE(range)), 2)
-	do_spray(A, wait_step, D, range, puff_reagent_left)
+	last_spray = world.time
+	INVOKE_ASYNC(src, .proc/do_spray, A, wait_step, D, range, puff_reagent_left)
+	return TRUE
 
 /obj/item/reagent_containers/spray/proc/do_spray(atom/A, wait_step, obj/effect/decal/chempuff/D, range, puff_reagent_left)
-	set waitfor = FALSE
 	var/range_left = range
 	for(var/i=0, i<range, i++)
 		range_left--