Port Baystruments PR from tgstation

code/modules/instruments/songs/_song.dm

@@ -0,0 +1,401 @@
+#define MUSICIAN_HEARCHECK_MINDELAY 4
+#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"
+
+	/// The atom we're attached to/playing from
+	var/atom/parent
+
+	/// Our song lines
+	var/list/lines
+
+	/// 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
+
+	/// Are we currently editing?
+	var/editing = TRUE
+	/// Is the help screen open?
+	var/help = FALSE
+
+	/// Repeats left
+	var/repeat = 1
+	/// Maximum times we can repeat
+	var/max_repeats = 10
+
+	/// Our volume
+	var/volume = 75
+	/// Max volume
+	var/max_volume = 75
+	/// Min volume - This is so someone doesn't decide it's funny to set it to 0 and play invisible songs.
+	var/min_volume = 1
+
+	/// What instruments our built in picker can use. The picker won't show unless this is longer than one.
+	var/list/allowed_instrument_ids
+
+	//////////// Cached instrument variables /////////////
+	/// Instrument we are currently using
+	var/datum/instrument/using_instrument
+	/// Cached legacy ext for legacy instruments
+	var/cached_legacy_ext
+	/// Cached legacy dir for legacy instruments
+	var/cached_legacy_dir
+	/// Cached list of samples, referenced directly from the instrument for synthesized instruments
+	var/list/cached_samples
+	/// Are we operating in legacy mode (so if the instrument is a legacy instrument)
+	var/legacy = FALSE
+	//////////////////////////////////////////////////////
+
+	/////////////////// Playing variables ////////////////
+	/**
+	  * 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 of channels that aren't being used, as text. This is to prevent unnecessary freeing and reallocations from SSsounds/SSinstruments.
+	var/list/channels_idle
+	/// Person playing us
+	var/mob/user_playing
+	//////////////////////////////////////////////////////
+
+	/// Last world.time we checked for who can hear us
+	var/last_hearcheck = 0
+	/// The list of mobs that can hear us
+	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
+	/// Max sound channels to occupy
+	var/max_sound_channels = CHANNELS_PER_INSTRUMENT
+	/// Current channels, so we can save a length() call.
+	var/using_sound_channels = 0
+	/// Last channel to play. text.
+	var/last_channel_played
+	/// Should we not decay our last played note?
+	var/full_sustain_held_note = TRUE
+
+	/////////////////////// DO NOT TOUCH THESE ///////////////////
+	var/octave_min = INSTRUMENT_MIN_OCTAVE
+	var/octave_max = INSTRUMENT_MAX_OCTAVE
+	var/key_min = INSTRUMENT_MIN_KEY
+	var/key_max = INSTRUMENT_MAX_KEY
+	var/static/list/note_offset_lookup
+	var/static/list/accent_lookup
+	//////////////////////////////////////////////////////////////
+
+	///////////// !!FUN!! - Only works in synthesized mode! /////////////////
+	/// Note numbers to shift.
+	var/note_shift = 0
+	var/note_shift_min = -100
+	var/note_shift_max = 100
+	var/can_noteshift = TRUE
+	/// The kind of sustain we're using
+	var/sustain_mode = SUSTAIN_LINEAR
+	/// When a note is considered dead if it is below this in volume
+	var/sustain_dropoff_volume = 0
+	/// Total duration of linear sustain for 100 volume note to get to SUSTAIN_DROPOFF
+	var/sustain_linear_duration = 5
+	/// Exponential sustain dropoff rate per decisecond
+	var/sustain_exponential_dropoff = 1.4
+	////////// DO NOT DIRECTLY SET THESE!
+	/// Do not directly set, use update_sustain()
+	var/cached_linear_dropoff = 10
+	/// Do not directly set, use update_sustain()
+	var/cached_exponential_dropoff = 1.045
+	/////////////////////////////////////////////////////////////////////////
+
+	var/static/list/valid_files[0] // Cache to avoid running fexists() every time
+
+/datum/song/New(atom/parent, list/instrument_ids, new_range)
+	SSinstruments.on_song_new(src)
+	lines = list()
+	tempo = sanitize_tempo(tempo)
+	src.parent = parent
+	if(instrument_ids)
+		allowed_instrument_ids = islist(instrument_ids)? instrument_ids : list(instrument_ids)
+	if(length(allowed_instrument_ids))
+		set_instrument(allowed_instrument_ids[1])
+	hearing_mobs = list()
+	volume = clamp(volume, min_volume, max_volume)
+	channels_playing = list()
+	channels_idle = list()
+	if(!note_offset_lookup)
+		note_offset_lookup = list(9, 11, 0, 2, 4, 5, 7)
+		accent_lookup = list("b" = -1, "s" = 1, "#" = 1, "n" = 0)
+	update_sustain()
+	if(new_range)
+		instrument_range = new_range
+
+/datum/song/Destroy()
+	stop_playing()
+	SSinstruments.on_song_del(src)
+	lines = null
+	using_instrument = null
+	allowed_instrument_ids = null
+	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 GLOB.player_list)
+		var/dist = get_dist(M, source)
+		if(dist > instrument_range)
+			continue
+		hearing_mobs[M] = dist
+	var/list/exited = old - hearing_mobs
+	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.
+  */
+/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
+	cached_legacy_dir = null
+	legacy = null
+	if(istext(I) || ispath(I))
+		I = SSinstruments.instrument_data[I]
+	if(istype(I))
+		using_instrument = I
+		I.songs_using += src
+		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
+			legacy = TRUE
+		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.
+  */
+/datum/song/proc/start_playing(mob/user)
+	if(playing)
+		return
+	if(!using_instrument?.is_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
+	SStgui.update_uis(parent)
+	//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()
+	SEND_SIGNAL(parent, COMSIG_SONG_START)
+	elapsed_delay = 0
+	delay_by = 0
+	current_chord = 1
+	user_playing = user
+	START_PROCESSING(SSinstruments, src)
+
+/**
+  * Stops playing, terminating all sounds if in synthesized mode. Clears hearing_mobs.
+  */
+/datum/song/proc/stop_playing()
+	if(!playing)
+		return
+	playing = FALSE
+	if(!debug_mode)
+		compiled_chords = null
+	STOP_PROCESSING(SSinstruments, src)
+	SEND_SIGNAL(parent, COMSIG_SONG_END)
+	terminate_all_sounds(TRUE)
+	hearing_mobs.len = 0
+	SStgui.update_uis(parent)
+	user_playing = null
+
+/**
+  * Processes our song.
+  */
+/datum/song/proc/process_song(wait)
+	if(!length(compiled_chords) || should_stop_playing(user_playing))
+		stop_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
+				SStgui.update_uis(parent)
+				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)
+	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)
+
+/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)
+
+/**
+  * 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
+	// Linear, not so much, since it's a target duration from 100 volume rather than an exponential rate.
+	var/target_duration = sustain_linear_duration
+	var/volume_diff = max(0, 100 - sustain_dropoff_volume)
+	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()
+	SStgui.update_uis(parent)
+
+/**
+  * 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()
+	SStgui.update_uis(parent)
+
+/**
+  * 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()
+	SStgui.update_uis(parent)
+
+/**
+  * 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()
+	SStgui.update_uis(parent)
+
+/datum/song/vv_edit_var(var_name, var_value)
+	. = ..()
+	if(.)
+		switch(var_name)
+			if(NAMEOF(src, volume))
+				set_volume(var_value)
+			if(NAMEOF(src, sustain_dropoff_volume))
+				set_dropoff_volume(var_value)
+			if(NAMEOF(src, sustain_exponential_dropoff))
+				set_exponential_drop_rate(var_value)
+			if(NAMEOF(src, sustain_linear_duration))
+				set_linear_falloff_duration(var_value)
+
+// subtype for handheld instruments, like violin
+/datum/song/handheld
+
+/datum/song/handheld/should_stop_playing(mob/user)
+	. = ..()
+	if(.)
+		return TRUE
+	var/obj/item/instrument/I = parent
+	return I.should_stop_playing(user)
+
+// subtype for stationary structures, like pianos
+/datum/song/stationary
+
+/datum/song/stationary/should_stop_playing(mob/user)
+	. = ..()
+	if(.)
+		return TRUE
+	var/obj/structure/musician/M = parent
+	return M.should_stop_playing(user)
+

code/modules/instruments/songs/_song_ui.dm

@@ -0,0 +1,183 @@
+/datum/song/tgui_data(mob/user)
+	var/data[0]
+
+	// General
+	data["playing"] = playing
+	data["repeat"] = repeat
+	data["maxRepeats"] = max_repeats
+	data["editing"] = editing
+	data["lines"] = lines
+	data["tempo"] = tempo
+	data["minTempo"] = world.tick_lag
+	data["maxTempo"] = 5 SECONDS
+	data["tickLag"] = world.tick_lag
+	data["help"] = help
+
+	// Status
+	var/list/allowed_instrument_names = list()
+	for(var/i in allowed_instrument_ids)
+		var/datum/instrument/I = SSinstruments.get_instrument(i)
+		if(I)
+			allowed_instrument_names += I.name
+	data["allowedInstrumentNames"] = allowed_instrument_names
+	data["instrumentLoaded"] = !isnull(using_instrument)
+	if(using_instrument)
+		data["instrument"] = using_instrument.name
+	data["canNoteShift"] = can_noteshift
+	if(can_noteshift)
+		data["noteShift"] = note_shift
+		data["noteShiftMin"] = note_shift_min
+		data["noteShiftMax"] = note_shift_max
+	data["sustainMode"] = sustain_mode
+	switch(sustain_mode)
+		if(SUSTAIN_LINEAR)
+			data["sustainLinearDuration"] = sustain_linear_duration
+		if(SUSTAIN_EXPONENTIAL)
+			data["sustainExponentialDropoff"] = sustain_exponential_dropoff
+	data["ready"] = using_instrument?.is_ready()
+	data["legacy"] = legacy
+	data["volume"] = volume
+	data["minVolume"] = min_volume
+	data["maxVolume"] = max_volume
+	data["sustainDropoffVolume"] = sustain_dropoff_volume
+	data["sustainHeldNote"] = full_sustain_held_note
+
+	return data
+
+/datum/song/tgui_interact(mob/user, ui_key = "main", datum/tgui/ui = null, force_open = FALSE, datum/tgui/master_ui = null, datum/tgui_state/state = GLOB.tgui_default_state)
+	ui = SStgui.try_update_ui(user, parent, ui_key, ui, force_open)
+	if(!ui)
+		ui = new(user, parent, ui_key, "Instrument", parent?.name || "Instrument", 700, 500)
+		ui.open()
+		ui.set_autoupdate(FALSE) // NO!!! Don't auto-update this!!
+
+/datum/song/tgui_act(action, params)
+	switch(action)
+		if("newsong")
+			lines = new()
+			tempo = sanitize_tempo(5) // default 120 BPM
+			name = ""
+			return TRUE
+		if("import")
+			var/t = ""
+			do
+				t = html_encode(input(usr, "Please paste the entire song, formatted:", text("[]", name), t)  as message)
+				if(!in_range(parent, usr))
+					return
+
+				if(length_char(t) >= MUSIC_MAXLINES * MUSIC_MAXLINECHARS)
+					var/cont = input(usr, "Your message is too long! Would you like to continue editing it?", "", "yes") in list("yes", "no")
+					if(cont == "no")
+						break
+			while(length_char(t) > MUSIC_MAXLINES * MUSIC_MAXLINECHARS)
+			parse_song(t)
+		if("help")
+			help = !help
+			return TRUE
+		if("edit")
+			editing = !editing
+			return TRUE
+		if("repeat") //Changing this from a toggle to a number of repeats to avoid infinite loops.
+			if(playing)
+				return //So that people cant keep adding to repeat. If the do it intentionally, it could result in the server crashing.
+			repeat = clamp(round(text2num(params["new"])), 0, max_repeats)
+			return TRUE
+		if("tempo")
+			tempo = sanitize_tempo(text2num(params["new"]))
+			return TRUE
+		if("play")
+			INVOKE_ASYNC(src, .proc/start_playing, usr)
+		if("newline")
+			var/newline = html_encode(input("Enter your line: ", parent.name) as text|null)
+			if(!newline || !in_range(parent, usr))
+				return
+			if(length(lines) > MUSIC_MAXLINES)
+				return
+			if(length(newline) > MUSIC_MAXLINECHARS)
+				newline = copytext(newline, 1, MUSIC_MAXLINECHARS)
+			lines.Add(newline)
+			return TRUE
+		if("deleteline")
+			var/num = round(text2num(params["line"]))
+			if(num > length(lines) || num < 1)
+				return
+			lines.Cut(num, num + 1)
+			return TRUE
+		if("modifyline")
+			var/num = round(text2num(params["line"]), 1)
+			var/content = stripped_input(usr, "Enter your line: ", parent.name, lines[num], MUSIC_MAXLINECHARS)
+			if(!content || !in_range(parent, usr))
+				return
+			if(num > length(lines) || num < 1)
+				return
+			lines[num] = content
+			return TRUE
+		if("stop")
+			stop_playing()
+		if("setlinearfalloff")
+			set_linear_falloff_duration(round(text2num(params["new"]) * 10, world.tick_lag))
+			return TRUE
+		if("setexpfalloff")
+			set_exponential_drop_rate(round(text2num(params["new"]), 0.00001))
+			return TRUE
+		if("setvolume")
+			set_volume(round(text2num(params["new"]), 1))
+			return TRUE
+		if("setdropoffvolume")
+			set_dropoff_volume(round(text2num(params["new"]), 0.01))
+			return TRUE
+		if("switchinstrument")
+			if(!length(allowed_instrument_ids))
+				return
+			else if(length(allowed_instrument_ids) == 1)
+				set_instrument(allowed_instrument_ids[1])
+				return
+			var/choice = params["name"]
+			for(var/i in allowed_instrument_ids)
+				var/datum/instrument/I = SSinstruments.get_instrument(i)
+				if(I && I.name == choice)
+					set_instrument(I)
+					return TRUE
+		if("setnoteshift")
+			note_shift = clamp(round(text2num(params["new"])), note_shift_min, note_shift_max)
+			return TRUE
+		if("setsustainmode")
+			var/static/list/sustain_modes
+			if(!length(sustain_modes))
+				sustain_modes = list("Linear" = SUSTAIN_LINEAR, "Exponential" = SUSTAIN_EXPONENTIAL)
+			var/choice = params["new"]
+			sustain_mode = sustain_modes[choice] || sustain_mode
+			return TRUE
+		if("togglesustainhold")
+			full_sustain_held_note = !full_sustain_held_note
+			return TRUE
+		else
+			return FALSE
+	parent.add_fingerprint(usr)
+
+/**
+  * Parses a song the user has input into lines and stores them.
+  */
+/datum/song/proc/parse_song(text)
+	set waitfor = FALSE
+	//split into lines
+	lines = splittext(text, "\n")
+	if(length(lines))
+		var/bpm_string = "BPM: "
+		if(findtext(lines[1], bpm_string, 1, length(bpm_string) + 1))
+			var/divisor = text2num(copytext(lines[1], length(bpm_string) + 1)) || 120 // default
+			tempo = sanitize_tempo(600 / round(divisor, 1))
+			lines.Cut(1, 2)
+		else
+			tempo = sanitize_tempo(5) // default 120 BPM
+		if(length(lines) > MUSIC_MAXLINES)
+			to_chat(usr, "Too many lines!")
+			lines.Cut(MUSIC_MAXLINES + 1)
+		var/linenum = 1
+		for(var/l in lines)
+			if(length_char(l) > MUSIC_MAXLINECHARS)
+				to_chat(usr, "Line [linenum] too long!")
+				lines.Remove(l)
+			else
+				linenum++
+		SStgui.update_uis(parent)

