RhythmGame/formats/RGT.gd

extends Node
# RhythmGameText formats
# .rgts - simplified format cutting out redundant data, should be easy to write charts in
# .rgtx - a lossless representation of MM in-memory format
# .rgtm - a collection of rgts charts, with a [title] at the start of each one
enum Format{RGTS, RGTX, RGTM}

const EXTENSIONS = {
	'rgts': Format.RGTS,
	'rgtx': Format.RGTX,
	'rgtm': Format.RGTM,
}

const NOTE_TYPES = {
	't': Note.NOTE_TAP,
	'h': Note.NOTE_HOLD,
	's': Note.NOTE_STAR,
	'e': Note.NOTE_SLIDE,
	'b': Note.NOTE_TAP,  # Break
	'x': Note.NOTE_STAR  # Break star
}

const SLIDE_TYPES = {
	'0': null,  # Seems to be used for stars without slides attached
	'1': Note.SlideType.CHORD,
	'2': Note.SlideType.ARC_ACW,
	'3': Note.SlideType.ARC_CW,
	'4': Note.SlideType.COMPLEX,  # Orbit around center ACW on the way
	'5': Note.SlideType.COMPLEX,  # CW of above
	'6': Note.SlideType.COMPLEX,  # S zigzag through center
	'7': Note.SlideType.COMPLEX,  # Z zigzag through center
	'8': Note.SlideType.COMPLEX,  # V into center
	'9': Note.SlideType.COMPLEX,  # Go to center then orbit off to the side ACW
	'a': Note.SlideType.COMPLEX,  # CW of above
	'b': Note.SlideType.COMPLEX,  # V into column 2 places ACW
	'c': Note.SlideType.COMPLEX,  # V into column 2 places CW
	'd': Note.SlideType.CHORD_TRIPLE,  # Triple cone. Spreads out to the adjacent receptors of the target.
	'e': Note.SlideType.CHORD,  # Not used in any of our charts
	'f': Note.SlideType.CHORD,  # Not used in any of our charts
}
const SLIDE_IN_R := sin(PI/8)  # Circle radius circumscribed by chords 0-3, 1-4, 2-5 etc.


static func load_file(filename: String):
	var extension = filename.rsplit('.', false, 1)[1]
	if not EXTENSIONS.has(extension):
		return -1
	var format = EXTENSIONS[extension]
	var file := File.new()
	var err := file.open(filename, File.READ)
	if err != OK:
		print(err)
		return err
	var length = file.get_len()
	var chart_ids = []
	var lines = [[]]
	# This loop will segment the lines as if the file were RGTM
	while (file.get_position() < (length-1)):  # Could probably replace this with file.eof_reached()
		var line : String = file.get_line()
		if line.begins_with('['):  # Split to a new list for each chart definition
			chart_ids.append(line.lstrip('[').rstrip(']'))
			lines.append([])
		elif !line.empty():
			lines[-1].push_back(line)
	file.close()
	print('Parsing chart: ', filename)

	match format:
		Format.RGTS:
			var metadata_and_notes = parse_rgts(lines[0])
			return metadata_and_notes
		Format.RGTX:
			var metadata_and_notes = parse_rgtx(lines[0])
			return metadata_and_notes
		Format.RGTM:
			lines.pop_front()  # Anything before the first [header] is meaningless
			var charts = {}
			for i in len(lines):
				charts[chart_ids[i]] = parse_rgts(lines[i])
			return charts
	return format


static func parse_rgtx(lines: PoolStringArray):
	return []  # To be implemented later


