Fixed regex by making it work across all lines instead of individual lines again. Added (hardcoded) version numbering to zips for mod.io. Folders and files that don't belong to mods in the input folder are now ignored.

Author: MyNameIsTrez

Python/convert.py

@@ -72,11 +72,13 @@ def convert():
 
 	for input_subfolder_path, input_subfolders, input_subfiles in os.walk(input_folder_path):
 		mod_subfolder = get_mod_subfolder(input_folder_path, input_subfolder_path, true_input_folder_path)
-		output_subfolder = os.path.join(output_folder, mod_subfolder)
 
-		try_print_mod_name(mod_subfolder)
-		create_folder(input_subfolder_path, output_subfolder)
-		process_file(input_subfiles, input_subfolder_path, output_subfolder, input_folder_path)
+		mod_subfolder_parts = pathlib.Path(mod_subfolder).parts
+		if len(mod_subfolder_parts) > 0 and mod_subfolder_parts[0].endswith(".rte"):
+			output_subfolder = os.path.join(output_folder, mod_subfolder)
+			try_print_mod_name(mod_subfolder_parts, mod_subfolder)
+			create_folder(input_subfolder_path, output_subfolder)
+			process_files(input_subfiles, input_subfolder_path, output_subfolder, input_folder_path)
 
 	if cfg.sg.user_settings_get_entry("output_zips"):
 		create_zips(input_folder_path, output_folder)
@@ -107,8 +109,10 @@ def get_total_progress(input_folder_path):
 	if input_folder_path.endswith(".rte"):
 		mod_count = 1
 	else:
-		mod_count = len([name for name in os.listdir(input_folder_path) if os.path.isdir(os.path.join(input_folder_path, name))])
-	
+		mod_count = 0
+		for mod_name in os.listdir(input_folder_path):
+			if os.path.isdir(os.path.join(input_folder_path, mod_name)) and mod_name.endswith(".rte"):
+				mod_count += 1
 	return mod_count * 2 if cfg.sg.user_settings_get_entry("output_zips") else mod_count
 
 