code/modules/instruments/songs/play_legacy.dm

@@ -0,0 +1,95 @@
+/**
+  * 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
+
+/**
+  * 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 - number from 1-7 for A-G
+  * * acc - either "b", "n", or "#"
+  * * oct - 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)
+			oct--
+		note--
+		acc = "n"
+	else if(acc == "#" && (note == 2 || note == 5)) // B or E
+		if(note == 2)
+			oct++
+		note++
+		acc = "n"
+	else if(acc == "#" && (note == 7)) //G#
+		note = 1
+		acc = "b"
+	else if(acc == "#") // mass convert all sharps to flats, octave jump already handled
+		acc = "b"
+		note++
+
+	// check octave, C is allowed to go to 9
+	if(oct < 1 || (note == 3 ? oct > 9 : oct > 8))
+		return
+
+	// now generate name
+	var/filename = "sound/instruments/[cached_legacy_dir]/[ascii2text(note + 64)][acc][oct].[cached_legacy_ext]"
+	var/soundfile = file(filename)
+	// make sure the note exists
+	var/cached_fexists = valid_files[filename]
+	if(!isnull(cached_fexists))
+		if(!cached_fexists)
+			return
+	else if(!fexists(soundfile))
+		valid_files[filename] = FALSE
+		return
+	else
+		valid_files[filename] = TRUE
+	// and play
+	var/turf/source = get_turf(parent)
+	if((world.time - MUSICIAN_HEARCHECK_MINDELAY) > last_hearcheck)
+		do_hearcheck()
+	var/sound/music_played = sound(soundfile)
+	for(var/i in hearing_mobs)
+		var/mob/M = i
+		if(!(M?.client?.prefs?.toggles & SOUND_INSTRUMENTS))
+			continue
+		M.playsound_local(source, null, volume * using_instrument.volume_multiplier, falloff = 5, S = music_played)
+		// Could do environment and echo later but not for now

code/modules/instruments/songs/play_synthesized.dm

@@ -0,0 +1,134 @@
+/**
+  * 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!
+	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 += clamp((note_offset_lookup[key] + octaves[key] * 12 + accent_lookup[accents[key]]), key_min, key_max)
+			compiled_chord += tempodiv		//this goes last
+			if(length(compiled_chord))
+				compiled_chords[++compiled_chords.len] = compiled_chord
+
+/**
+  * 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)
+		do_hearcheck()
+	var/datum/instrument_key/K = using_instrument.samples[num2text(key)]			//See how fucking easy it is to make a number text? You don't need a complicated 9 line proc!
+	//Should probably add channel limiters here at some point but I don't care right now.
+	var/channel = pop_channel()
+	if(isnull(channel))
+		return FALSE
+	. = TRUE
+	var/sound/copy = sound(K.sample)
+	var/volume = src.volume * using_instrument.volume_multiplier
+	copy.frequency = K.frequency
+	copy.volume = volume
+	var/channel_text = num2text(channel)
+	channels_playing[channel_text] = 100
+	last_channel_played = channel_text
+	for(var/i in hearing_mobs)
+		var/mob/M = i
+		if(!(M?.client?.prefs?.toggles & SOUND_INSTRUMENTS))
+			continue
+		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)
+	if(clear_channels && channels_playing)
+		channels_playing.len = 0
+		channels_idle.len = 0
+		SSinstruments.current_instrument_channels -= using_sound_channels
+		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])
+		channels_idle.Cut(1, 2)
+		return
+	if(using_sound_channels >= max_sound_channels)
+		return
+	. = SSinstruments.reserve_instrument_channel(src)
+	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
+	for(var/channel in channels_playing)
+		if(full_sustain_held_note && (channel == last_channel_played))
+			continue
+		var/current_volume = channels_playing[channel]
+		switch(sustain_mode)
+			if(SUSTAIN_LINEAR)
+				current_volume -= linear_dropoff
+			if(SUSTAIN_EXPONENTIAL)
+				current_volume /= exponential_dropoff
+		channels_playing[channel] = current_volume
+		var/dead = current_volume <= sustain_dropoff_volume
+		var/channelnumber = text2num(channel)
+		if(dead)
+			channels_playing -= channel
+			channels_idle += channel
+			for(var/i in hearing_mobs)
+				var/mob/M = i
+				M.stop_sound_channel(channelnumber)
+		else
+			for(var/i in hearing_mobs)
+				var/mob/M = i
+				M.set_sound_channel_volume(channelnumber, (current_volume * 0.01) * volume * using_instrument.volume_multiplier)