uh what?

code/modules/instruments/songs/_song.dm

@@ -2,12 +2,6 @@
 #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"
@@ -21,9 +15,6 @@
 	/// 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
 
@@ -62,24 +53,17 @@
 
 	/////////////////// Playing variables ////////////////
 	/**
-	  * Build by compile_chords()
-	  * Must be rebuilt on instrument switch.
+	  * 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
 	  * 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
@@ -88,6 +72,8 @@
 	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.
@@ -127,7 +113,7 @@
 	var/cached_exponential_dropoff = 1.045
 	/////////////////////////////////////////////////////////////////////////
 
-/datum/song/New(atom/parent, list/instrument_ids, new_range)
+/datum/song/New(atom/parent, list/instrument_ids)
 	SSinstruments.on_song_new(src)
 	lines = list()
 	tempo = sanitize_tempo(tempo)
@@ -139,8 +125,6 @@
 	hearing_mobs = list()
 	volume = clamp(volume, min_volume, max_volume)
 	update_sustain()
-	if(new_range)
-		instrument_range = new_range
 
 /datum/song/Destroy()
 	stop_playing()
@@ -151,15 +135,12 @@
 	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(instrument_range, source))
+	for(var/mob/M in get_hearers_in_view(15, source))
 		if(!(M?.client?.prefs?.toggles & SOUND_INSTRUMENTS))
 			continue
 		hearing_mobs[M] = get_dist(M, source)
@@ -167,15 +148,10 @@
 	for(var/i in exited)
 		terminate_sound_mob(i)
 
-/**
-  * Sets our instrument, caching anything necessary for faster accessing. Accepts an ID, typepath, or instantiated instrument datum.
-  */
+/// I can either be a datum, id, or path (if the instrument has no id).
 /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
@@ -186,7 +162,7 @@
 	if(istype(I))
 		using_instrument = I
 		I.songs_using += src
-		var/instrument_legacy = (I.instrument_flags & INSTRUMENT_LEGACY)
+		var/instrument_legacy = CHECK_BITFIELD(I.instrument_flags, INSTRUMENT_LEGACY)
 		if(instrument_legacy)
 			cached_legacy_ext = I.legacy_instrument_ext
 			cached_legacy_dir = I.legacy_instrument_path
@@ -194,37 +170,23 @@
 		else
 			cached_samples = I.samples
 			legacy = FALSE
-		if(isnull(old_legacy) || (old_legacy != instrument_legacy))
-			if(playing)
-				compile_chords()
 
-/**
-  * Attempts to start playing our song.
-  */
+/// THIS IS A BLOCKING CALL.
 /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(user_playing)
+	updateDialog()
 	//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.
-	do_hearcheck()
-	elapsed_delay = 0
-	delay_by = 0
-	current_chord = 1
-	user_playing = user
+	last_process_decay = world.time
 	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
@@ -234,93 +196,42 @@
 	STOP_PROCESSING(SSinstruments, src)
 	terminate_all_sounds(TRUE)
 	hearing_mobs.len = 0
-	user_playing = null
+	updateDialog()
 
-/**
-  * Processes our song.
-  */
-/datum/song/proc/process_song(wait)
-	if(!length(compiled_chords) || should_stop_playing(user_playing))
-		stop_playing()
+/// THIS IS A BLOCKING CALL.
+/datum/song/proc/do_play_lines(user)
+	if(!playing)
 		return
-	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
+	do_hearcheck()
+	if(legacy)
+		do_play_lines_legacy(user)
+	else
+		do_play_lines_synthesized(user)
 
-/**
-  * 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 users. Override down the line.
-  */
-/datum/song/proc/updateDialog(mob/user)
+/// Updates the window for our user. Override in subtypes.
+/datum/song/proc/updateDialog(mob/user = usr)
 	ui_interact(user)
 
 /datum/song/process(wait)
 	if(!playing)
 		return PROCESS_KILL
-	// 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)
+	var/delay = world.time - last_process_decay
+	process_decay(delay)
+	last_process_decay = world.time
 
-/**
-  * 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
@@ -330,33 +241,21 @@
 	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()
@@ -378,8 +277,10 @@
 // subtype for handheld instruments, like violin
 /datum/song/handheld
 
-/datum/song/handheld/updateDialog(mob/user)
-	parent.ui_interact(user || usr)
+/datum/song/handheld/updateDialog(mob/user = usr)
+	if(user.machine != src)
+		return
+	parent.ui_interact(user)
 
 /datum/song/handheld/should_stop_playing(mob/user)
 	. = ..()
@@ -391,8 +292,10 @@
 // subtype for stationary structures, like pianos
 /datum/song/stationary
 
-/datum/song/stationary/updateDialog(mob/user)
-	parent.ui_interact(user || usr)
+/datum/song/stationary/updateDialog(mob/user = usr)
+	if(user.machine != src)
+		return
+	parent.ui_interact(user)
 
 /datum/song/stationary/should_stop_playing(mob/user)
 	. = ..()

code/modules/instruments/songs/editor.dm

@@ -82,6 +82,7 @@
 
 	var/datum/browser/popup = new(user, "instrument", parent?.name || "instrument", 700, 500)
 	popup.set_content(dat.Join(""))
+	popup.set_title_image(user.browse_rsc_icon(parent.icon, parent.icon_state))
 	popup.open()
 
 /datum/song/proc/ParseSong(text)

code/modules/instruments/songs/play_legacy.dm

@@ -1,52 +1,48 @@
-/**
-  * 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
+/// 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"
 
-/**
-  * 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)
+		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)
 	// 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,7 +1,27 @@
-/**
-  * 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()
+/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()
 	if(!length(src.lines))
 		return
 	var/list/lines = src.lines		//cache for hyepr speed!
@@ -37,12 +57,10 @@
 			compiled_chord += tempodiv		//this goes last
 			if(length(compiled_chord))
 				compiled_chords[++compiled_chords.len] = compiled_chord
+		CHECK_TICK
+	return compiled_chords
 
-/**
-  * 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)
+/datum/song/proc/playkey_synth(key)
 	if(can_noteshift)
 		key = clamp(key + note_shift, key_min, key_max)
 	if((world.time - MUSICIAN_HEARCHECK_MINDELAY) > last_hearcheck)
@@ -65,9 +83,6 @@
 		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)
@@ -78,16 +93,10 @@
 		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])
@@ -99,12 +108,6 @@
 	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