@@ -119,11 +123,9 @@ def get_mod_subfolder(input_folder_path, input_subfolder_path, true_input_folder
 		return os.path.relpath(input_subfolder_path, input_folder_path)
 
 
-def try_print_mod_name(mod_subfolder):
-	input_subfolder_path_tuple = pathlib.Path(mod_subfolder).parts
-
-	if len(input_subfolder_path_tuple) == 1:
-		print("Converting '{}'".format(input_subfolder_path_tuple[0]))
+def try_print_mod_name(mod_subfolder_parts, mod_subfolder):
+	if len(mod_subfolder_parts) == 1:
+		print("Converting '{}'".format(mod_subfolder))
 		update_progress()
 
 
@@ -140,14 +142,10 @@ def create_folder(input_subfolder_path, output_subfolder):
 		pass
 
 
-def process_file(input_subfiles, input_subfolder_path, output_subfolder, input_folder_path):
+def process_files(input_subfiles, input_subfolder_path, output_subfolder, input_folder_path):
 	for full_filename in input_subfiles:
 		filename, file_extension = os.path.splitext(full_filename)
 
-		# The ".empty" file exists so otherwise empty folders can be added to Git.
-		if filename == ".empty":
-			continue
-
 		input_file_path  = os.path.join(input_subfolder_path, full_filename)
 		output_file_path = os.path.join(output_subfolder, full_filename)
 
@@ -167,55 +165,61 @@ def create_converted_file(input_file_path, output_file_path, input_folder_path):
 				line_number = 0
 				for line in file_in:
 					line_number += 1
-					
-					line = regex_replace(line)
-					for old_str, new_str in conversion_rules.items():
-						line = line.replace(old_str, new_str)
-					all_lines_list.append(line)
 
 					if warnings_available:
 						for old_str, new_str in warning_rules.items():
 							if old_str in line:
 								warnings.append("'{}' line {}: {} -> {}".format(file_path, line_number, old_str, new_str))
-				
-				all_lines_str = "".join(all_lines_list)
-				file_out.write(regex_replace_bmps_and_wavs(all_lines_str))
+
+					all_lines_list.append(line)
+
+				all_lines = "".join(all_lines_list)
+
+				for old_str, new_str in conversion_rules.items():
+					all_lines = all_lines.replace(old_str, new_str)
+
+				all_lines = regex_replace(all_lines)
+				file_out.write(regex_replace_bmps_and_wavs(all_lines))
 	except:
 		shutil.copyfile(input_file_path, output_file_path)
 
 
-def regex_replace(line):
-	line = simple_replace(line, "Framerate = (.*)", "SpriteAnimMode = 7")
-	line = simple_replace(line, "\tPlayerCount = (.*)\n", "")
-	line = simple_replace(line, "\tTeamCount = (.*)\n", "")
+def regex_replace(all_lines):
+	all_lines = simple_replace(all_lines, "Framerate = (.*)", "SpriteAnimMode = 7")
+	all_lines = simple_replace(all_lines, "\tPlayerCount = (.*)\n", "")
+	all_lines = simple_replace(all_lines, "\tTeamCount = (.*)\n", "")
 
-	line = specific_replace(line, regex_replace_particle, False, "ParticleNumberToAdd = (.*)\n\tAddParticles = (.*)\n\t\tCopyOf = (.*)\n", "AddGib = Gib\n\t\tGibParticle = {}\n\t\t\tCopyOf = {}\n\t\tCount = {}\n")
-	line = specific_replace(line, regex_replace_sound_priority, True, " Sound(((?! Sound).)*)Priority", " Sound{}// Priority")
-	line = specific_replace(line, regex_use_capture, False, "FundsOfTeam(.*) =", "Team{}Funds =")
-	# line = specific_replace(line, regex_replace_playsound, False, "", "")
+	all_lines = specific_replace(all_lines, regex_replace_particle, False, "ParticleNumberToAdd = (.*)\n\tAddParticles = (.*)\n\t\tCopyOf = (.*)\n", "AddGib = Gib\n\t\tGibParticle = {}\n\t\t\tCopyOf = {}\n\t\tCount = {}\n")
+	
+	all_lines = specific_replace(all_lines, regex_replace_sound_priority, True, "SoundContainer(((?!SoundContainer).)*)Priority", "SoundContainer{}// Priority")
+
+	# all_lines = specific_replace(all_lines, regex_replace_sound_priority, True, "AddSound(((?! AddSound).)*)Priority", "AddSound{}// Priority")
+	
+	all_lines = specific_replace(all_lines, regex_use_capture, False, "FundsOfTeam(.*) =", "Team{}Funds =")
+	# all_lines = specific_replace(all_lines, regex_replace_playsound, False, "", "")
 
-	return line
+	return all_lines
 
 
-def simple_replace(line, pattern, replacement):
-	matches = re.findall(pattern, line)
+def simple_replace(all_lines, pattern, replacement):
+	matches = re.findall(pattern, all_lines)
 	if len(matches) > 0:
-		return re.sub(pattern, replacement, line)
-	return line
+		return re.sub(pattern, replacement, all_lines)
+	return all_lines
 
 
-def specific_replace(line, fn, dotall, pattern, replacement):
+def specific_replace(all_lines, fn, dotall, pattern, replacement):
 	# TODO: Refactor so .findall takes re.DOTALL as an argument directly.
 	if dotall:
-		matches = re.findall(pattern, line, re.DOTALL)
+		matches = re.findall(pattern, all_lines, re.DOTALL)
 	else:
-		matches = re.findall(pattern, line)
+		matches = re.findall(pattern, all_lines)
 	if len(matches) > 0:
-		return fn(line, pattern, replacement, matches)
-	return line
+		return fn(all_lines, pattern, replacement, matches)
+	return all_lines
 
 
-def regex_replace_particle(line, pattern, replacement, matches):
+def regex_replace_particle(all_lines, pattern, replacement, matches):
 	# matches == [(4, "foo", "bar"), (2, "baz", "bee")]
 	new = [item for tup in matches for item in tup]
 	# new == [4, "foo", "bar", 2, "baz", "bee"]
@@ -225,38 +229,39 @@ def regex_replace_particle(line, pattern, replacement, matches):
 	new[1::3], new[2::3], new[0::3]
 
 	# new == ["foo", "bar", 4, "baz", "bee", 2]
-	return re.sub(pattern, replacement, line).format(*new)
+	return re.sub(pattern, replacement, all_lines).format(*new)
 
 
-def regex_replace_sound_priority(line, pattern, replacement, matches):
+def regex_replace_sound_priority(all_lines, pattern, replacement, matches):
 	# TODO: This pattern returns two items in each tuple, while we only need the first. Create a better pattern.
 	# https://stackoverflow.com/a/406408/13279557
 	# https://regex101.com/r/NdKaWs/2
 
 	# matches == [(4, "foo"), (2, "bar")]
 	new = [item for tup in matches for item in tup][::2]
 	# new == [4, 2]
-	return re.sub(pattern, replacement, line, flags=re.DOTALL).format(*new)
+	return re.sub(pattern, replacement, all_lines, flags=re.DOTALL).format(*new)
 
 
-def regex_use_capture(line, pattern, replacement, matches):
-	return re.sub(pattern, replacement, line).format(*matches)
+def regex_use_capture(all_lines, pattern, replacement, matches):
+	return re.sub(pattern, replacement, all_lines).format(*matches)
 
 
-# def regex_replace_playsound(line, pattern, replacement, matches):
-# 	return line
+# def regex_replace_playsound(all_lines, pattern, replacement, matches):
+# 	return all_lines
 # 	# TODO:
 # 	# AudioMan:PlaySound("ModName.rte/Folder/SoundName.wav", SceneMan:TargetDistanceScalar(self.Pos), false, true, -1)
 # 	# to
 #	# AudioMan:PlaySound("ModName.rte/Folder/SoundName.wav", self.Pos)	-- Cut everything and leave the thing inside the brackets after SceneMan:TargetDistanceScalar
 
 
-def regex_replace_bmps_and_wavs(line):
-	line = specific_replace(line, regex_use_capture, False, "Base\.rte(.*?)\.bmp", "Base.rte{}.png")
-	line = specific_replace(line, regex_use_capture, False, "base\.rte(.*?)\.bmp", "Base.rte{}.png")
-	line = specific_replace(line, regex_use_capture, False, "Base\.rte(.*?)\.wav", "Base.rte{}.flac")
-	line = specific_replace(line, regex_use_capture, False, "base\.rte(.*?)\.wav", "Base.rte{}.flac")
-	return line
+def regex_replace_bmps_and_wavs(all_lines):
+	# TODO: Combine these four patterns into two.
+	all_lines = specific_replace(all_lines, regex_use_capture, False, "Base\.rte(.*?)\.bmp", "Base.rte{}.png")
+	all_lines = specific_replace(all_lines, regex_use_capture, False, "base\.rte(.*?)\.bmp", "Base.rte{}.png")
+	all_lines = specific_replace(all_lines, regex_use_capture, False, "Base\.rte(.*?)\.wav", "Base.rte{}.flac")
+	all_lines = specific_replace(all_lines, regex_use_capture, False, "base\.rte(.*?)\.wav", "Base.rte{}.flac")
+	return all_lines
 
 
 def create_zips(input_folder_path, output_folder):
@@ -266,21 +271,22 @@ def create_zips(input_folder_path, output_folder):
 		# TODO: Move check if it's a directory out of this loop. 
 		folder_names = [f for f in os.listdir(input_folder_path) if os.path.isdir(os.path.join(output_folder, f))]
 		for mod_name in folder_names:
-			create_single_zip(mod_name, output_folder)
+			if mod_name.endswith(".rte"):
+				create_single_zip(mod_name, output_folder)
 
 
 def create_single_zip(mod_name, output_folder):
 	print("Zipping '{}'".format(mod_name))
-	folder_path = os.path.join(output_folder, mod_name)
-	shutil.make_archive(folder_path, "zip", root_dir=output_folder, base_dir=mod_name)
-	shutil.rmtree(folder_path)
+	mod_path = os.path.join(output_folder, mod_name)
+	shutil.make_archive(mod_path.replace(".rte", "") + "-v1.0" + ".rte", "zip", root_dir=output_folder, base_dir=mod_name)
+	shutil.rmtree(mod_path)
 	update_progress()
 
 
 def warnings_popup():
 	if warnings_available:
 		w = max(30, len(max(warnings, key=len)))
-		h = min(50, len(warnings)) + 1 # + 1 necessary because popup_scrolled adds an extra line
+		h = min(50, len(warnings)) + 1 # + 1 necessary because popup_scrolled adds an extra line.
 		cfg.sg.popup_scrolled("\n".join(warnings), title="Lines needing manual replacing", size=(w, h), button_color=cfg.sg.theme_button_color(), background_color=cfg.sg.theme_background_color())