const beats_per_measure = 4.0  # TODO: Bit of an ugly hack, need to revisit this later
static func parse_rgts(lines: PoolStringArray):
	var metadata := {}
	var num_taps := 0
	var num_holds := 0
	var num_slides := 0
	var notes := []
	var slide_ids := {}
	var slide_stars := {}  # Multiple stars might link to one star. We only care about linking for the spin speed.
	var last_star := []
	for i in Rules.COLS:
		last_star.append(null)

	for line in lines:
		if len(line) < 4:  # shortest legal line would be like '1:1t'
			continue
		var s = line.split(':')
		var time := float(s[0]) * beats_per_measure
		var note_hits := []
		var note_nonhits := []
		for i in range(1, len(s)):
			var n = s[i]
			var column := int(n[0])
			var ntype = n[1]
			n = n.substr(2)

			match ntype:
				't', 'b':  # tap
					note_hits.append(Note.NoteTap.new(time, column, ntype=='b'))
					num_taps += 1
				'h':  # hold
					var duration = float(n) * beats_per_measure
					note_hits.append(Note.NoteHold.new(time, column, duration))
					num_holds += 1
				's', 'x':  # slide star
					var star = Note.NoteStar.new(time, column, ntype=='z')
					note_hits.append(star)
					num_slides += 1
					last_star[column] = star
					if len(n) > 1:  # Not all stars have proper slide info
						var slide_type = n[0]  # hex digit
						var slide_id = int(n.substr(1))
						if slide_id > 0:
							slide_stars[slide_id] = star
							var slide = Note.NoteSlide.new(time, column)
							slide_ids[slide_id] = slide
							note_nonhits.append(slide)
				'e':  # slide end
					var slide_type = n[0]  # numeric digit, left as str just in case
					var slide_id = int(n.substr(1))
					if slide_id in slide_ids:  # Classic slide end
						slide_ids[slide_id].time_release = time
						if slide_id in slide_stars:
							slide_stars[slide_id].duration = slide_ids[slide_id].duration  # Should probably recalc in case start time is different but w/e
						slide_ids[slide_id].column_release = column
						slide_ids[slide_id].slide_type = SLIDE_TYPES[slide_type]
						slide_ids[slide_id].update_slide_variables()
						if SLIDE_TYPES[slide_type] == Note.SlideType.COMPLEX:
							var col_hit = slide_ids[slide_id].column
							var RUV = GameTheme.RADIAL_UNIT_VECTORS
							var RCA = GameTheme.RADIAL_COL_ANGLES
							slide_ids[slide_id].values.curve2d.add_point(RUV[col_hit])  # Start col
							match slide_type:
								'4':  # Orbit ACW around center. Size of loop is roughly inscribed in chords of 0-3, 1-4, 2-5...   NB: doesn't loop if directly opposite col
									Note.curve2d_make_orbit(slide_ids[slide_id].values.curve2d, RCA[col_hit], RCA[column], true)
								'5':  # CW of above
									Note.curve2d_make_orbit(slide_ids[slide_id].values.curve2d, RCA[col_hit], RCA[column], false)
								'6':  # S zigzag through center
									slide_ids[slide_id].values.curve2d.add_point(RUV[posmod(col_hit-2, Rules.COLS)] * SLIDE_IN_R)
									slide_ids[slide_id].values.curve2d.add_point(RUV[posmod(col_hit+2, Rules.COLS)] * SLIDE_IN_R)
								'7':  # Z zigzag through center
									slide_ids[slide_id].values.curve2d.add_point(RUV[posmod(col_hit+2, Rules.COLS)] * SLIDE_IN_R)
									slide_ids[slide_id].values.curve2d.add_point(RUV[posmod(col_hit-2, Rules.COLS)] * SLIDE_IN_R)
								'8':  # V into center
									slide_ids[slide_id].values.curve2d.add_point(Vector2.ZERO)
								'9':  # Orbit off-center ACW
									Note.curve2d_make_sideorbit(slide_ids[slide_id].values.curve2d, RCA[col_hit], RCA[column], true)
								'a':  # CW of above
									Note.curve2d_make_sideorbit(slide_ids[slide_id].values.curve2d, RCA[col_hit], RCA[column], false)
								'b':  # V into column 2 places ACW
									slide_ids[slide_id].values.curve2d.add_point(RUV[posmod(col_hit-2, Rules.COLS)])
								'c':  # V into column 2 places CW
									slide_ids[slide_id].values.curve2d.add_point(RUV[posmod(col_hit+2, Rules.COLS)])
							slide_ids[slide_id].values.curve2d.add_point(RUV[column])  # End col
					else:  # Naked slide start
						if last_star[column] != null:
							slide_stars[slide_id] = last_star[column]
						else:
							print_debug('Naked slide with no prior star in column!')
						var note = Note.NoteSlide.new(time, column)
						slide_ids[slide_id] = note
						note_nonhits.append(note)
				'_':
					print_debug('Unknown note type: ', ntype)

		if len(note_hits) > 1:
			for note in note_hits:  # Set multihit on each one
				note.double_hit = true
		notes += note_hits + note_nonhits
	metadata['num_taps'] = num_taps
	metadata['num_holds'] = num_holds
	metadata['num_slides'] = num_slides
	return [metadata, notes]