You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
LC_ModManager/ModManager.py

378 lines
15 KiB
Python

import glob
import hashlib
import json
import logging
import os
import shutil
import sys
import tempfile
from typing import Tuple, List
from zipfile import ZipFile
from PyQt6 import QtWidgets
from PyQt6.QtWidgets import QApplication
from files.settings import LCSettings
from window.main_window import MainWindow
class ModManager:
VERSION = "0.1"
def __init__(self, log_level: int = logging.INFO):
self.__logger = logging.getLogger("ModManager")
sh = logging.StreamHandler(sys.stdout)
sh.setFormatter(logging.Formatter(
fmt="%(asctime)s.%(msecs)03d [%(name)-12.12s] [%(levelname)-5.5s] %(message)s"))
self.__logger.addHandler(sh)
self.__logger.setLevel(log_level)
self.__app = QApplication([])
self.__window = MainWindow(self, self.__logger, version=ModManager.VERSION)
self.__settings = LCSettings()
self.available_mods = dict()
self.installed_mods = dict()
if self.__settings.get_game_folder() is None:
dialog = QtWidgets.QMessageBox()
dialog.setWindowTitle("No Game folder")
dialog.setInformativeText(f"The mod manager requires the path to your Lethal Company game folder!\n"
"Please choose it in the following window.")
dialog.setIcon(QtWidgets.QMessageBox.Icon.Information)
dialog.exec()
self.__window.on_action_set_game_folder()
if self.__settings.get_game_folder() is None:
dialog = QtWidgets.QMessageBox()
dialog.setWindowTitle("No Game folder")
dialog.setInformativeText(f"Can't do anything without a valid game folder path.\nExiting!")
dialog.setIcon(QtWidgets.QMessageBox.Icon.Information)
dialog.exec()
self.__app.exit(0)
sys.exit(0)
self.create_manager_folder()
self.index_stored_mods()
self.index_installed_mods()
def run(self):
self.__logger.debug(f"Starting LCMod Manager {ModManager.VERSION} ...")
self.__window.show()
status = self.__app.exec()
sys.exit(status)
def __adjust_folder_paths(self, path: str) -> str:
"""
Adjusts a given path containing common issues to one compatible with BepInEx
:param input:
:return:
"""
if path.endswith(".dll") and "BepInEx" not in path:
path = os.path.join("BepInEx", "plugins", path)
if path.startswith("config" + os.path.sep) or path.startswith("plugins" + os.path.sep):
path = os.path.join("BepInEx", path)
if path.lower().startswith("bepinex") and not path.startswith("BepInEx"):
path = "BepInEx" + path[len("BepinEx"):]
return path
def create_manager_folder(self):
game_folder = self.__settings.get_game_folder()
if game_folder is not None:
manager_folder = os.path.join(game_folder, LCSettings.FOLDER_NAME)
if not os.path.isdir(manager_folder):
self.__logger.debug(f"Creating folder: {manager_folder}")
os.mkdir(manager_folder)
def is_folder_valid_game_folder(self, dir_path: str) -> bool:
req_files = ["Lethal Company.exe", "doorstop_config.ini"]
req_folders = ["Lethal Company_Data", "MonoBleedingEdge", "BepInEx"]
for entry in os.listdir(dir_path):
fullpath_entry = os.path.join(dir_path, entry)
if os.path.isfile(fullpath_entry):
if entry in req_files:
req_files.remove(entry)
elif os.path.isdir(fullpath_entry):
if entry in req_folders:
req_folders.remove(entry)
if len(req_folders) == len(req_files) == 0:
return True
else:
if len(req_files) == 1 and req_files[0] == "doorstop_config.ini" or \
len(req_folders) == 1 and req_folders[0] == "BepInEx":
self.__logger.error(f"new game path rejected! Following files and folders were "
f"expected but not present: {req_files + req_folders}\nBepInEx not installed?")
return False
self.__logger.error(f"new game path rejected! Following files and folders were "
f"expected but not present: {req_files + req_folders}")
return False
def set_game_folder(self, dir_path: str) -> bool:
"""
Sets the game_path to dir_path in the settings
:param dir_path:
:return: indicates if the new game folder path was accepted
"""
if len(dir_path) == 0:
self.__logger.debug("new game path selection got probably cancelled.")
return True
is_valid = self.is_folder_valid_game_folder(dir_path)
if is_valid:
s = self.__settings.get_settings()
s["game_path"] = dir_path
self.__settings.apply_changes()
self.create_manager_folder()
self.index_stored_mods()
self.index_installed_mods()
return is_valid
def is_mod_installed(self, mod_name: str) -> bool:
"""
Checks if a given mod has been installed to the game already
:param mod_name:
:return:
"""
r = self.available_mods[mod_name]
mod_files = r["mod_files"]
for i in range(len(mod_files)):
file = mod_files[i]
orig_file = r["orig_mod_files"][i]
if not os.path.exists(os.path.join(self.__settings.get_game_folder(), file)):
return False
else:
if os.path.isfile(os.path.join(self.__settings.get_game_folder(), file)):
hash_installed = self.get_file_hash(open(os.path.join(self.__settings.get_game_folder(), file), 'rb'))
modzip = os.path.join(self.__settings.get_mod_folder(), self.available_mods[mod_name]["path"])
hash_in_storage = self.get_file_hash(ZipFile(modzip).open(orig_file, 'r'))
if hash_installed != hash_in_storage:
return False
return True
def is_valid_mod_file(self, file_path: str):
"""
Checks if the given file is a valid mod zip file
:param file_path:
:return:
"""
if not os.path.isfile(file_path):
return False
zip = ZipFile(file_path)
contents = zip.namelist()
if "manifest.json" in contents:
return True
return False
def get_file_hash(self, file_buffer) -> str:
md5_obj = hashlib.md5()
while True:
buffer = file_buffer.read(8096)
if not buffer:
break
md5_obj.update(buffer)
return md5_obj.hexdigest()
def get_mod_hash(self, file_path: str) -> str:
md5_obj = hashlib.md5()
with open(file_path, 'rb') as file:
while True:
buffer = file.read(8096)
if not buffer:
break
md5_obj.update(buffer)
return md5_obj.hexdigest()
def get_mod_info(self, file_path: str) -> Tuple[str, str, List[str]]:
"""
Returns the name and version string of a given mod file
:param file_path:
:return:
"""
if not self.is_valid_mod_file(file_path):
self.__logger.error(f"Tried to get mod info of an invalid file: {file_path}")
raise ValueError(f"Tried to get mod info of an invalid file: {file_path}")
zip = ZipFile(file_path)
f = zip.open('manifest.json')
contents = zip.namelist()
orig_files = []
files = []
for file in contents:
if "icon.png" in file or "manifest.json" in file or file.endswith(".md"):
continue
orig_files.append(file)
file = self.__adjust_folder_paths(file)
files.append(file)
manifest = json.load(f)
return str(manifest["name"]), str(manifest["version_number"]), files, orig_files
def index_installed_mods(self):
"""
Checks all installed mods against the known mod files.
For unknown mods a placeholder is created
:return:
"""
self.installed_mods = dict()
if self.__settings.get_game_folder() is None:
return
files = []
to_search = [self.__settings.get_plugin_folder()]
while len(to_search) > 0:
curr = to_search.pop()
if os.path.isdir(curr):
r = os.listdir(curr)
for i in r:
to_search.append(os.path.join(curr, i))
elif os.path.isfile(curr) and curr.endswith('.dll'):
files.append(curr)
for mod_name in self.available_mods.keys():
if self.is_mod_installed(mod_name):
self.installed_mods[mod_name] = self.available_mods[mod_name]
unknown_mod = dict()
unresolved_files = files.copy()
for file in files:
for mod in self.installed_mods.keys():
file_rel = file[len(self.__settings.get_game_folder())+1:]
if file_rel.replace(os.path.sep, "/") in self.installed_mods[mod]["mod_files"]:
unresolved_files.remove(file)
if file in unresolved_files:
unknown_mod[os.path.basename(file)] = {"mod_files": [file]}
for key in unknown_mod.keys():
self.installed_mods[key] = unknown_mod[key]
self.__window.set_installed_mods(self.installed_mods)
self.__window.set_available_mods(self.available_mods)
def index_stored_mods(self):
"""
Goes through all mods in ModManager.FOLDER_NAME and tries to add them to the available mod list.
Ignores mods that are already on the list
:return:
"""
self.available_mods = dict()
if self.__settings.get_game_folder() is None:
return
for file in os.listdir(os.path.join(self.__settings.get_game_folder(), LCSettings.FOLDER_NAME)):
full_path = os.path.join(self.__settings.get_mod_folder(), str(file))
if not self.is_valid_mod_file(full_path):
self.__logger.warning(f"File {file} is not a valid mod file but inside the mod storage folder!")
mod_name, mod_version, mod_files, orig_mod_files = self.get_mod_info(full_path)
if mod_name is None:
self.__logger.warning(f"Mod \"{full_path}\" did not have the expected path. Ignoring it ...")
continue
self.available_mods[mod_name] = {"path": file, "version": mod_version, "mod_files": mod_files,
"orig_mod_files": orig_mod_files}
self.__window.set_available_mods(self.available_mods)
def add_mod_file(self, file_path: str):
"""
Adds the mod to the mod list
:param file_path:
:return:
"""
if self.__settings.get_settings()["game_path"] is None:
self.__logger.error("Can't add a mod without a valid game path!")
if not self.is_valid_mod_file(file_path):
self.__logger.warning(f"File {file_path} was not a mod file!")
return
dst = os.path.join(self.__settings.get_mod_folder(),
os.path.basename(file_path))
if os.path.isfile(dst):
hash1 = self.get_mod_hash(file_path)
hash2 = self.get_mod_hash(dst)
if hash1 != hash2:
self.__logger.info("Given file is different than the one stored. Overwriting it!")
else:
self.__logger.info("Given file is the same as the one stored. Ignoring it!")
return
self.create_manager_folder()
self.__logger.info(f"File {file_path} added as a mod file ...")
shutil.copy(file_path,
os.path.join(self.__settings.get_mod_folder(), os.path.basename(file_path)))
self.index_stored_mods()
self.index_installed_mods()
def install_mod(self, mod_name: str):
"""
Installs the given mod by extracting all files into the game directory.
This assumes that the .zip is structured like the game folder as all mods should be
:param mod_name:
:return:
"""
if mod_name not in self.available_mods.keys():
self.__logger.critical(f"Tried to install a mod that doesn't exist: {mod_name}")
return
self.__logger.info(f"Installing mod \"{mod_name}\" ...")
mod_zip = self.available_mods[mod_name]["path"]
with ZipFile(os.path.join(self.__settings.get_mod_folder(), mod_zip), 'r') as zip_ref:
#zip_ref.extractall(self.__settings.get_game_folder())
contents = zip_ref.namelist()
with tempfile.TemporaryDirectory() as tmp_dir:
for file in contents:
content = file
if "icon.png" in file or "manifest.json" in file or file.endswith(".md"):
continue
file = self.__adjust_folder_paths(file)
#print("Extracting", content, "to", tmp_dir)
zip_ref.extract(content, tmp_dir)
if content.endswith(os.path.sep):
#print("Skipped moving", os.path.join(tmp_dir, content))
continue
#print("Moving", os.path.join(tmp_dir, content), "to",
# os.path.join(self.__settings.get_game_folder(), file))
parent_dir = os.path.join(self.__settings.get_game_folder().replace("/", os.path.sep),
file.replace("/", os.path.sep)).split(file.replace("/", os.path.sep))[0]
if not os.path.exists(parent_dir):
os.mkdir(parent_dir)
if not os.path.exists(os.path.join(self.__settings.get_game_folder().replace("/", os.path.sep), file.replace("/", os.path.sep))):
shutil.move(os.path.join(tmp_dir, content.replace("/", os.path.sep)), os.path.join(self.__settings.get_game_folder().replace("/", os.path.sep), file.replace("/", os.path.sep)))
self.index_installed_mods()
def uninstall_mod(self, mod_name: str):
"""
Uninstalls the given mod by removing all files (not folders) that the manager is aware of
Note: For untracked mods this will only be the .dll in the plugins folder
:param mod_name:
:return:
"""
self.__logger.info(f"Uninstalling mod \"{mod_name}\" ...")
for file in self.installed_mods[mod_name]["mod_files"]:
full_path = os.path.join(self.__settings.get_game_folder(), file)
if os.path.isfile(full_path):
self.__logger.debug(f"Deleting file \"{full_path}\" ...")
os.remove(full_path)
self.index_installed_mods()
def nuke_manager_files(self):
self.__logger.info("Deleting all manager related files ...")
self.__logger.debug(f"Deleting folder \"{self.__settings.get_mod_folder()}\"")
files = glob.glob(os.path.join(self.__settings.get_mod_folder(), '*.zip'))
for f in files:
self.__logger.debug(f"Deleting file \"{f}\"")
os.remove(f)
os.removedirs(self.__settings.get_mod_folder())
self.__logger.debug(f"Deleting configuration file \"{self.__settings.file_path}\"")
os.remove(self.__settings.file_path)
self.__app.exit(0)