T7x-Workshop-Downloader/boiiiwd.py
faroukbmiled 5bc155e55d add
2023-08-03 10:14:42 +01:00

999 lines
36 KiB
Python

import os
import sys
import re
import subprocess
import configparser
import json
import shutil
import zipfile
import psutil
import requests
import time
import threading
from bs4 import BeautifulSoup
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QDialog, \
QVBoxLayout, QMessageBox, QHBoxLayout, QProgressBar, QSizePolicy, QFileDialog, QCheckBox, QSpacerItem
from PyQt5.QtCore import Qt, QThread, pyqtSignal
from PyQt5.QtCore import QCoreApplication, QSettings
from PyQt5.QtGui import QIcon, QPixmap, QCloseEvent
import webbrowser
import qdarktheme
VERSION = "v0.1.3"
GITHUB_REPO = "faroukbmiled/BOIIIWD"
LATEST_RELEASE_URL = "https://github.com/faroukbmiled/BOIIIWD/releases/latest/download/Release.zip"
UPDATER_FOLDER = "update"
CONFIG_FILE_PATH = "config.ini"
global stopped, steampid, console, up_cancelled
steampid = None
stopped = False
console = False
up_cancelled = False
def get_latest_release_version():
try:
release_api_url = f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest"
response = requests.get(release_api_url)
response.raise_for_status()
data = response.json()
return data["tag_name"]
except requests.exceptions.RequestException as e:
show_message("Warning", f"Error while checking for updates: \n{e}")
return None
def create_update_script(current_exe, new_exe, updater_folder, program_name):
script_content = f"""
@echo off
echo Terminating BOIIIWD.exe...
taskkill /im "{program_name}" /t /f
echo Replacing BOIIIWD.exe...
cd "{updater_folder}"
taskkill /im "{program_name}" /t /f
move /y "{new_exe}" "../"{program_name}""
echo Starting BOIIIWD.exe...
cd ..
start "" "{current_exe}"
echo Exiting!
exit
"""
script_path = os.path.join(updater_folder, "boiiiwd_updater.bat")
with open(script_path, "w") as script_file:
script_file.write(script_content)
return script_path
def cwd():
if getattr(sys, 'frozen', False):
return os.path.dirname(sys.executable)
else:
return os.path.dirname(os.path.abspath(__file__))
def extract_workshop_id(link):
try:
pattern = r'(?<=id=)(\d+)'
match = re.search(pattern, link)
if match:
return match.group(0)
else:
return None
except:
return None
def check_steamcmd():
steamcmd_path = get_steamcmd_path()
steamcmd_exe_path = os.path.join(steamcmd_path, "steamcmd.exe")
if not os.path.exists(steamcmd_exe_path):
return False
return True
def initialize_steam():
try:
steamcmd_path = get_steamcmd_path()
steamcmd_exe_path = os.path.join(steamcmd_path, "steamcmd.exe")
process = subprocess.Popen([steamcmd_exe_path, "+quit"], creationflags=subprocess.CREATE_NEW_CONSOLE)
process.wait()
show_message("Done!", "BOIIIWD is ready for action.", icon=QMessageBox.Information)
except:
show_message("Done!", "An error occurred please check your paths and try again.")
def valid_id(workshop_id):
url = f"https://steamcommunity.com/sharedfiles/filedetails/?id={workshop_id}"
response = requests.get(url)
response.raise_for_status()
content = response.text
soup = BeautifulSoup(content, "html.parser")
try:
soup.find("div", class_="rightDetailsBlock").text.strip()
soup.find("div", class_="workshopItemTitle").text.strip()
soup.find("div", class_="detailsStatRight").text.strip()
stars_div = soup.find("div", class_="fileRatingDetails")
stars_div.find("img")["src"]
return True
except:
return False
def convert_speed(speed_bytes):
if speed_bytes < 1024:
return speed_bytes, "B/s"
elif speed_bytes < 1024 * 1024:
return speed_bytes / 1024, "KB/s"
elif speed_bytes < 1024 * 1024 * 1024:
return speed_bytes / (1024 * 1024), "MB/s"
else:
return speed_bytes / (1024 * 1024 * 1024), "GB/s"
def create_default_config():
config = configparser.ConfigParser()
config["Settings"] = {
"SteamCMDPath": cwd(),
"DestinationFolder": "",
"checkforupdtes": "on",
"console": "off"
}
with open(CONFIG_FILE_PATH, "w") as config_file:
config.write(config_file)
def run_steamcmd_command(command):
steamcmd_path = get_steamcmd_path()
show_console = subprocess.CREATE_NO_WINDOW
if console:
show_console = subprocess.CREATE_NEW_CONSOLE
process = subprocess.Popen(
[steamcmd_path + "\steamcmd.exe"] + command.split(),
stdout=None if console else subprocess.PIPE,
stderr=None if console else subprocess.PIPE,
text=True,
bufsize=1,
universal_newlines=True,
creationflags=show_console
)
global steampid
steampid = process.pid
if process.poll() is not None:
return process.returncode
process.communicate()
if process.returncode != 0:
show_message("Warning", "SteamCMD encountered an error while downloading, try again!")
return process.returncode
def get_steamcmd_path():
config = configparser.ConfigParser()
config.read(CONFIG_FILE_PATH)
return config.get("Settings", "SteamCMDPath", fallback=cwd())
def config_check_for_updates(state=None):
if state:
config = configparser.ConfigParser()
config.read(CONFIG_FILE_PATH)
config["Settings"]["checkforupdtes"] = state
with open(CONFIG_FILE_PATH, "w") as config_file:
config.write(config_file)
return
config = configparser.ConfigParser()
config.read(CONFIG_FILE_PATH)
return config.get("Settings", "checkforupdtes", fallback="on")
def config_console_state(state=None):
if state:
config = configparser.ConfigParser()
config.read(CONFIG_FILE_PATH)
config["Settings"]["console"] = state
with open(CONFIG_FILE_PATH, "w") as config_file:
config.write(config_file)
return
config = configparser.ConfigParser()
config.read(CONFIG_FILE_PATH)
return config.get("Settings", "console", fallback="off")
def extract_json_data(json_path):
with open(json_path, "r") as json_file:
data = json.load(json_file)
return data["Type"], data["FolderName"]
def convert_bytes_to_readable(size_in_bytes):
for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
if size_in_bytes < 1024.0:
return f"{size_in_bytes:.2f} {unit}"
size_in_bytes /= 1024.0
def get_workshop_file_size(workshop_id, raw=None):
url = f"https://steamcommunity.com/sharedfiles/filedetails/?id={workshop_id}&searchtext="
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")
file_size_element = soup.find("div", class_="detailsStatRight")
try:
if raw:
file_size_text = file_size_element.get_text(strip=True)
file_size_text = file_size_text.replace(",", "")
file_size_in_mb = float(file_size_text.replace(" MB", ""))
file_size_in_bytes = int(file_size_in_mb * 1024 * 1024)
return convert_bytes_to_readable(file_size_in_bytes)
if file_size_element:
file_size_text = file_size_element.get_text(strip=True)
file_size_text = file_size_text.replace(",", "")
file_size_in_mb = float(file_size_text.replace(" MB", ""))
file_size_in_bytes = int(file_size_in_mb * 1024 * 1024)
return file_size_in_bytes
return None
except:
return None
def update_progress_bar(current_size, file_size, progress_bar):
if file_size is not None:
progress = int(current_size / file_size * 100)
progress_bar.setValue(progress)
def check_and_update_progress(file_size, folder_name_path, progress_bar, speed_label):
previous_net_speed = 0
while not stopped:
current_size = sum(os.path.getsize(os.path.join(folder_name_path, f)) for f in os.listdir(folder_name_path))
update_progress_bar(current_size, file_size, progress_bar)
current_net_speed = psutil.net_io_counters().bytes_recv
net_speed_bytes = current_net_speed - previous_net_speed
previous_net_speed = current_net_speed
net_speed, speed_unit = convert_speed(net_speed_bytes)
speed_label.setText(f"Network Speed: {net_speed:.2f} {speed_unit}")
QCoreApplication.processEvents()
time.sleep(1)
def download_workshop_map(workshop_id, destination_folder, progress_bar, speed_label):
file_size = get_workshop_file_size(workshop_id)
if file_size is None:
show_message("Error", "Failed to retrieve file size.")
return
download_folder = os.path.join(get_steamcmd_path(), "steamapps", "workshop", "downloads", "311210", workshop_id)
if not os.path.exists(download_folder):
os.makedirs(download_folder)
command = f"+login anonymous +workshop_download_item 311210 {workshop_id} +quit"
progress_thread = threading.Thread(target=check_and_update_progress, args=(file_size, download_folder, progress_bar, speed_label))
progress_thread.daemon = True
progress_thread.start()
run_steamcmd_command(command)
global stopped
stopped = True
progress_bar.setValue(100)
map_folder = os.path.join(get_steamcmd_path(), "steamapps", "workshop", "content", "311210", workshop_id)
json_file_path = os.path.join(map_folder, "workshop.json")
if os.path.exists(json_file_path):
global mod_type
mod_type, folder_name = extract_json_data(json_file_path)
if mod_type == "mod":
mods_folder = os.path.join(destination_folder, "mods")
folder_name_path = os.path.join(mods_folder, folder_name, "zone")
elif mod_type == "map":
usermaps_folder = os.path.join(destination_folder, "usermaps")
folder_name_path = os.path.join(usermaps_folder, folder_name, "zone")
else:
show_message("Error", "Invalid map type in workshop.json.")
return
os.makedirs(folder_name_path, exist_ok=True)
try:
shutil.copytree(map_folder, folder_name_path, dirs_exist_ok=True)
except Exception as E:
show_message("Error", f"Error copying files: {E}")
show_message("Download Complete", f"{mod_type} files are downloaded at \n{folder_name_path}\nYou can run the game now!", icon=QMessageBox.Information)
def show_message(title, message, icon=QMessageBox.Warning, exit_on_close=False):
msg = QMessageBox()
msg.setWindowTitle(title)
msg.setWindowIcon(QIcon('ryuk.ico'))
msg.setText(message)
msg.setIcon(icon)
if exit_on_close:
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.No)
msg.setDefaultButton(QMessageBox.Ok)
result = msg.exec_()
if result == QMessageBox.No:
sys.exit(0)
else:
msg.exec_()
class UpdatePorgressThread(QThread):
global up_cancelled
progress_update = pyqtSignal(int)
def __init__(self, label_progress, progress_bar, label_size):
super().__init__()
self.label_progress = label_progress
self.progress_bar = progress_bar
self.label_size = label_size
self.cancelled = False
def run(self):
try:
update_dir = os.path.join(os.getcwd(), UPDATER_FOLDER)
response = requests.get(LATEST_RELEASE_URL, stream=True)
response.raise_for_status()
current_exe = sys.argv[0]
program_name = os.path.basename(current_exe)
new_exe = os.path.join(update_dir, "BOIIIWD.exe")
if not os.path.exists(update_dir):
os.makedirs(update_dir)
zip_path = os.path.join(update_dir, "latest_version.zip")
total_size = int(response.headers.get('content-length', 0))
size = convert_bytes_to_readable(total_size)
self.label_size.setText(f"Size: {size}")
with open(zip_path, "wb") as zip_file:
chunk_size = 8192
current_size = 0
for chunk in response.iter_content(chunk_size=chunk_size):
if up_cancelled:
break
if chunk:
zip_file.write(chunk)
current_size += len(chunk)
progress = int(current_size / total_size * 100)
self.progress_update.emit(progress)
QCoreApplication.processEvents()
if not up_cancelled:
with zipfile.ZipFile(zip_path, "r") as zip_ref:
zip_ref.extractall(update_dir)
self.label_progress.setText("Update installed successfully!")
time.sleep(1)
script_path = create_update_script(current_exe, new_exe, update_dir, program_name)
subprocess.run(('cmd', '/C', 'start', '', fr'{script_path}'))
sys.exit(0)
else:
if os.path.exists(zip_path):
os.remove(fr"{zip_path}")
self.label_progress.setText("Update cancelled.")
except Exception as e:
self.label_progress.setText("Error installing the update.")
show_message("Warning", f"Error installing the update: {e}")
class UpdateProgressWindow(QDialog):
def __init__(self):
super().__init__()
self.setWindowTitle("Updating...")
self.setWindowIcon(QIcon('ryuk.ico'))
layout = QVBoxLayout()
info_layout = QHBoxLayout()
self.label_progress = QLabel("Downloading latest update from Github...")
info_layout.addWidget(self.label_progress, 3)
self.label_size = QLabel("File size: 0KB")
info_layout.addWidget(self.label_size, 1)
layout.addLayout(info_layout)
self.progress_bar = QProgressBar()
layout.addWidget(self.progress_bar)
spacer = QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
layout.addSpacerItem(spacer)
button_layout = QHBoxLayout()
self.cancel_button = QPushButton("Cancel")
self.cancel_button.clicked.connect(self.cancel_update)
button_layout.addItem(QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
button_layout.addWidget(self.cancel_button)
layout.addLayout(button_layout)
self.setLayout(layout)
global up_cancelled
self.thread = None
up_cancelled = False
def update_progress(self, value):
self.progress_bar.setValue(value)
def start_update(self):
self.thread = UpdatePorgressThread(self.label_progress, self.progress_bar, self.label_size)
self.thread.progress_update.connect(self.update_progress)
self.thread.finished.connect(self.on_update_finished)
self.thread.start()
def on_update_finished(self):
"""code"""
# self.accept()
def cancel_update(self):
global up_cancelled
up_cancelled = True
self.label_progress.setText("Update cancelled.")
def closeEvent(self, event: QCloseEvent):
global up_cancelled
if not up_cancelled:
self.cancel_update()
super().closeEvent(event)
class DownloadThread(QThread):
finished = pyqtSignal()
def __init__(self, workshop_id, destination_folder, progress_bar, label_speed):
super().__init__()
self.workshop_id = workshop_id
self.destination_folder = destination_folder
self.progress_bar = progress_bar
self.label_speed = label_speed
def run(self):
download_workshop_map(self.workshop_id, self.destination_folder, self.progress_bar, self.label_speed)
self.finished.emit()
class WorkshopDownloaderApp(QWidget):
def __init__(self):
super().__init__()
self.initUI()
if not check_steamcmd():
self.show_warning_message()
self.download_thread = None
self.button_download.setEnabled(True)
self.button_stop.setEnabled(False)
def show_warning_message(self):
msg_box = QMessageBox(self)
msg_box.setWindowTitle("Warning")
msg_box.setWindowIcon(QIcon('ryuk.ico'))
msg_box.setText("steamcmd.exe was not found in the specified directory.\nPress Download to get it or Press OK and select it from there!.")
msg_box.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
download_button = msg_box.addButton("Download", QMessageBox.AcceptRole)
download_button.clicked.connect(self.download_steamcmd)
msg_box.setDefaultButton(download_button)
result = msg_box.exec_()
if result == QMessageBox.Cancel:
sys.exit(0)
def download_steamcmd(self):
self.edit_steamcmd_path.setText(cwd())
self.save_config(self.edit_destination_folder.text(), self.edit_steamcmd_path.text())
steamcmd_url = "https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip"
steamcmd_zip_path = os.path.join(cwd(), "steamcmd.zip")
try:
response = requests.get(steamcmd_url)
response.raise_for_status()
with open(steamcmd_zip_path, "wb") as zip_file:
zip_file.write(response.content)
with zipfile.ZipFile(steamcmd_zip_path, "r") as zip_ref:
zip_ref.extractall(cwd())
if check_steamcmd():
os.remove(fr"{steamcmd_zip_path}")
show_message("Success", "SteamCMD has been downloaded ,Press ok to initialize it.", icon=QMessageBox.Information, exit_on_close=True)
initialize_steam()
else:
show_message("Error", "Failed to find steamcmd.exe after extraction.\nMake you sure to select the correct SteamCMD path (which is the current BOIIIWD path)")
os.remove(fr"{steamcmd_zip_path}")
except requests.exceptions.RequestException as e:
show_message("Error", f"Failed to download SteamCMD: {e}")
os.remove(fr"{steamcmd_zip_path}")
except zipfile.BadZipFile:
show_message("Error", "Failed to extract SteamCMD. The downloaded file might be corrupted.")
os.remove(fr"{steamcmd_zip_path}")
def check_for_updates(self, ignore_up_todate=False):
try:
latest_version = get_latest_release_version()
current_version = VERSION
if latest_version and latest_version != current_version:
msg_box = QMessageBox()
msg_box.setWindowTitle("Update Available")
msg_box.setWindowIcon(QIcon('ryuk.ico'))
msg_box.setText(f"An update is available!, Do you want to install it?\n\nCurrent Version: {current_version}\nLatest Version: {latest_version}")
msg_box.setIcon(QMessageBox.Information)
msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.No | QMessageBox.Open)
msg_box.setDefaultButton(QMessageBox.Yes)
result = msg_box.exec_()
if result == QMessageBox.Open:
webbrowser.open(f"https://github.com/{GITHUB_REPO}/releases/latest")
if result == QMessageBox.Yes:
update_progress_window = UpdateProgressWindow()
update_progress_window.start_update()
update_progress_window.exec_()
elif latest_version == current_version:
if ignore_up_todate:
return
msg_box = QMessageBox()
msg_box.setWindowTitle("Up to Date!")
msg_box.setWindowIcon(QIcon('ryuk.ico'))
msg_box.setText(f"No Updates Available!")
msg_box.setIcon(QMessageBox.Information)
msg_box.setStandardButtons(QMessageBox.Ok)
msg_box.setDefaultButton(QMessageBox.Ok)
result = msg_box.exec_()
except Exception as e:
show_message("Error", f"Error while checking for updates: \n{e}")
def initUI(self):
self.setWindowTitle(f'BOIII Workshop Downloader {VERSION}-beta')
self.setWindowIcon(QIcon('ryuk.ico'))
self.setGeometry(100, 100, 400, 200)
self.settings = QSettings("MyApp", "MyWindow")
self.restore_geometry()
layout = QVBoxLayout()
browse_layout = QHBoxLayout()
self.label_workshop_id = QLabel("Enter the Workshop ID or Link of the map/mod you want to download:")
browse_layout.addWidget(self.label_workshop_id, 3)
self.button_browse = QPushButton("Browse")
self.button_browse.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button_browse.clicked.connect(self.open_browser)
browse_layout.addWidget(self.button_browse, 1)
layout.addLayout(browse_layout)
info_workshop_layout = QHBoxLayout()
self.edit_workshop_id = QLineEdit()
self.edit_workshop_id.setPlaceholderText("Workshop ID/Link => Press info to see map/mod info")
self.edit_workshop_id.textChanged.connect(self.reset_file_size)
info_workshop_layout.addWidget(self.edit_workshop_id, 3)
layout.addLayout(info_workshop_layout)
self.info_button = QPushButton("Info")
self.info_button.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.info_button.clicked.connect(self.show_map_info)
info_workshop_layout.addWidget(self.info_button, 1)
self.label_destination_folder = QLabel("Enter Your BOIII folder:")
layout.addWidget(self.label_destination_folder, 3)
Boiii_Input = QHBoxLayout()
self.edit_destination_folder = QLineEdit()
self.edit_destination_folder.setPlaceholderText("Your BOIII Instalation folder")
Boiii_Input.addWidget(self.edit_destination_folder, 90)
layout.addLayout(Boiii_Input)
self.button_BOIII_browse = QPushButton("Select")
self.button_BOIII_browse.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button_BOIII_browse.clicked.connect(self.open_BOIII_browser)
Boiii_Input.addWidget(self.button_BOIII_browse, 10)
self.label_steamcmd_path = QLabel("Enter SteamCMD path (default):")
layout.addWidget(self.label_steamcmd_path)
steamcmd_path = QHBoxLayout()
self.edit_steamcmd_path = QLineEdit()
steamcmd_path.addWidget(self.edit_steamcmd_path, 90)
self.button_steamcmd_browse = QPushButton("Select")
self.button_steamcmd_browse.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button_steamcmd_browse.clicked.connect(self.open_steamcmd_path_browser)
steamcmd_path.addWidget(self.button_steamcmd_browse, 10)
layout.addLayout(steamcmd_path)
layout.addSpacing(10)
buttons_layout = QHBoxLayout()
self.button_download = QPushButton("Download")
self.button_download.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button_download.clicked.connect(self.download_map)
buttons_layout.addWidget(self.button_download, 70)
self.button_stop = QPushButton("Stop")
self.button_stop.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button_stop.clicked.connect(self.stop_download)
buttons_layout.addWidget(self.button_stop, 25)
layout.addLayout(buttons_layout)
InfoBar = QHBoxLayout()
self.label_speed = QLabel("Network Speed: 0 KB/s")
InfoBar.addWidget(self.label_speed, 3)
self.label_file_size = QLabel("File size: 0KB")
InfoBar.addWidget(self.label_file_size, 1)
InfoWidget = QWidget()
InfoWidget.setLayout(InfoBar)
layout.addWidget(InfoWidget)
self.progress_bar = QProgressBar()
layout.addWidget(self.progress_bar, 75)
spacer = QSpacerItem(10, 10, QSizePolicy.Expanding, QSizePolicy.Minimum)
layout.addSpacerItem(spacer)
check_for_update_layout = QHBoxLayout()
check_update_button = QPushButton("Check for Updates")
check_update_button.clicked.connect(self.check_for_updates)
check_update_button.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.check_for_update_layout = QVBoxLayout()
self.check_for_update_layout.addWidget(check_update_button)
self.show_more_button = QPushButton("Launch boiii")
self.show_more_button.clicked.connect(self.launch_boiii)
check_for_update_layout = QHBoxLayout()
check_for_update_layout.addWidget(check_update_button)
self.check_for_updates_checkbox = QPushButton("Settings")
self.check_for_updates_checkbox.clicked.connect(self.open_settings_dialog)
check_for_update_layout = QHBoxLayout()
check_for_update_layout.addWidget(check_update_button)
check_for_update_layout.addWidget(self.check_for_updates_checkbox)
check_for_update_layout.addWidget(self.show_more_button)
layout.addLayout(check_for_update_layout)
self.setLayout(layout)
self.load_config()
if config_check_for_updates() == "on":
self.check_for_updates(ignore_up_todate=True)
try:
global console
if config_console_state() == "on":
console = True
return 1
else:
console = False
return 0
except:
pass
def download_map(self):
global stopped
stopped = False
self.save_config(self.edit_destination_folder.text(), self.edit_steamcmd_path.text())
if not check_steamcmd():
self.show_warning_message()
return
steamcmd_path = get_steamcmd_path()
steamcmd_exe_path = os.path.join(steamcmd_path, "steamcmd.exe")
steamcmd_size = os.path.getsize(steamcmd_exe_path)
if steamcmd_size < 3 * 1024 * 1024:
show_message("Warning", "SteamCMD is not initialized, Press OK to do so!\nProgram may go unresponsive until SteamCMD is finished downloading.", icon=QMessageBox.Warning, exit_on_close=True)
initialize_steam()
return
workshop_id = self.edit_workshop_id.text().strip()
if not workshop_id.isdigit():
try:
if extract_workshop_id(workshop_id).strip().isdigit():
workshop_id = extract_workshop_id(workshop_id).strip()
else:
QMessageBox.warning(self, "Warning", "Please enter a valid Workshop ID.")
return
except:
QMessageBox.warning(self, "Warning", "Please enter a valid Workshop ID.")
return
if not valid_id(workshop_id):
QMessageBox.warning(self, "Warning", "Please enter a valid Workshop ID.")
return
destination_folder = self.edit_destination_folder.text()
steamcmd_path = self.edit_steamcmd_path.text()
self.label_file_size.setText(f"File size: {get_workshop_file_size(workshop_id, raw=True)}")
if not destination_folder:
show_message("Error", "Please select a destination folder.")
return
if not steamcmd_path:
show_message("Error", "Please enter the SteamCMD path.")
return
self.button_stop.setEnabled(True)
self.progress_bar.setValue(0)
self.button_download.setEnabled(False)
self.download_thread = DownloadThread(workshop_id, destination_folder, self.progress_bar, self.label_speed)
self.download_thread.finished.connect(self.on_download_finished)
self.download_thread.start()
def stop_download(self):
global stopped
stopped = True
subprocess.run(['taskkill', '/F', '/IM', 'steamcmd.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if self.download_thread and self.download_thread.isRunning():
self.download_thread.terminate()
self.button_download.setEnabled(True)
self.button_stop.setEnabled(False)
self.progress_bar.setValue(0)
self.label_speed.setText(f"Network Speed: {0:.2f} KB/s")
self.label_file_size.setText(f"File size: 0KB")
def open_BOIII_browser(self):
selected_folder = QFileDialog.getExistingDirectory(self, "Select BOIII Folder", "")
if selected_folder:
self.edit_destination_folder.setText(selected_folder)
self.save_config(self.edit_destination_folder.text(), self.edit_steamcmd_path.text())
def open_steamcmd_path_browser(self):
selected_folder = QFileDialog.getExistingDirectory(self, "Select SteamCMD Folder", "")
if selected_folder:
self.edit_steamcmd_path.setText(selected_folder)
self.save_config(self.edit_destination_folder.text(), self.edit_steamcmd_path.text())
def on_download_finished(self):
self.button_download.setEnabled(True)
self.progress_bar.setValue(0)
self.label_speed.setText(f"Network Speed: {0:.2f} KB/s")
self.label_file_size.setText(f"File size: 0KB")
self.button_stop.setEnabled(False)
self.save_config(self.edit_destination_folder.text(), self.edit_steamcmd_path.text())
def open_browser(self):
link = "https://steamcommunity.com/app/311210/workshop/"
webbrowser.open(link)
def load_config(self):
config = configparser.ConfigParser()
if os.path.exists(CONFIG_FILE_PATH):
config.read(CONFIG_FILE_PATH)
destination_folder = config.get("Settings", "DestinationFolder", fallback="")
steamcmd_path = config.get("Settings", "SteamCMDPath", fallback=cwd())
self.edit_destination_folder.setText(destination_folder)
self.edit_steamcmd_path.setText(steamcmd_path)
else:
create_default_config()
def save_config(self, destination_folder, steamcmd_path):
config = configparser.ConfigParser()
config.read(CONFIG_FILE_PATH)
config.set("Settings", "DestinationFolder", destination_folder)
config.set("Settings", "SteamCMDPath", steamcmd_path)
with open(CONFIG_FILE_PATH, "w") as config_file:
config.write(config_file)
def reset_file_size(self):
self.label_file_size.setText(f"File size: 0KB")
def show_map_info(self):
workshop_id = self.edit_workshop_id.text().strip()
if not workshop_id:
QMessageBox.warning(self, "Warning", "Please enter a Workshop ID first.")
return
if not workshop_id.isdigit():
try:
if extract_workshop_id(workshop_id).strip().isdigit():
workshop_id = extract_workshop_id(workshop_id).strip()
else:
QMessageBox.warning(self, "Warning", "Please enter a valid Workshop ID.")
return
except:
QMessageBox.warning(self, "Warning", "Please enter a valid Workshop ID.")
return
self.label_file_size.setText(f"File size: {get_workshop_file_size(workshop_id, raw=True)}")
try:
url = f"https://steamcommunity.com/sharedfiles/filedetails/?id={workshop_id}"
response = requests.get(url)
response.raise_for_status()
content = response.text
soup = BeautifulSoup(content, "html.parser")
try:
map_mod_type = soup.find("div", class_="rightDetailsBlock").text.strip()
map_name = soup.find("div", class_="workshopItemTitle").text.strip()
map_size = soup.find("div", class_="detailsStatRight").text.strip()
stars_div = soup.find("div", class_="fileRatingDetails")
stars = stars_div.find("img")["src"]
except:
QMessageBox.warning(self, "Warning", "Please enter a valid Workshop ID.")
return
try:
preview_image_element = soup.find("img", id="previewImage")
workshop_item_image_url = preview_image_element["src"]
except:
preview_image_element = soup.find("img", id="previewImageMain")
workshop_item_image_url = preview_image_element["src"]
image_response = requests.get(workshop_item_image_url)
image_response.raise_for_status()
stars_response = requests.get(stars)
stars_response.raise_for_status()
pixmap = QPixmap()
pixmap.loadFromData(image_response.content)
pixmap_stars = QPixmap()
pixmap_stars.loadFromData(stars_response.content)
label = QLabel(self)
label.setPixmap(pixmap)
label.setAlignment(Qt.AlignCenter)
label_stars = QLabel(self)
label_stars.setPixmap(pixmap_stars)
label_stars.setAlignment(Qt.AlignCenter)
info = (
f"Name: {map_name}<br>"
f"Type: {map_mod_type}<br>"
f"Size: {map_size}<br>"
)
msg_box = QMessageBox(self)
msg_box.setWindowTitle("Map/Mod Information")
msg_box.setWindowIcon(QIcon('ryuk.ico'))
msg_box.setIconPixmap(pixmap)
msg_box.setInformativeText(info)
msg_box.setDetailedText(f"Stars: {stars}\nLink: {url}")
msg_box.setStandardButtons(QMessageBox.Ok)
msg_box.exec_()
except requests.exceptions.RequestException as e:
show_message("Error", f"Failed to fetch map information.\nError: {e}")
def launch_boiii(self):
try:
boiii_path = os.path.join(self.edit_destination_folder.text(), "boiii.exe")
subprocess.Popen([boiii_path], cwd=self.edit_destination_folder.text())
except Exception as e:
show_message("Error: Failed to launch BOIII", f"Failed to launch boiii.exe\nMake sure to put in your correct boiii path\n{e}")
def open_settings_dialog(self):
settings_dialog = SettingsDialog()
settings_dialog.exec_()
def closeEvent(self, event):
self.settings.setValue("geometry", self.saveGeometry())
super().closeEvent(event)
def restore_geometry(self):
geometry = self.settings.value("geometry", None)
if geometry is not None:
self.restoreGeometry(geometry)
class SettingsDialog(QDialog):
def __init__(self):
super().__init__()
self.setWindowTitle("Settings")
self.setWindowIcon(QIcon('ryuk.ico'))
self.setGeometry(50, 50, 250, 120)
self.settings = QSettings("MyApp2", "MyWindow2")
self.restore_geometry()
self.initUI()
def initUI(self):
layout = QVBoxLayout()
self.check_updates_checkbox = QCheckBox("Check for updates on launch")
self.check_updates_checkbox.setChecked(self.load_settings(updates=True))
layout.addWidget(self.check_updates_checkbox)
buttons_layout = QHBoxLayout()
self.checkbox_show_console = QCheckBox("Console (On Download)", self)
self.checkbox_show_console.setChecked(self.load_settings(console=True))
tooltip_text = "<font color='black'>Toggle SteamCMD console\nPlease don't close the Console If you want to stop press the Stop boutton.</font>"
self.checkbox_show_console.setToolTip(tooltip_text)
buttons_layout.addWidget(self.checkbox_show_console, 5)
layout.addLayout(buttons_layout)
save_button = QPushButton("Save")
save_button.setFixedWidth(60)
save_button.clicked.connect(self.save_settings)
layout.addWidget(save_button, alignment=Qt.AlignLeft)
self.setLayout(layout)
def save_settings(self):
global console
if self.check_updates_checkbox.isChecked():
config_check_for_updates(state="on")
else:
config_check_for_updates(state="off")
if self.checkbox_show_console.isChecked():
config_console_state(state="on")
console = True
else:
config_console_state(state="off")
console = False
self.accept()
def load_settings(self, console=None, updates=None):
if updates:
if config_check_for_updates() == "on":
return 1
else:
return 0
if console:
if config_console_state() == "on":
console = True
return 1
else:
console = False
return 0
def closeEvent(self, event):
self.settings.setValue("geometry", self.saveGeometry())
super().closeEvent(event)
def restore_geometry(self):
geometry = self.settings.value("geometry", None)
if geometry is not None:
self.restoreGeometry(geometry)
if __name__ == "__main__":
app = QApplication(sys.argv)
qdarktheme.setup_theme()
if not os.path.exists(CONFIG_FILE_PATH):
create_default_config()
window = WorkshopDownloaderApp()
window.show()
sys.exit(app.exec_())