mirror of
https://github.com/Omni-guides/Jackify.git
synced 2026-01-17 11:37:01 +01:00
1784 lines
71 KiB
Bash
1784 lines
71 KiB
Bash
#!/usr/bin/env bash
|
|
#
|
|
###################################################
|
|
# #
|
|
# A tool for running Wabbajack modlists on Linux #
|
|
# #
|
|
# Beta v0.69t - Omni 03/18/2025 #
|
|
# #
|
|
###################################################
|
|
|
|
# Full Changelog can be found here: https://github.com/Omni-guides/Wabbajack-Modlist-Linux/blob/main/binaries/omni-guides-sh.changelog.txt
|
|
|
|
# Parse --debug or -d flag before anything else
|
|
DEBUG=0
|
|
for arg in "$@"; do
|
|
if [[ "$arg" == "--debug" || "$arg" == "-d" ]]; then
|
|
DEBUG=1
|
|
export DEBUG
|
|
break
|
|
fi
|
|
# Do not shift here, just scan args
|
|
|
|
done
|
|
|
|
# Current Script Version (beta)
|
|
script_ver=0.69t
|
|
|
|
# Define modlist-specific configurations
|
|
declare -A modlist_configs=(
|
|
["wildlander"]="dotnet472"
|
|
["librum|apostasy"]="dotnet40 dotnet8"
|
|
["nordicsouls"]="dotnet40"
|
|
["livingskyrim|lsiv|ls4"]="dotnet40"
|
|
["lostlegacy"]="dotnet48"
|
|
)
|
|
|
|
# Set up and blank logs (simplified)
|
|
LOGFILE=$HOME/omni-guides-sh.log
|
|
echo "" >$HOME/omni-guides-sh.log
|
|
|
|
# Add our new logging function
|
|
log_status() {
|
|
local level="$1"
|
|
local message="$2"
|
|
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
|
|
|
|
# Always write to log file with timestamp but without color codes
|
|
echo "[$timestamp] [$level] $(echo "$message" | sed 's/\x1b\[[0-9;]*m//g')" >> "$LOGFILE"
|
|
|
|
# If DEBUG=1, print all messages to terminal, including DEBUG
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
echo -e "$message"
|
|
else
|
|
# Only display non-DEBUG messages to the user, preserving color codes
|
|
if [ "$level" != "DEBUG" ]; then
|
|
echo -e "$message"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Display banner
|
|
echo "╔══════════════════════════════════════════════════════════════════╗"
|
|
echo "║ Omni-Guides (beta) ║"
|
|
echo "║ ║"
|
|
echo "║ A tool for running Wabbajack modlists on Linux ║"
|
|
echo "╚══════════════════════════════════════════════════════════════════╝"
|
|
|
|
#########
|
|
# Intro #
|
|
#########
|
|
echo ""
|
|
log_status "INFO" "Omni-Guides Wabbajack Post-Install Script v$script_ver"
|
|
echo "───────────────────────────────────────────────────────────────────"
|
|
log_status "INFO" "This script automates the post-install steps for Wabbajack modlists on Linux/Steam Deck."
|
|
log_status "INFO" "It will configure your modlist location, install required components, and apply necessary fixes."
|
|
echo ""
|
|
log_status "WARN" "⚠ IMPORTANT: Use this script at your own risk."
|
|
log_status "INFO" "Please report any issues via GitHub (Omni-guides/Wabbajack-Modlist-Linux)."
|
|
echo "───────────────────────────────────────────────────────────────────"
|
|
echo -e "\e[33mPress any key to continue...\e[0m"
|
|
read -n 1 -s -r -p ""
|
|
|
|
#############
|
|
# Functions #
|
|
#############
|
|
|
|
##########################
|
|
# Cleanup Wine Processes #
|
|
##########################
|
|
|
|
cleanup_wine_procs() {
|
|
|
|
# Find and kill processes containing various process names
|
|
processes=$(pgrep -f "win7|win10|ShowDotFiles|protontricks")
|
|
if [[ -n "$processes" ]]; then
|
|
echo "$processes" | xargs kill -9
|
|
echo "Processes killed successfully." >>$LOGFILE 2>&1
|
|
else
|
|
echo "No matching processes found." >>$LOGFILE 2>&1
|
|
fi
|
|
|
|
pkill -9 winetricks
|
|
|
|
}
|
|
|
|
#############
|
|
# Set APPID #
|
|
#############
|
|
|
|
set_appid() {
|
|
|
|
echo "DEBUG: Extracting APPID from choice: '$choice'" >>$LOGFILE 2>&1
|
|
APPID=$(echo "$choice" | awk -F'[()]' '{print $2}')
|
|
echo "DEBUG: Extracted APPID: '$APPID'" >>$LOGFILE 2>&1
|
|
|
|
#APPID=$(echo $choice | awk {'print $NF'} | sed 's:^.\(.*\).$:\1:')
|
|
echo "APPID=$APPID" >>$LOGFILE 2>&1
|
|
|
|
if [ -z "$APPID" ]; then
|
|
echo "Error: APPID cannot be empty, exiting... Please tell Omni :("
|
|
cleaner_exit
|
|
fi
|
|
|
|
}
|
|
|
|
#############################
|
|
# Detect if running on deck #
|
|
#############################
|
|
|
|
detect_steamdeck() {
|
|
# Steamdeck or nah?
|
|
|
|
if [ -f "/etc/os-release" ] && grep -q "steamdeck" "/etc/os-release"; then
|
|
steamdeck=1
|
|
echo "Running on Steam Deck" >>$LOGFILE 2>&1
|
|
else
|
|
steamdeck=0
|
|
echo "NOT A steamdeck" >>$LOGFILE 2>&1
|
|
fi
|
|
|
|
}
|
|
|
|
# Modlist-specific steps spinner wrapper
|
|
modlist_specific_steps_spinner() {
|
|
echo "[DEBUG] modlist_specific_steps_spinner: DEBUG=$DEBUG" >&2
|
|
if [ "$DEBUG" = "1" ]; then
|
|
modlist_specific_steps
|
|
else
|
|
local pid
|
|
local spinner=('⠋' '⠙' '⠹' '⠸' '⠼' '⠴' '⠦' '⠧' '⠇' '⠏')
|
|
modlist_specific_steps >>"$LOGFILE" 2>&1 &
|
|
pid=$!
|
|
local i=0
|
|
local bar="=============== "
|
|
local msg="Progress: [${bar}] 30% - Running modlist-specific steps... "
|
|
while kill -0 "$pid" 2>/dev/null; do
|
|
printf "\r\033[K%s%s" "$msg" "${spinner[i]}"
|
|
i=$(( (i+1) % 10 ))
|
|
sleep 0.1
|
|
done
|
|
wait "$pid"
|
|
printf "\r\033[K"
|
|
fi
|
|
}
|
|
|
|
###########################################
|
|
# Detect Protontricks (flatpak or native) #
|
|
###########################################
|
|
|
|
detect_protontricks() {
|
|
echo -ne "\nDetecting if protontricks is installed..." >>$LOGFILE 2>&1
|
|
|
|
# Check if protontricks exists
|
|
if command -v protontricks >/dev/null 2>&1; then
|
|
protontricks_path=$(command -v protontricks)
|
|
# Check if the detected binary is actually a Flatpak wrapper
|
|
if [[ -f "$protontricks_path" ]] && grep -q "flatpak run" "$protontricks_path"; then
|
|
echo -e "Detected Protontricks is actually a Flatpak wrapper at $protontricks_path." >>$LOGFILE 2>&1
|
|
which_protontricks=flatpak
|
|
return 0
|
|
else
|
|
echo -e "Native Protontricks found at $protontricks_path." | tee -a $LOGFILE
|
|
which_protontricks=native
|
|
return 0 # Exit function since we confirmed native protontricks
|
|
fi
|
|
else
|
|
echo -e "Non-Flatpak Protontricks not found. Checking flatpak..." >>$LOGFILE 2>&1
|
|
if flatpak list | grep -iq protontricks; then
|
|
echo -e "Flatpak Protontricks is already installed." >>$LOGFILE 2>&1
|
|
which_protontricks=flatpak
|
|
else
|
|
echo -e "\e[31m\n** Protontricks not found. Do you wish to install it? (y/n): **\e[0m"
|
|
read -p " " answer
|
|
if [[ $answer =~ ^[Yy]$ ]]; then
|
|
if [[ $steamdeck -eq 1 ]]; then
|
|
if flatpak install -u -y --noninteractive flathub com.github.Matoking.protontricks; then
|
|
which_protontricks=flatpak
|
|
else
|
|
echo -e "\n\e[31mFailed to install Protontricks via Flatpak. Please install it manually and rerun this script.\e[0m" | tee -a $LOGFILE
|
|
exit 1
|
|
fi
|
|
else
|
|
read -p "Choose installation method: 1) Flatpak (preferred) 2) Native: " choice
|
|
if [[ $choice =~ 1 ]]; then
|
|
if flatpak install -u -y --noninteractive flathub com.github.Matoking.protontricks; then
|
|
which_protontricks=flatpak
|
|
else
|
|
echo -e "\n\e[31mFailed to install Protontricks via Flatpak. Please install it manually and rerun this script.\e[0m" | tee -a $LOGFILE
|
|
exit 1
|
|
fi
|
|
else
|
|
echo -e "\nSorry, there are too many distros to automate this!" | tee -a $LOGFILE
|
|
echo -e "Please check how to install Protontricks using your OS package manager (yum, dnf, apt, pacman, etc.)" | tee -a $LOGFILE
|
|
echo -e "\e[31mProtontricks is required for this script to function. Exiting.\e[0m" | tee -a $LOGFILE
|
|
exit 1
|
|
fi
|
|
fi
|
|
else
|
|
echo -e "\e[31mProtontricks is required for this script to function. Exiting.\e[0m" | tee -a $LOGFILE
|
|
exit 1
|
|
fi
|
|
fi
|
|
# After any install attempt, re-check for protontricks
|
|
if ! command -v protontricks >/dev/null 2>&1 && ! flatpak list | grep -iq protontricks; then
|
|
echo -e "\e[31mProtontricks is still not installed after attempted installation. Exiting.\e[0m" | tee -a $LOGFILE
|
|
exit 1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#############################
|
|
# Run protontricks commands #
|
|
#############################
|
|
|
|
run_protontricks() {
|
|
# Determine the protontricks binary path and create command array
|
|
if [ "$which_protontricks" = "flatpak" ]; then
|
|
local cmd=(flatpak run com.github.Matoking.protontricks)
|
|
else
|
|
local cmd=(protontricks)
|
|
fi
|
|
|
|
# Execute the command with all arguments
|
|
"${cmd[@]}" "$@"
|
|
}
|
|
|
|
###############################
|
|
# Detect Protontricks Version #
|
|
###############################
|
|
|
|
protontricks_version() {
|
|
# Get the current version of protontricks
|
|
protontricks_version=$(run_protontricks -V | cut -d ' ' -f 2 | sed 's/[()]//g')
|
|
|
|
# Remove any non-numeric characters from the version number
|
|
protontricks_version_cleaned=$(echo "$protontricks_version" | sed 's/[^0-9.]//g')
|
|
|
|
echo "Protontricks Version Cleaned = $protontricks_version_cleaned" >> "$LOGFILE" 2>&1
|
|
|
|
# Split the version into digits
|
|
IFS='.' read -r first_digit second_digit third_digit <<< "$protontricks_version_cleaned"
|
|
|
|
# Check if the second digit is defined and greater than or equal to 12
|
|
if [[ -n "$second_digit" && "$second_digit" -lt 12 ]]; then
|
|
echo "Your protontricks version is too old! Update to version 1.12 or newer and rerun this script. If 'flatpak run com.github.Matoking.protontricks -V' returns 'unknown', then please update via flatpak." | tee -a "$LOGFILE"
|
|
cleaner_exit
|
|
fi
|
|
}
|
|
|
|
#######################################
|
|
# Detect Skyrim or Fallout 4 Function #
|
|
#######################################
|
|
|
|
detect_game() {
|
|
# Define lookup table for games
|
|
declare -A game_lookup=(
|
|
["Skyrim"]="Skyrim Special Edition"
|
|
["Fallout 4"]="Fallout 4"
|
|
["Fallout New Vegas"]="Fallout New Vegas"
|
|
["FNV"]="Fallout New Vegas"
|
|
["Oblivion"]="Oblivion"
|
|
)
|
|
|
|
# Try direct match first
|
|
for pattern in "${!game_lookup[@]}"; do
|
|
if [[ $choice == *"$pattern"* ]]; then
|
|
gamevar="${game_lookup[$pattern]}"
|
|
which_game="${gamevar%% *}"
|
|
echo "Game variable set to $which_game." >>"$LOGFILE" 2>&1
|
|
echo "Game variable: $gamevar" >>"$LOGFILE" 2>&1
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
# Handle generic "Fallout" case
|
|
if [[ $choice == *"Fallout"* ]]; then
|
|
PS3="Please select a Fallout game (enter the number): "
|
|
select fallout_opt in "Fallout 4" "Fallout New Vegas"; do
|
|
if [[ -n $fallout_opt ]]; then
|
|
gamevar="$fallout_opt"
|
|
which_game="${gamevar%% *}"
|
|
echo "Game variable set to $which_game." >>"$LOGFILE" 2>&1
|
|
echo "Game variable: $gamevar" >>"$LOGFILE" 2>&1
|
|
return 0
|
|
else
|
|
echo "Invalid option"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# If no match found, show selection menu
|
|
PS3="Please select a game (enter the number): "
|
|
select opt in "Skyrim" "Fallout 4" "Fallout New Vegas" "Oblivion"; do
|
|
if [[ -n $opt ]]; then
|
|
gamevar="${game_lookup[$opt]}"
|
|
which_game="${gamevar%% *}"
|
|
echo "Game variable set to $which_game." >>"$LOGFILE" 2>&1
|
|
echo "Game variable: $gamevar" >>"$LOGFILE" 2>&1
|
|
return 0
|
|
else
|
|
echo "Invalid option"
|
|
fi
|
|
done
|
|
}
|
|
|
|
###################################
|
|
# Try to detect the Steam Library #
|
|
###################################
|
|
|
|
detect_steam_library() {
|
|
|
|
local libraryfolders_vdf="$HOME/.steam/steam/config/libraryfolders.vdf"
|
|
|
|
if [[ ! -f "$libraryfolders_vdf" ]]; then
|
|
echo "libraryfolders.vdf not found in ~/.steam/steam/config/. Please ensure Steam is installed." | tee -a "$LOGFILE"
|
|
return 1
|
|
fi
|
|
|
|
local library_paths=()
|
|
while IFS='' read -r line; do
|
|
if [[ "$line" =~ \"path\" ]]; then
|
|
local path=$(echo "$line" | sed 's/.*"path"\s*"\(.*\)"/\1/')
|
|
if [[ -n "$path" ]]; then
|
|
library_paths+=("$path/steamapps/common")
|
|
fi
|
|
fi
|
|
done <"$libraryfolders_vdf"
|
|
|
|
local found=0
|
|
for library_path in "${library_paths[@]}"; do
|
|
if [[ -d "$library_path/$gamevar" ]]; then
|
|
steam_library="$library_path"
|
|
found=1
|
|
echo "Found '$gamevar' in $steam_library." >>$LOGFILE 2>&1
|
|
break
|
|
else
|
|
echo "Checking $library_path: '$gamevar' not found." >>$LOGFILE 2>&1
|
|
fi
|
|
done
|
|
|
|
if [[ "$found" -eq 0 ]]; then
|
|
echo "Vanilla game not found in Steam library locations." | tee -a "$LOGFILE"
|
|
|
|
while true; do
|
|
echo -e "\n** Enter the path to your Vanilla $gamevar directory manually (e.g. /data/SteamLibrary/steamapps/common/$gamevar): **"
|
|
read -e -r gamevar_input
|
|
|
|
steam_library_input="${gamevar_input%/*}/"
|
|
|
|
if [[ -d "$steam_library_input/$gamevar" ]]; then
|
|
steam_library="$steam_library_input"
|
|
echo "Found $gamevar in $steam_library_input." | tee -a "$LOGFILE"
|
|
echo "Steam Library set to: $steam_library" >>$LOGFILE 2>&1
|
|
break
|
|
else
|
|
echo "Game not found in $steam_library_input. Please enter a valid path to Vanilla $gamevar." | tee -a "$LOGFILE"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
echo "Steam Library Location: $steam_library" >>$LOGFILE 2>&1
|
|
|
|
if [[ "$steamdeck" -eq 1 && "$steam_library" == "/run/media"* ]]; then
|
|
basegame_sdcard=1
|
|
fi
|
|
|
|
}
|
|
|
|
#################################
|
|
# Detect Modlist Directory Path #
|
|
#################################
|
|
|
|
detect_modlist_dir_path() {
|
|
log_status "DEBUG" "Detecting $MODLIST Install Directory..."
|
|
local modlist_paths=()
|
|
local choice modlist_ini_temp
|
|
local pattern=$(echo "$MODLIST" | sed 's/ /.*\|/g')
|
|
|
|
# Search for ModOrganizer.exe entries matching the modlist pattern
|
|
while IFS= read -r entry; do
|
|
modlist_paths+=("$(dirname "${entry//[\"\']/}")")
|
|
done < <(strings ~/.steam/steam/userdata/*/config/shortcuts.vdf | grep -iE "ModOrganizer.exe" | grep -iE "$pattern")
|
|
|
|
# If no exact matches, get all ModOrganizer.exe instances
|
|
if [[ ${#modlist_paths[@]} -eq 0 ]]; then
|
|
echo "No exact matches found. Searching for all ModOrganizer.exe instances..."
|
|
while IFS= read -r entry; do
|
|
modlist_paths+=("$(dirname "${entry//[\"\']/}")")
|
|
done < <(strings ~/.steam/steam/userdata/*/config/shortcuts.vdf | grep -iE "ModOrganizer.exe")
|
|
fi
|
|
|
|
# Handle different cases based on number of paths found
|
|
if [[ ${#modlist_paths[@]} -eq 0 ]]; then
|
|
# No paths found - must enter manually
|
|
echo -e "\e[34mNo ModOrganizer.exe entries found. Please enter the directory manually:\e[0m"
|
|
read -r -e modlist_dir
|
|
elif [[ ${#modlist_paths[@]} -eq 1 ]]; then
|
|
# Single path found - use it directly without output
|
|
modlist_dir="${modlist_paths[0]}"
|
|
else
|
|
# Multiple paths found - show selection menu
|
|
echo "Select the ModOrganizer directory:"
|
|
for i in "${!modlist_paths[@]}"; do
|
|
echo -e "\e[33m$((i + 1))) ${modlist_paths[i]}\e[0m"
|
|
done
|
|
echo -e "\e[34m$(( ${#modlist_paths[@]} + 1 ))) Enter path manually\e[0m"
|
|
|
|
while true; do
|
|
read -p "Enter your choice (1-$((${#modlist_paths[@]} + 1))): " choice
|
|
if [[ "$choice" =~ ^[0-9]+$ && "$choice" -ge 1 && "$choice" -le $(( ${#modlist_paths[@]} + 1 )) ]]; then
|
|
if [[ "$choice" -eq $(( ${#modlist_paths[@]} + 1 )) ]]; then
|
|
echo -ne "\e[34mEnter the ModOrganizer directory path: \e[0m"
|
|
read -r -e modlist_dir
|
|
else
|
|
modlist_dir="${modlist_paths[choice - 1]}"
|
|
fi
|
|
break
|
|
else
|
|
echo "Invalid selection. Please try again."
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# Validate selection
|
|
modlist_ini_temp="$modlist_dir/ModOrganizer.ini"
|
|
while [[ ! -f "$modlist_ini_temp" ]]; do
|
|
echo "ModOrganizer.ini not found in $modlist_dir. Please enter a valid path."
|
|
echo -ne "\e[34mEnter the ModOrganizer directory path: \e[0m"
|
|
read -r -e modlist_dir
|
|
modlist_ini_temp="$modlist_dir/ModOrganizer.ini"
|
|
done
|
|
|
|
# Save and log results
|
|
modlist_ini="$modlist_ini_temp"
|
|
echo "Modlist directory: $modlist_dir" >> "$LOGFILE"
|
|
echo "Modlist INI location: $modlist_ini" >> "$LOGFILE"
|
|
}
|
|
|
|
#####################################################
|
|
# Set protontricks permissions on Modlist Directory #
|
|
#####################################################
|
|
|
|
set_protontricks_perms() {
|
|
if [ "$which_protontricks" = "flatpak" ]; then
|
|
log_status "INFO" "\nSetting Protontricks permissions..."
|
|
flatpak override --user com.github.Matoking.protontricks --filesystem="$modlist_dir"
|
|
log_status "SUCCESS" "Done!"
|
|
|
|
if [[ $steamdeck = 1 ]]; then
|
|
log_status "WARN" "\nChecking for SDCard and setting permissions appropriately.."
|
|
sdcard_path=$(df -h | grep "/run/media" | awk {'print $NF'})
|
|
echo "$sdcard_path" >>$LOGFILE 2>&1
|
|
flatpak override --user --filesystem=$sdcard_path com.github.Matoking.protontricks
|
|
flatpak override --user --filesystem=/run/media/mmcblk0p1 com.github.Matoking.protontricks
|
|
log_status "SUCCESS" "Done."
|
|
fi
|
|
else
|
|
log_status "DEBUG" "Using Native protontricks, skip setting permissions"
|
|
fi
|
|
}
|
|
|
|
#####################################
|
|
# Enable Visibility of (.)dot files #
|
|
#####################################
|
|
|
|
enable_dotfiles() {
|
|
log_status "DEBUG" "APPID=$APPID"
|
|
log_status "INFO" "\nEnabling visibility of (.)dot files..."
|
|
|
|
# Completely redirect all output to avoid any wine debug messages
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
dotfiles_check=$(run_protontricks -c 'wine reg query "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles' $APPID | grep ShowDotFiles | awk '{gsub(/\r/,""); print $NF}')
|
|
else
|
|
dotfiles_check=$(WINEDEBUG=-all run_protontricks -c 'wine reg query "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles' $APPID > /dev/null 2>&1; \
|
|
WINEDEBUG=-all run_protontricks -c 'wine reg query "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles' $APPID 2>/dev/null | grep ShowDotFiles | awk '{gsub(/\r/,""); print $NF}')
|
|
fi
|
|
|
|
log_status "DEBUG" "Current dotfiles setting: $dotfiles_check"
|
|
|
|
if [[ "$dotfiles_check" = "Y" ]]; then
|
|
log_status "INFO" "DotFiles already enabled via registry... skipping"
|
|
else
|
|
# Method 2: Set registry key (standard approach)
|
|
log_status "DEBUG" "Setting ShowDotFiles registry key..."
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
run_protontricks -c 'wine reg add "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles /d Y /f' $APPID
|
|
else
|
|
WINEDEBUG=-all run_protontricks -c 'wine reg add "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles /d Y /f' $APPID > /dev/null 2>&1
|
|
fi
|
|
# Method 3: Also try direct winecfg approach as backup
|
|
log_status "DEBUG" "Also setting via winecfg command..."
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
run_protontricks -c 'winecfg /v wine' $APPID
|
|
else
|
|
WINEDEBUG=-all run_protontricks -c 'winecfg /v wine' $APPID > /dev/null 2>&1
|
|
fi
|
|
# Method 4: Create user.reg entry if it doesn't exist
|
|
log_status "DEBUG" "Ensuring user.reg has correct entry..."
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
prefix_path=$(run_protontricks -c 'echo $WINEPREFIX' $APPID 2>/dev/null)
|
|
else
|
|
prefix_path=$(WINEDEBUG=-all run_protontricks -c 'echo $WINEPREFIX' $APPID 2>/dev/null)
|
|
fi
|
|
if [[ -n "$prefix_path" && -d "$prefix_path" ]]; then
|
|
if [[ -f "$prefix_path/user.reg" ]]; then
|
|
if ! grep -q "ShowDotFiles" "$prefix_path/user.reg" 2>/dev/null; then
|
|
echo '[Software\\Wine] 1603891765' >> "$prefix_path/user.reg" 2>/dev/null
|
|
echo '"ShowDotFiles"="Y"' >> "$prefix_path/user.reg" 2>/dev/null
|
|
fi
|
|
fi
|
|
fi
|
|
# Verify the setting took effect
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
dotfiles_verify=$(run_protontricks -c 'wine reg query "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles' $APPID | grep ShowDotFiles | awk '{gsub(/\r/,""); print $NF}')
|
|
else
|
|
dotfiles_verify=$(WINEDEBUG=-all run_protontricks -c 'wine reg query "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles' $APPID > /dev/null 2>&1; \
|
|
WINEDEBUG=-all run_protontricks -c 'wine reg query "HKEY_CURRENT_USER\Software\Wine" /v ShowDotFiles' $APPID 2>/dev/null | grep ShowDotFiles | awk '{gsub(/\r/,""); print $NF}')
|
|
fi
|
|
log_status "DEBUG" "Verification check: $dotfiles_verify"
|
|
log_status "SUCCESS" "Done!"
|
|
fi
|
|
}
|
|
|
|
###############################################
|
|
# Set Windows 10 version in the proton prefix #
|
|
###############################################
|
|
|
|
set_win10_prefix() {
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
run_protontricks --no-bwrap $APPID win10
|
|
else
|
|
WINEDEBUG=-all run_protontricks --no-bwrap $APPID win10 >/dev/null 2>&1
|
|
fi
|
|
}
|
|
|
|
######################################
|
|
# Install Wine Components & VCRedist #
|
|
######################################
|
|
|
|
install_wine_components() {
|
|
log_status "INFO" "Installing Wine Components... This can take some time, be patient!"
|
|
|
|
# Define game-specific component sets
|
|
local protontricks_appid="$APPID"
|
|
local protontricks_components=()
|
|
|
|
# Common components for all games
|
|
local common_components=("fontsmooth=rgb" "xact" "xact_x64" "vcrun2022")
|
|
|
|
# Game-specific configuration
|
|
case "$gamevar" in
|
|
"Skyrim Special Edition"|"Fallout 4")
|
|
protontricks_components=("${common_components[@]}" "d3dcompiler_47" "d3dx11_43" "d3dcompiler_43" "dotnet6" "dotnet7")
|
|
;;
|
|
"Fallout New Vegas")
|
|
protontricks_components=("${common_components[@]}" "d3dx9_43" "d3dx9")
|
|
protontricks_appid="22380" # Force appid for FNV
|
|
;;
|
|
"Oblivion")
|
|
protontricks_components=("${common_components[@]}" "d3dx9_43" "d3dx9")
|
|
;;
|
|
*)
|
|
echo "Unsupported game: $gamevar" | tee -a "$LOGFILE"
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
# Log the command we're about to run
|
|
echo "Installing components: ${protontricks_components[*]}" >>$LOGFILE 2>&1
|
|
|
|
# Run the installation with progress indicator
|
|
printf "Protontricks running... "
|
|
|
|
# Try up to 3 times to install components
|
|
local max_attempts=3
|
|
local attempt=1
|
|
local success=false
|
|
|
|
while [[ $attempt -le $max_attempts && $success == false ]]; do
|
|
if [[ $attempt -gt 1 ]]; then
|
|
echo "Retry attempt $attempt/$max_attempts..." | tee -a "$LOGFILE"
|
|
sleep 2
|
|
fi
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
run_protontricks --no-bwrap "$protontricks_appid" -q "${protontricks_components[@]}"
|
|
result=$?
|
|
else
|
|
WINEDEBUG=-all run_protontricks --no-bwrap "$protontricks_appid" -q "${protontricks_components[@]}" >/dev/null 2>&1
|
|
result=$?
|
|
fi
|
|
if [[ $result -eq 0 ]]; then
|
|
success=true
|
|
else
|
|
echo "Attempt $attempt failed, cleaning up wine processes before retry..." >>$LOGFILE 2>&1
|
|
cleanup_wine_procs
|
|
attempt=$((attempt+1))
|
|
fi
|
|
done
|
|
|
|
if [[ $success == true ]]; then
|
|
printf "Done.\n"
|
|
log_status "SUCCESS" "Wine Component installation completed."
|
|
else
|
|
printf "Failed.\n"
|
|
log_status "ERROR" "Component install failed after $max_attempts attempts."
|
|
return 1
|
|
fi
|
|
|
|
# Verify installation
|
|
log_status "DEBUG" "Verifying installed components..."
|
|
local output
|
|
output=$(run_protontricks --no-bwrap "$protontricks_appid" list-installed 2>/dev/null)
|
|
|
|
# Clean up and deduplicate the component list
|
|
local cleaned_output
|
|
cleaned_output=$(echo "$output" | grep -v "Using winetricks" | sort -u | grep -v '^$')
|
|
log_status "DEBUG" "Installed components (unique):"
|
|
echo "$cleaned_output" >> "$LOGFILE"
|
|
|
|
# Check for critical components only to avoid false negatives
|
|
local critical_components=("vcrun2022" "xact")
|
|
local missing_components=()
|
|
|
|
for component in "${critical_components[@]}"; do
|
|
if ! grep -q "$component" <<<"$output"; then
|
|
missing_components+=("$component")
|
|
fi
|
|
done
|
|
|
|
if [[ ${#missing_components[@]} -gt 0 ]]; then
|
|
echo -e "\nERROR: Some critical components are missing: ${missing_components[*]}" | tee -a "$LOGFILE"
|
|
return 1
|
|
else
|
|
echo "Critical components verified successfully." >>$LOGFILE 2>&1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
############################################
|
|
# Detect default compatdata Directory Path #
|
|
############################################
|
|
default_steam_compatdata_dir() {
|
|
# Prefer ~/.local/share/Steam if it exists
|
|
if [[ -d "$HOME/.local/share/Steam/steamapps/compatdata" ]]; then
|
|
echo "$HOME/.local/share/Steam/steamapps/compatdata"
|
|
elif [[ -d "$HOME/.steam/steam/steamapps/compatdata" ]]; then
|
|
echo "$HOME/.steam/steam/steamapps/compatdata"
|
|
else
|
|
# Do not create the directory; just return empty string
|
|
echo ""
|
|
fi
|
|
}
|
|
|
|
# Helper to get all Steam library folders from libraryfolders.vdf
|
|
get_all_steam_libraries() {
|
|
local vdf_file="$HOME/.steam/steam/config/libraryfolders.vdf"
|
|
local libraries=("$HOME/.local/share/Steam" "$HOME/.steam/steam")
|
|
if [[ -f "$vdf_file" ]]; then
|
|
while IFS='' read -r line; do
|
|
if [[ "$line" =~ "path" ]]; then
|
|
local path=$(echo "$line" | sed 's/.*"path"\s*"\(.*\)"/\1/')
|
|
if [[ -n "$path" ]]; then
|
|
libraries+=("$path")
|
|
fi
|
|
fi
|
|
done <"$vdf_file"
|
|
fi
|
|
echo "${libraries[@]}"
|
|
}
|
|
|
|
####################################
|
|
# Detect compatdata Directory Path #
|
|
####################################
|
|
|
|
detect_compatdata_path() {
|
|
local appid_to_check="$APPID"
|
|
if [[ "$gamevar" == "Fallout New Vegas" ]]; then
|
|
appid_to_check="22380"
|
|
local vdf_file="$HOME/.steam/steam/config/libraryfolders.vdf"
|
|
local libraries=("$HOME/.local/share/Steam" "$HOME/.steam/steam")
|
|
# Parse all additional libraries from the VDF
|
|
if [[ -f "$vdf_file" ]]; then
|
|
while IFS= read -r line; do
|
|
if [[ "$line" =~ "path" ]]; then
|
|
local path=$(echo "$line" | sed -E 's/.*"path"[ \t]*"([^"]+)".*/\1/')
|
|
if [[ "$path" == /* ]]; then
|
|
libraries+=("$path")
|
|
else
|
|
libraries+=("$HOME/$path")
|
|
fi
|
|
fi
|
|
done < "$vdf_file"
|
|
fi
|
|
compat_data_path=""
|
|
for lib in "${libraries[@]}"; do
|
|
local compat_path="$lib/steamapps/compatdata/$appid_to_check"
|
|
log_status "DEBUG" "Checking for compatdata at: $compat_path"
|
|
if [[ -d "$compat_path" ]]; then
|
|
compat_data_path="$compat_path"
|
|
log_status "DEBUG" "Found FNV compatdata: $compat_data_path"
|
|
break
|
|
fi
|
|
done
|
|
if [[ -z "$compat_data_path" ]]; then
|
|
log_status "ERROR" "Could not find compatdata directory for Fallout New Vegas (22380) in any Steam library."
|
|
log_status "ERROR" "Please ensure you have launched the vanilla Fallout New Vegas game at least once via Steam in the correct library."
|
|
return 1
|
|
fi
|
|
return 0
|
|
fi
|
|
# ... (existing logic for other games)
|
|
# Check common Steam library locations first
|
|
for path in "$HOME/.local/share/Steam/steamapps/compatdata" "$HOME/.steam/steam/steamapps/compatdata"; do
|
|
if [[ -d "$path/$appid_to_check" ]]; then
|
|
compat_data_path="$path/$appid_to_check"
|
|
log_status "DEBUG" "compatdata Path detected: $compat_data_path"
|
|
break
|
|
fi
|
|
done
|
|
|
|
# If not found in common locations, use find command
|
|
if [[ -z "$compat_data_path" ]]; then
|
|
find / -type d -name "compatdata" 2>/dev/null | while read -r compatdata_dir; do
|
|
if [[ -d "$compatdata_dir/$appid_to_check" ]]; then
|
|
compat_data_path="$compatdata_dir/$appid_to_check"
|
|
log_status "DEBUG" "compatdata Path detected: $compat_data_path"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if [[ -z "$compat_data_path" ]]; then
|
|
log_status "ERROR" "Directory named '$appid_to_check' not found in any compatdata directories."
|
|
log_status "ERROR" "Please ensure you have started the Steam entry for the modlist at least once, even if it fails.."
|
|
else
|
|
log_status "DEBUG" "Found compatdata directory with '$appid_to_check': $compat_data_path"
|
|
fi
|
|
}
|
|
|
|
#########################
|
|
# Detect Proton Version #
|
|
#########################
|
|
|
|
detect_proton_version() {
|
|
log_status "DEBUG" "Detecting Proton version..."
|
|
|
|
# Validate the compatdata path exists
|
|
if [[ ! -d "$compat_data_path" ]]; then
|
|
log_status "WARN" "Compatdata directory not found at '$compat_data_path'"
|
|
proton_ver="Unknown"
|
|
return 1
|
|
fi
|
|
|
|
# First try to get Proton version from the registry
|
|
if [[ -f "$compat_data_path/pfx/system.reg" ]]; then
|
|
local reg_output
|
|
reg_output=$(grep -A 3 "\"SteamClientProtonVersion\"" "$compat_data_path/pfx/system.reg" | grep "=" | cut -d= -f2 | tr -d '"' | tr -d ' ')
|
|
|
|
if [[ -n "$reg_output" ]]; then
|
|
# Keep GE versions as is, otherwise prefix with "Proton"
|
|
if [[ "$reg_output" == *"GE"* ]]; then
|
|
proton_ver="$reg_output" # Keep GE versions as is
|
|
else
|
|
proton_ver="Proton $reg_output"
|
|
fi
|
|
log_status "DEBUG" "Detected Proton version from registry: $proton_ver"
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
# Fallback to config_info if registry method fails
|
|
if [[ -f "$compat_data_path/config_info" ]]; then
|
|
local config_ver
|
|
config_ver=$(head -n 1 "$compat_data_path/config_info")
|
|
if [[ -n "$config_ver" ]]; then
|
|
# Keep GE versions as is, otherwise prefix with "Proton"
|
|
if [[ "$config_ver" == *"GE"* ]]; then
|
|
proton_ver="$config_ver" # Keep GE versions as is
|
|
else
|
|
proton_ver="Proton $config_ver"
|
|
fi
|
|
log_status "DEBUG" "Detected Proton version from config_info: $proton_ver"
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
proton_ver="Unknown"
|
|
log_status "WARN" "Could not detect Proton version"
|
|
return 1
|
|
}
|
|
|
|
###############################
|
|
# Confirmation before running #
|
|
###############################
|
|
|
|
confirmation_before_running() {
|
|
|
|
echo "" | tee -a $LOGFILE
|
|
echo -e "Detail Checklist:" | tee -a $LOGFILE
|
|
echo -e "=================" | tee -a $LOGFILE
|
|
echo -e "Modlist: $MODLIST .....\e[32m OK.\e[0m" | tee -a $LOGFILE
|
|
echo -e "Directory: $modlist_dir .....\e[32m OK.\e[0m" | tee -a $LOGFILE
|
|
echo -e "Proton Version: $proton_ver .....\e[32m OK.\e[0m" | tee -a $LOGFILE
|
|
echo -e "App ID: $APPID" | tee -a $LOGFILE
|
|
|
|
}
|
|
|
|
#################################
|
|
# chown/chmod modlist directory #
|
|
#################################
|
|
|
|
chown_chmod_modlist_dir() {
|
|
log_status "WARN" "Changing Ownership and Permissions of modlist directory (may require sudo password)"
|
|
|
|
user=$(whoami)
|
|
group=$(id -gn)
|
|
log_status "DEBUG" "User is $user and Group is $group"
|
|
|
|
sudo chown -R "$user:$group" "$modlist_dir"
|
|
sudo chmod -R 755 "$modlist_dir"
|
|
}
|
|
|
|
|
|
###############################################
|
|
# Backup ModOrganizer.ini and backup gamePath #
|
|
###############################################
|
|
|
|
backup_modorganizer() {
|
|
log_status "DEBUG" "Backing up ModOrganizer.ini: $modlist_ini"
|
|
cp "$modlist_ini" "$modlist_ini.$(date +"%Y%m%d_%H%M%S").bak"
|
|
grep gamePath "$modlist_ini" | sed '/^backupPath/! s/gamePath/backupPath/' >> "$modlist_ini"
|
|
}
|
|
|
|
########################################
|
|
# Blank or set MO2 Downloads Directory #
|
|
########################################
|
|
|
|
blank_downloads_dir() {
|
|
log_status "INFO" "\nEditing download_directory..."
|
|
sed -i "/download_directory/c\download_directory =" "$modlist_ini"
|
|
log_status "SUCCESS" "Done."
|
|
}
|
|
|
|
############################################
|
|
# Replace the gamePath in ModOrganizer.ini #
|
|
############################################
|
|
|
|
replace_gamepath() {
|
|
log_status "INFO" "Setting game path in ModOrganizer.ini..."
|
|
|
|
log_status "DEBUG" "Using Steam Library Path: $steam_library"
|
|
log_status "DEBUG" "Use SDCard?: $basegame_sdcard"
|
|
|
|
# Check if Modlist uses Game Root, Stock Game, etc.
|
|
game_path_line=$(grep '^gamePath' "$modlist_ini")
|
|
log_status "DEBUG" "Game Path Line: $game_path_line"
|
|
|
|
if [[ "$game_path_line" == *Stock\ Game* || "$game_path_line" == *STOCK\ GAME* || "$game_path_line" == *Stock\ Game\ Folder* || "$game_path_line" == *Stock\ Folder* || "$game_path_line" == *Skyrim\ Stock* || "$game_path_line" == *Game\ Root* || $game_path_line == *root\\\\Skyrim\ Special\ Edition* ]]; then
|
|
# Stock Game, Game Root or equivalent directory found
|
|
log_status "INFO" "Found Game Root/Stock Game or equivalent directory, editing Game Path..."
|
|
|
|
# Get the end of our path
|
|
if [[ $game_path_line =~ Stock\ Game\ Folder ]]; then
|
|
modlist_gamedir="$modlist_dir/Stock Game Folder"
|
|
log_status "DEBUG" "Modlist Gamedir: $modlist_gamedir"
|
|
elif [[ $game_path_line =~ Stock\ Folder ]]; then
|
|
modlist_gamedir="$modlist_dir/Stock Folder"
|
|
elif [[ $game_path_line =~ Skyrim\ Stock ]]; then
|
|
modlist_gamedir="$modlist_dir/Skyrim Stock"
|
|
log_status "DEBUG" "Modlist Gamedir: $modlist_gamedir"
|
|
elif [[ $game_path_line =~ Game\ Root ]]; then
|
|
modlist_gamedir="$modlist_dir/Game Root"
|
|
log_status "DEBUG" "Modlist Gamedir: $modlist_gamedir"
|
|
elif [[ $game_path_line =~ STOCK\ GAME ]]; then
|
|
modlist_gamedir="$modlist_dir/STOCK GAME"
|
|
log_status "DEBUG" "Modlist Gamedir: $modlist_gamedir"
|
|
elif [[ $game_path_line =~ Stock\ Game ]]; then
|
|
modlist_gamedir="$modlist_dir/Stock Game"
|
|
log_status "DEBUG" "Modlist Gamedir: $modlist_gamedir"
|
|
elif [[ $game_path_line =~ root\\\\Skyrim\ Special\ Edition ]]; then
|
|
modlist_gamedir="$modlist_dir/root/Skyrim Special Edition"
|
|
log_status "DEBUG" "Modlist Gamedir: $modlist_gamedir"
|
|
fi
|
|
|
|
if [[ "$modlist_sdcard" -eq "1" && "$steamdeck" -eq "1" ]]; then
|
|
log_status "DEBUG" "Using SDCard on Steam Deck"
|
|
modlist_gamedir_sdcard="${modlist_gamedir#*mmcblk0p1}"
|
|
sdcard_new_path="$modlist_gamedir_sdcard"
|
|
|
|
# Strip /run/media/deck/UUID if present
|
|
if [[ "$sdcard_new_path" == /run/media/deck/* ]]; then
|
|
sdcard_new_path="/${sdcard_new_path#*/run/media/deck/*/*}"
|
|
log_status "DEBUG" "SD Card Path after stripping: $sdcard_new_path"
|
|
fi
|
|
|
|
new_string="@ByteArray(D:${sdcard_new_path//\//\\\\})"
|
|
log_status "DEBUG" "New String: $new_string"
|
|
else
|
|
new_string="@ByteArray(Z:${modlist_gamedir//\//\\\\})"
|
|
log_status "DEBUG" "New String: $new_string"
|
|
fi
|
|
|
|
elif [[ "$game_path_line" == *steamapps* ]]; then
|
|
log_status "INFO" "Vanilla Game Directory required, editing Game Path..."
|
|
modlist_gamedir="$steam_library/$gamevar"
|
|
log_status "DEBUG" "Modlist Gamedir: $modlist_gamedir"
|
|
|
|
if [[ "$basegame_sdcard" -eq "1" && "$steamdeck" -eq "1" ]]; then
|
|
log_status "DEBUG" "Using SDCard on Steam Deck"
|
|
modlist_gamedir_sdcard="${modlist_gamedir#*mmcblk0p1}"
|
|
sdcard_new_path="$modlist_gamedir_sdcard/$gamevar"
|
|
new_string="@ByteArray(D:${sdcard_new_path//\//\\\\})"
|
|
log_status "DEBUG" "New String: $new_string"
|
|
else
|
|
new_string="@ByteArray(Z:${modlist_gamedir//\//\\\\})"
|
|
log_status "DEBUG" "New String: $new_string"
|
|
fi
|
|
else
|
|
log_status "WARN" "Neither Game Root, Stock Game or Vanilla Game directory found, Please launch MO and set path manually..."
|
|
return 1
|
|
fi
|
|
|
|
# Replace the string in the file
|
|
file_to_modify="$modlist_dir/ModOrganizer.ini"
|
|
escaped_new_string=$(printf '%s\n' "$new_string" | sed -e 's/[\/&]/\\&/g')
|
|
sed -i "/^gamePath/c\gamePath=$escaped_new_string" "$file_to_modify"
|
|
|
|
log_status "SUCCESS" "Game path set successfully"
|
|
}
|
|
|
|
##########################################
|
|
# Update Executables in ModOrganizer.ini #
|
|
##########################################
|
|
|
|
update_executables() {
|
|
|
|
# Take the line passed to the function
|
|
echo "Original Line: $orig_line_path" >>$LOGFILE 2>&1
|
|
|
|
skse_loc=$(echo "$orig_line_path" | cut -d '=' -f 2-)
|
|
echo "SKSE Loc: $skse_loc" >>$LOGFILE 2>&1
|
|
|
|
# Drive letter
|
|
if [[ "$modlist_sdcard" -eq 1 && "$steamdeck" -eq 1 ]]; then
|
|
echo "Using SDCard on Steam Deck" >>$LOGFILE 2>&1
|
|
drive_letter=" = D:"
|
|
else
|
|
drive_letter=" = Z:"
|
|
fi
|
|
|
|
# Find the workingDirectory number
|
|
|
|
binary_num=$(echo "$orig_line_path" | cut -d '=' -f -1)
|
|
echo "Binary Num: $binary_num" >>$LOGFILE 2>&1
|
|
|
|
# Find the equvalent workingDirectory
|
|
justnum=$(echo "$binary_num" | cut -d '\' -f 1)
|
|
bin_path_start=$(echo "$binary_num" | tr -d ' ' | sed 's/\\/\\\\/g')
|
|
path_start=$(echo "$justnum\\workingDirectory" | sed 's/\\/\\\\/g')
|
|
echo "Path Start: $path_start" >>$LOGFILE 2>&1
|
|
# Decide on steam apps or Stock Game etc
|
|
|
|
if [[ "$orig_line_path" == *"mods"* ]]; then
|
|
# mods path type found
|
|
echo -e "mods path Found" >>$LOGFILE 2>&1
|
|
|
|
# Path Middle / modlist_dr
|
|
if [[ "$modlist_sdcard" -eq 1 && "$steamdeck" -eq 1 ]]; then
|
|
echo "Using SDCard on Steam Deck" >>$LOGFILE 2>&1
|
|
drive_letter=" = D:"
|
|
echo "$modlist_dir" >>$LOGFILE 2>&1
|
|
path_middle="${modlist_dir#*mmcblk0p1}"
|
|
# Strip /run/media/deck/UUID
|
|
if [[ "$path_middle" == /run/media/*/* ]]; then
|
|
path_middle="/${path_middle#*/run/media/*/*/*}"
|
|
echo "Path Middle after stripping: $path_middle" >>$LOGFILE 2>&1
|
|
fi
|
|
else
|
|
path_middle="$modlist_dir"
|
|
fi
|
|
|
|
echo "Path Middle: $path_middle" >>$LOGFILE 2>&1
|
|
|
|
path_end=$(echo "${skse_loc%/*}" | sed 's/.*\/mods/\/mods/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end=$(echo "$skse_loc" | sed 's/.*\/mods/\/mods/')
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
elif grep -q -E "(Stock Game|Game Root|STOCK GAME|Stock Game Folder|Stock Folder|Skyrim Stock|root/Skyrim Special Edition)" <<<"$orig_line_path"; then
|
|
# STOCK GAME ROOT FOUND
|
|
echo -e "Stock/Game Root Found" >>$LOGFILE 2>&1
|
|
|
|
# Path Middle / modlist_dr
|
|
if [[ "$modlist_sdcard" -eq 1 && "$steamdeck" -eq 1 ]]; then
|
|
echo "Using SDCard on Steam Deck" >>$LOGFILE 2>&1
|
|
drive_letter=" = D:"
|
|
echo "Modlist Dir: $modlist_dir" >>$LOGFILE 2>&1
|
|
path_middle="${modlist_dir#*mmcblk0p1}"
|
|
# Strip /run/media/deck/UUID
|
|
if [[ "$path_middle" == /run/media/*/* ]]; then
|
|
path_middle="/${path_middle#*/run/media/*/*/*}"
|
|
echo "Path Middle after stripping: $path_middle" >>$LOGFILE 2>&1
|
|
fi
|
|
else
|
|
path_middle="$modlist_dir"
|
|
fi
|
|
echo "Path Middle: $path_middle" >>$LOGFILE 2>&1
|
|
|
|
# Get the end of our path
|
|
if [[ $orig_line_path =~ Stock\ Game ]]; then
|
|
dir_type="stockgame"
|
|
path_end=$(echo "${skse_loc%/*}" | sed 's/.*\/Stock Game/\/Stock Game/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end=$(echo "$skse_loc" | sed 's/.*\/Stock Game/\/Stock Game/')
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
elif [[ $orig_line_path =~ Game\ Root ]]; then
|
|
dir_type="gameroot"
|
|
path_end=$(echo "${skse_loc%/*}" | sed 's/.*\/Game Root/\/Game Root/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end=$(echo "$skse_loc" | sed 's/.*\/Game Root/\/Game Root/')
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
elif [[ $orig_line_path =~ STOCK\ GAME ]]; then
|
|
dir_type="STOCKGAME"
|
|
path_end=$(echo "${skse_loc%/*}" | sed 's/.*\/STOCK GAME/\/STOCK GAME/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end=$(echo "$skse_loc" | sed 's/.*\/STOCK GAME/\/STOCK GAME/')
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
elif [[ $orig_line_path =~ Stock\ Folder ]]; then
|
|
dir_type="stockfolder"
|
|
path_end=$(echo "${skse_loc%/*}" | sed 's/.*\/Stock Folder/\/Stock Folder/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end=$(echo "$skse_loc" | sed 's/.*\/Stock Folder/\/Stock Folder/')
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
elif [[ $orig_line_path =~ Skyrim\ Stock ]]; then
|
|
dir_type="skyrimstock"
|
|
path_end=$(echo "${skse_loc%/*}" | sed 's/.*\/Skyrim Stock/\/Skyrim Stock/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end=$(echo "$skse_loc" | sed 's/.*\/Skyrim Stock/\/Skyrim Stock/')
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
elif [[ $orig_line_path =~ Stock\ Game\ Folder ]]; then
|
|
dir_type="stockgamefolder"
|
|
path_end=$(echo "$skse_loc" | sed 's/.*\/Stock Game Folder/\/Stock Game Folder/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
elif [[ $orig_line_path =~ root\/Skyrim\ Special\ Edition ]]; then
|
|
dir_type="rootskyrimse"
|
|
path_end="/${skse_loc# }"
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end="/${skse_loc# }"
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
fi
|
|
elif [[ "$orig_line_path" == *"steamapps"* ]]; then
|
|
# STEAMAPPS FOUND
|
|
echo -e "steamapps Found" >>$LOGFILE 2>&1
|
|
|
|
# Path Middle / modlist_dr
|
|
if [[ "$basegame_sdcard" -eq "1" && "$steamdeck" -eq "1" ]]; then
|
|
echo "Using SDCard on Steam Deck" >>$LOGFILE 2>&1
|
|
path_middle="${steam_library#*mmcblk0p1}"
|
|
drive_letter=" = D:"
|
|
else
|
|
echo "Steamapps Steam Library Path: $steam_library"
|
|
path_middle=${steam_library%%steamapps*}
|
|
fi
|
|
echo "Path Middle: $path_middle" >>$LOGFILE 2>&1
|
|
path_end=$(echo "${skse_loc%/*}" | sed 's/.*\/steamapps/\/steamapps/')
|
|
echo "Path End: $path_end" >>$LOGFILE 2>&1
|
|
bin_path_end=$(echo "$skse_loc" | sed 's/.*\/steamapps/\/steamapps/')
|
|
echo "Bin Path End: $bin_path_end" >>$LOGFILE 2>&1
|
|
|
|
else
|
|
echo "No matching pattern found in the path: $orig_line_path" >>$LOGFILE 2>&1
|
|
bail_out=1
|
|
echo $bail_out >>$LOGFILE 2>&1
|
|
|
|
fi
|
|
|
|
echo "Bail Out: $bail_out" >>$LOGFILE 2>&1
|
|
|
|
if [[ $bail_out -eq 1 ]]; then
|
|
echo "Exiting function due to bail_out" >>$LOGFILE 2>&1
|
|
return
|
|
else
|
|
# Combine them all together
|
|
full_bin_path="$bin_path_start$drive_letter$path_middle$bin_path_end"
|
|
echo "Full Bin Path: $full_bin_path" >>$LOGFILE 2>&1
|
|
full_path="$path_start$drive_letter$path_middle$path_end"
|
|
echo "Full Path: $full_path" >>$LOGFILE 2>&1
|
|
|
|
# Replace forwardslashes with double backslashes
|
|
new_path=${full_path//\//\\\\\\\\}
|
|
echo "New Path: $new_path" >>$LOGFILE 2>&1
|
|
|
|
# Convert the lines in ModOrganizer.ini, if it isn't already
|
|
|
|
sed -i "\|^${bin_path_start}|s|^.*$|${full_bin_path}|" "$modlist_ini"
|
|
# Convert workingDirectory entries
|
|
sed -i "\|^${path_start}|s|^.*$|${new_path}|" "$modlist_ini"
|
|
fi
|
|
|
|
}
|
|
|
|
#################################################
|
|
# Edit Custom binary and workingDirectory paths #
|
|
#################################################
|
|
|
|
edit_binary_working_paths() {
|
|
|
|
grep -E -e "skse64_loader\.exe" -e "f4se_loader\.exe" "$modlist_ini" | while IFS= read -r orig_line_path; do
|
|
update_executables
|
|
done
|
|
|
|
}
|
|
|
|
################################
|
|
# Set or Select the Resolution #
|
|
################################
|
|
|
|
select_resolution() {
|
|
if [ "$steamdeck" -eq 1 ]; then
|
|
set_res="1280x800"
|
|
else
|
|
while true; do
|
|
echo -e "\e[31m ** Enter your desired resolution in the format 1920x1200: ** \e[0m"
|
|
read -p " " user_res
|
|
|
|
# Validate the input format
|
|
if [[ "$user_res" =~ ^[0-9]+x[0-9]+$ ]]; then
|
|
# Ask for confirmation
|
|
echo -e "\e[31m \n** Is $user_res your desired resolution? (y/N): ** \e[0m"
|
|
read -p " " confirm
|
|
if [[ "$confirm" =~ ^[Yy]$ ]]; then
|
|
set_res="$user_res"
|
|
break
|
|
else
|
|
echo "Please enter the resolution again." | tee -a $LOGFILE
|
|
fi
|
|
else
|
|
echo "Invalid input format. Please enter the resolution in the format 1920x1200." | tee -a $LOGFILE
|
|
fi
|
|
done
|
|
fi
|
|
|
|
echo "Resolution set to: $set_res" | tee -a $LOGFILE
|
|
}
|
|
|
|
######################################
|
|
# Update the resolution in INI files #
|
|
######################################
|
|
|
|
update_ini_resolution() {
|
|
|
|
echo -ne "\nEditing Resolution in prefs files... " | tee -a "$LOGFILE"
|
|
|
|
# Find all SSEDisplayTweaks.ini files in the specified directory and its subdirectories
|
|
ini_files=$(find "$modlist_dir" -name "SSEDisplayTweaks.ini")
|
|
|
|
if [[ "$gamevar" == "Skyrim Special Edition" && -n "$ini_files" ]]; then
|
|
while IFS= read -r ini_file; do
|
|
# Use awk to replace the lines with the new values, handling spaces in paths
|
|
awk -v res="$set_res" '/^(#?)Resolution[[:space:]]*=/ { print "Resolution=" res; next } \
|
|
/^(#?)Fullscreen[[:space:]]*=/ { print "Fullscreen=false"; next } \
|
|
/^(#?)#Fullscreen[[:space:]]*=/ { print "#Fullscreen=false"; next } \
|
|
/^(#?)Borderless[[:space:]]*=/ { print "Borderless=true"; next } \
|
|
/^(#?)#Borderless[[:space:]]*=/ { print "#Borderless=true"; next }1' "$ini_file" >"$ini_file.new"
|
|
|
|
cp "$ini_file.new" "$ini_file"
|
|
echo "Updated $ini_file with Resolution=$res, Fullscreen=false, Borderless=true" >>"$LOGFILE" 2>&1
|
|
echo -e " Done." >>"$LOGFILE" 2>&1
|
|
done <<<"$ini_files"
|
|
elif [[ "$gamevar" == "Fallout 4" ]]; then
|
|
echo "Not Skyrim, skipping SSEDisplayTweaks" >>"$LOGFILE" 2>&1
|
|
fi
|
|
|
|
##########
|
|
|
|
# Split $set_res into two variables
|
|
isize_w=$(echo "$set_res" | cut -d'x' -f1)
|
|
isize_h=$(echo "$set_res" | cut -d'x' -f2)
|
|
|
|
# Find all instances of skyrimprefs.ini, Fallout4Prefs.ini, falloutprefs.ini, or Oblivion.ini in specified directories
|
|
|
|
if [[ "$gamevar" == "Skyrim Special Edition" ]]; then
|
|
ini_files=$(find "$modlist_dir/profiles" "$modlist_dir/Stock Game" "$modlist_dir/Game Root" "$modlist_dir/STOCK GAME" "$modlist_dir/Stock Game Folder" "$modlist_dir/Stock Folder" "$modlist_dir/Skyrim Stock" -iname "skyrimprefs.ini" 2>/dev/null)
|
|
elif [[ "$gamevar" == "Fallout 4" ]]; then
|
|
ini_files=$(find "$modlist_dir/profiles" "$modlist_dir/Stock Game" "$modlist_dir/Game Root" "$modlist_dir/STOCK GAME" "$modlist_dir/Stock Game Folder" "$modlist_dir/Stock Folder" -iname "Fallout4Prefs.ini" 2>/dev/null)
|
|
elif [[ "$gamevar" == "Fallout New Vegas" ]]; then
|
|
ini_files=$(find "$modlist_dir/profiles" "$modlist_dir/Stock Game" "$modlist_dir/Game Root" "$modlist_dir/STOCK GAME" "$modlist_dir/Stock Game Folder" "$modlist_dir/Stock Folder" -iname "falloutprefs.ini" 2>/dev/null)
|
|
elif [[ "$gamevar" == "Oblivion" ]]; then
|
|
ini_files=$(find "$modlist_dir/profiles" "$modlist_dir/Stock Game" "$modlist_dir/Game Root" "$modlist_dir/STOCK GAME" "$modlist_dir/Stock Game Folder" "$modlist_dir/Stock Folder" -iname "Oblivion.ini" 2>/dev/null)
|
|
fi
|
|
|
|
if [ -n "$ini_files" ]; then
|
|
while IFS= read -r ini_file; do
|
|
# Use awk to replace the lines with the new values in the appropriate ini file
|
|
if [[ "$gamevar" == "Skyrim Special Edition" ]] || [[ "$gamevar" == "Fallout 4" ]] || [[ "$gamevar" == "Fallout New Vegas" ]]; then
|
|
awk -v isize_w="$isize_w" -v isize_h="$isize_h" '/^iSize W/ { print "iSize W = " isize_w; next } \
|
|
/^iSize H/ { print "iSize H = " isize_h; next }1' "$ini_file" >"$HOME/temp_file" && mv "$HOME/temp_file" "$ini_file"
|
|
elif [[ "$gamevar" == "Oblivion" ]]; then
|
|
awk -v isize_w="$isize_w" -v isize_h="$isize_h" '/^iSize W=/ { print "iSize W=" isize_w; next } \
|
|
/^iSize H=/ { print "iSize H=" isize_h; next }1' "$ini_file" >"$HOME/temp_file" && mv "$HOME/temp_file" "$ini_file"
|
|
fi
|
|
|
|
echo "Updated $ini_file with iSize W=$isize_w, iSize H=$isize_h" >>"$LOGFILE" 2>&1
|
|
done <<<"$ini_files"
|
|
else
|
|
echo "No suitable prefs.ini files found in specified directories. Please set manually using the INI Editor in MO2." | tee -a "$LOGFILE"
|
|
fi
|
|
|
|
echo -e "Done." | tee -a "$LOGFILE"
|
|
|
|
}
|
|
|
|
###################
|
|
# Edit resolution #
|
|
###################
|
|
|
|
edit_resolution() {
|
|
if [[ -n "$selected_resolution" ]]; then
|
|
log_status "DEBUG" "Applying resolution: $selected_resolution"
|
|
set_res="$selected_resolution"
|
|
update_ini_resolution
|
|
else
|
|
log_status "DEBUG" "Resolution setup skipped"
|
|
fi
|
|
}
|
|
|
|
##########################
|
|
# Small additional tasks #
|
|
##########################
|
|
|
|
small_additional_tasks() {
|
|
|
|
# Delete MO2 plugins that don't work via Proton
|
|
|
|
file_to_delete="$modlist_dir/plugins/FixGameRegKey.py"
|
|
|
|
if [ -e "$file_to_delete" ]; then
|
|
rm "$file_to_delete"
|
|
echo "File deleted: $file_to_delete" >>$LOGFILE 2>&1
|
|
else
|
|
echo "File does not exist: $file_to_delete" >>"$LOGFILE" 2>&1
|
|
fi
|
|
|
|
# Download Font to support Bethini
|
|
wget https://github.com/mrbvrz/segoe-ui-linux/raw/refs/heads/master/font/seguisym.ttf -q -nc -O "$compat_data_path/pfx/drive_c/windows/Fonts/seguisym.ttf"
|
|
|
|
}
|
|
|
|
###############################
|
|
# Set Steam Artwork Function #
|
|
###############################
|
|
|
|
set_steam_artwork() {
|
|
# Only run for Tuxborn modlist
|
|
if [[ "$MODLIST" == *"Tuxborn"* ]]; then
|
|
log_status "DEBUG" "Setting up Steam artwork for Tuxborn..."
|
|
|
|
# Source directory with artwork
|
|
local source_dir="$modlist_dir/Steam Icons"
|
|
|
|
if [[ ! -d "$source_dir" ]]; then
|
|
log_status "WARN" "Steam Icons directory not found at $source_dir"
|
|
return 1
|
|
fi
|
|
|
|
# Find all Steam userdata directories
|
|
for userdata_dir in "$HOME/.local/share/Steam/userdata" "$HOME/.steam/steam/userdata"; do
|
|
if [[ ! -d "$userdata_dir" ]]; then
|
|
continue
|
|
fi
|
|
|
|
# Process each user ID directory
|
|
for user_id_dir in "$userdata_dir"/*; do
|
|
if [[ ! -d "$user_id_dir" || "$user_id_dir" == *"0"* ]]; then
|
|
continue # Skip non-directories and the anonymous user
|
|
fi
|
|
|
|
# Create grid directory if it doesn't exist
|
|
local grid_dir="$user_id_dir/config/grid"
|
|
mkdir -p "$grid_dir"
|
|
|
|
# Copy grid-tall.png to both APPID.png and APPIDp.png
|
|
if [[ -f "$source_dir/grid-tall.png" ]]; then
|
|
cp "$source_dir/grid-tall.png" "$grid_dir/${APPID}.png"
|
|
log_status "DEBUG" "Copied grid-tall.png to ${APPID}.png"
|
|
cp "$source_dir/grid-tall.png" "$grid_dir/${APPID}p.png"
|
|
log_status "DEBUG" "Copied grid-tall.png to ${APPID}p.png"
|
|
fi
|
|
|
|
# Copy grid-hero.png to APPID_hero.png
|
|
if [[ -f "$source_dir/grid-hero.png" ]]; then
|
|
cp "$source_dir/grid-hero.png" "$grid_dir/${APPID}_hero.png"
|
|
log_status "DEBUG" "Copied grid-hero.png to ${APPID}_hero.png"
|
|
fi
|
|
|
|
# Copy grid-logo.png to APPID_logo.png
|
|
if [[ -f "$source_dir/grid-logo.png" ]]; then
|
|
cp "$source_dir/grid-logo.png" "$grid_dir/${APPID}_logo.png"
|
|
log_status "DEBUG" "Copied grid-logo.png to ${APPID}_logo.png"
|
|
fi
|
|
|
|
log_status "DEBUG" "Tuxborn artwork copied for user ID $(basename "$user_id_dir")"
|
|
done
|
|
done
|
|
|
|
log_status "DEBUG" "Steam artwork setup complete for Tuxborn"
|
|
fi
|
|
}
|
|
|
|
|
|
##########################
|
|
# Modlist Specific Steps #
|
|
##########################
|
|
|
|
modlist_specific_steps() {
|
|
local modlist_lower=$(echo "${MODLIST// /}" | tr '[:upper:]' '[:lower:]')
|
|
|
|
# Call the Steam artwork function for all modlists
|
|
set_steam_artwork | tee -a "$LOGFILE"
|
|
|
|
# Handle Wildlander specially due to its custom spinner animation
|
|
if [[ "$MODLIST" == *"Wildlander"* ]]; then
|
|
log_status "INFO" "\nRunning steps specific to \e[32m$MODLIST\e[0m. This can take some time, be patient!"
|
|
|
|
# Install dotnet with spinner animation
|
|
spinner=('⠋' '⠙' '⠹' '⠸' '⠼' '⠴' '⠦' '⠧' '⠇' '⠏')
|
|
run_protontricks --no-bwrap "$APPID" -q dotnet472 >/dev/null 2>&1 &
|
|
|
|
pid=$! # Store the PID of the background process
|
|
|
|
while kill -0 "$pid" >/dev/null 2>&1; do
|
|
for i in "${spinner[@]}"; do
|
|
echo -en "\r${i}\c"
|
|
sleep 0.1
|
|
done
|
|
done
|
|
|
|
wait "$pid" # Wait for the process to finish
|
|
|
|
# Clear the spinner and move to the next line
|
|
echo -en "\r\033[K" # Clear the spinner line
|
|
|
|
if [[ $? -ne 0 ]]; then
|
|
log_status "ERROR" "Component install failed with exit code $?"
|
|
else
|
|
log_status "SUCCESS" "Wine Component install completed successfully."
|
|
fi
|
|
|
|
new_output="$(run_protontricks --no-bwrap "$APPID" list-installed 2>/dev/null)"
|
|
log_status "DEBUG" "Components Found: $new_output"
|
|
return 0
|
|
fi
|
|
|
|
# Handle the rest of the modlists with the compact approach
|
|
for pattern in "${!modlist_configs[@]}"; do
|
|
if [[ "$pattern" != "wildlander" ]] && [[ "$modlist_lower" =~ ${pattern//|/|.*} ]]; then
|
|
log_status "INFO" "\nRunning steps specific to \e[32m$MODLIST\e[0m. This can take some time, be patient!"
|
|
|
|
IFS=' ' read -ra components <<< "${modlist_configs[$pattern]}"
|
|
for component in "${components[@]}"; do
|
|
if [[ "$component" == "dotnet8" ]]; then
|
|
log_status "INFO" "\nDownloading .NET 8 Runtime"
|
|
wget https://download.visualstudio.microsoft.com/download/pr/77284554-b8df-4697-9a9e-4c70a8b35f29/6763c16069d1ab8fa2bc506ef0767366/dotnet-runtime-8.0.5-win-x64.exe -q -nc --show-progress --progress=bar:force:noscroll -O "$HOME/Downloads/dotnet-runtime-8.0.5-win-x64.exe"
|
|
log_status "INFO" "Installing .NET 8 Runtime...."
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
run_protontricks --no-bwrap -c 'wine "$HOME/Downloads/dotnet-runtime-8.0.5-win-x64.exe" /Q' "$APPID"
|
|
else
|
|
WINEDEBUG=-all run_protontricks --no-bwrap -c 'wine "$HOME/Downloads/dotnet-runtime-8.0.5-win-x64.exe" /Q' "$APPID" >/dev/null 2>&1
|
|
fi
|
|
log_status "SUCCESS" "Done."
|
|
else
|
|
log_status "INFO" "Installing .NET ${component#dotnet}..."
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
run_protontricks --no-bwrap "$APPID" -q "$component"
|
|
else
|
|
WINEDEBUG=-all run_protontricks --no-bwrap "$APPID" -q "$component" >/dev/null 2>&1
|
|
fi
|
|
log_status "SUCCESS" "Done."
|
|
fi
|
|
done
|
|
|
|
set_win10_prefix
|
|
new_output="$(run_protontricks --no-bwrap "$APPID" list-installed 2>/dev/null)"
|
|
log_status "DEBUG" "Components Found: $new_output"
|
|
break
|
|
fi
|
|
done
|
|
}
|
|
|
|
######################################
|
|
# Create DXVK Graphics Pipeline file #
|
|
######################################
|
|
|
|
create_dxvk_file() {
|
|
echo "Use SDCard for DXVK File?: $basegame_sdcard" >>"$LOGFILE" 2>&1
|
|
echo -e "\nCreating dxvk.conf file - Checking if Modlist uses Game Root, Stock Game or Vanilla Game Directory.." >>"$LOGFILE" 2>&1
|
|
|
|
game_path_line=$(grep '^gamePath' "$modlist_ini")
|
|
echo "Game Path Line: $game_path_line" >>"$LOGFILE" 2>&1
|
|
|
|
if [[ "$game_path_line" == *Stock\ Game* || "$game_path_line" == *STOCK\ GAME* || "$game_path_line" == *Stock\ Game\ Folder* || "$game_path_line" == *Stock\ Folder* || "$game_path_line" == *Skyrim\ Stock* || "$game_path_line" == *Game\ Root* ]]; then
|
|
# Get the end of our path
|
|
if [[ $game_path_line =~ Stock\ Game\ Folder ]]; then
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/Stock Game Folder/dxvk.conf"
|
|
elif [[ $game_path_line =~ Stock\ Folder ]]; then
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/Stock Folder/dxvk.conf"
|
|
elif [[ $game_path_line =~ Skyrim\ Stock ]]; then
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/Skyrim Stock/dxvk.conf"
|
|
elif [[ $game_path_line =~ Game\ Root ]]; then
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/Game Root/dxvk.conf"
|
|
elif [[ $game_path_line =~ STOCK\ GAME ]]; then
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/STOCK GAME/dxvk.conf"
|
|
elif [[ $game_path_line =~ Stock\ Game ]]; then
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/Stock Game/dxvk.conf"
|
|
elif [[ $game_path_line =~ root\\Skyrim\ Special\ Edition ]]; then
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/root/Skyrim Special Edition/dxvk.conf"
|
|
fi
|
|
|
|
if [[ "$modlist_sdcard" -eq "1" ]]; then
|
|
echo "Using SDCard" >>"$LOGFILE" 2>&1
|
|
modlist_gamedir_sdcard="${modlist_gamedir#*mmcblk0p1}"
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_gamedir/dxvk.conf"
|
|
fi
|
|
|
|
elif [[ "$game_path_line" == *steamapps* ]]; then
|
|
echo -ne "Vanilla Game Directory required, editing Game Path.. " >>"$LOGFILE" 2>&1
|
|
modlist_gamedir="$steam_library"
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_gamedir/dxvk.conf"
|
|
if [[ "$basegame_sdcard" -eq "1" ]]; then
|
|
echo "Using SDCard" >>"$LOGFILE" 2>&1
|
|
modlist_gamedir_sdcard="${modlist_gamedir#*mmcblk0p1}"
|
|
echo "dxvk.enableGraphicsPipelineLibrary = False" >"$modlist_dir/$gamevar/dxvk.conf"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#############################
|
|
# Create protontricks alias #
|
|
#############################
|
|
|
|
protontricks_alias() {
|
|
if [[ "$which_protontricks" = "flatpak" ]]; then
|
|
local protontricks_alias_exists=$(grep "^alias protontricks=" ~/.bashrc)
|
|
local launch_alias_exists=$(grep "^alias protontricks-launch" ~/.bashrc)
|
|
|
|
if [[ -z "$protontricks_alias_exists" ]]; then
|
|
echo -e "\nAdding protontricks alias to ~/.bashrc"
|
|
echo "alias protontricks='flatpak run com.github.Matoking.protontricks'" >> ~/.bashrc
|
|
source ~/.bashrc
|
|
else
|
|
echo "protontricks alias already exists in ~/.bashrc" >> "$LOGFILE" 2>&1
|
|
fi
|
|
|
|
if [[ -z "$launch_alias_exists" ]]; then
|
|
echo -e "\nAdding protontricks-launch alias to ~/.bashrc"
|
|
echo "alias protontricks-launch='flatpak run --command=protontricks-launch com.github.Matoking.protontricks'" >> ~/.bashrc
|
|
source ~/.bashrc
|
|
else
|
|
echo "protontricks-launch alias already exists in ~/.bashrc" >> "$LOGFILE" 2>&1
|
|
fi
|
|
else
|
|
echo "Protontricks is not installed via flatpak, skipping alias creation." >> "$LOGFILE" 2>&1
|
|
fi
|
|
}
|
|
|
|
############################
|
|
# FNV Launch Option Notice #
|
|
############################
|
|
|
|
fnv_launch_options() {
|
|
log_status "DEBUG" "fnv_launch_options: gamevar='$gamevar', compat_data_path='$compat_data_path'"
|
|
if [[ "$gamevar" == "Fallout New Vegas" ]]; then
|
|
if [[ -n "$compat_data_path" && -d "$compat_data_path" ]]; then
|
|
log_status "WARN" "\n\e[41;97m======================= CRITICAL: STEAM LAUNCH OPTIONS =======================\e[0m"
|
|
log_status "SUCCESS" "\n\e[1;32mOpen the properties of your '$MODLIST' entry in Steam and add the following to the launch options:\e[0m"
|
|
log_status "SUCCESS" "\n\e[1;32mSTEAM_COMPAT_DATA_PATH=\"$compat_data_path\" %command%\e[0m"
|
|
log_status "WARN" "\e[41;97m=============================================================================\e[0m"
|
|
log_status "WARN" "\nThis is \e[1;4mESSENTIAL\e[0m for the modlist to load correctly. You \e[1;4mMUST\e[0m add it to your Steam launch options."
|
|
else
|
|
log_status "ERROR" "\nCould not determine the compatdata path for Fallout New Vegas. Please manually set the correct path in the Launch Options."
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################
|
|
# Exit more cleanly #
|
|
#####################
|
|
|
|
cleaner_exit() {
|
|
# Clean up wine and winetricks processes
|
|
cleanup_wine_procs
|
|
log_status "DEBUG" "Cleanup complete"
|
|
exit 1
|
|
}
|
|
|
|
####################
|
|
# END OF FUNCTIONS #
|
|
####################
|
|
|
|
#######################
|
|
# Note Script Version #
|
|
#######################
|
|
|
|
echo -e "Script Version $script_ver" >>"$LOGFILE" 2>&1
|
|
|
|
######################
|
|
# Note Date and Time #
|
|
######################
|
|
|
|
echo -e "Script started at: $(date +'%Y-%m-%d %H:%M:%S')" >>"$LOGFILE" 2>&1
|
|
|
|
#############################
|
|
# Detect if running on deck #
|
|
#############################
|
|
|
|
detect_steamdeck
|
|
|
|
###########################################
|
|
# Detect Protontricks (flatpak or native) #
|
|
###########################################
|
|
|
|
detect_protontricks
|
|
|
|
###############################
|
|
# Detect Protontricks Version #
|
|
###############################
|
|
|
|
protontricks_version
|
|
|
|
##########################################
|
|
# Create protontricks alias in ~/.bashrc #
|
|
##########################################
|
|
|
|
protontricks_alias
|
|
|
|
##############################################################
|
|
# List Skyrim and Fallout Modlists from Steam (protontricks) #
|
|
##############################################################
|
|
|
|
IFS=$'\n' readarray -t output_array < <(run_protontricks -l | tr -d $'\r' | grep -i 'Non-Steam shortcut' | grep -i 'Skyrim\|Fallout\|FNV\|Oblivion' | cut -d ' ' -f 3-)
|
|
|
|
if [[ ${#output_array[@]} -eq 0 ]]; then
|
|
echo "" | tee -a "$LOGFILE"
|
|
log_status "ERROR" "No modlists detected for Skyrim, Oblivion or Fallout/FNV!"
|
|
log_status "INFO" "Please make sure your entry in Steam is something like 'Skyrim - ModlistName'"
|
|
log_status "INFO" "or 'Fallout - ModlistName' AND that you have pressed play in Steam at least once!"
|
|
cleaner_exit
|
|
fi
|
|
|
|
echo "" | tee -a "$LOGFILE"
|
|
echo -e "\e[33mDetected Modlists:\e[0m" | tee -a "$LOGFILE"
|
|
|
|
# Print numbered list with color
|
|
for i in "${!output_array[@]}"; do
|
|
echo -e "\e[32m$((i + 1)))\e[0m ${output_array[$i]}"
|
|
done
|
|
|
|
# Read user selection with proper prompt
|
|
echo "───────────────────────────────────────────────────────────────────"
|
|
while true; do
|
|
read -p $'\e[33mSelect a modlist (1-'"${#output_array[@]}"$'): \e[0m' choice_num
|
|
|
|
# Add a debug flag at the top for easy toggling
|
|
DEBUG_MODLIST_SELECTION=0 # Set to 1 to enable extra debug output
|
|
|
|
# After reading user input for choice_num:
|
|
if [[ $DEBUG_MODLIST_SELECTION -eq 1 ]]; then
|
|
echo "[DEBUG] Raw user input: '$choice_num'" | tee -a "$LOGFILE"
|
|
fi
|
|
choice_num=$(echo "$choice_num" | xargs) # Trim whitespace
|
|
if [[ $DEBUG_MODLIST_SELECTION -eq 1 ]]; then
|
|
echo "[DEBUG] Trimmed user input: '$choice_num'" | tee -a "$LOGFILE"
|
|
fi
|
|
|
|
# Before the selection validation if-statement:
|
|
if [[ $DEBUG_MODLIST_SELECTION -eq 1 ]]; then
|
|
echo "[DEBUG] Validating: '$choice_num' =~ ^[0-9]+$ && $choice_num -ge 1 && $choice_num -le ${#output_array[@]}" | tee -a "$LOGFILE"
|
|
fi
|
|
|
|
# Validate selection properly
|
|
if [[ "$choice_num" =~ ^[0-9]+$ ]] && [[ "$choice_num" -ge 1 ]] && [[ "$choice_num" -le "${#output_array[@]}" ]]; then
|
|
if [[ $DEBUG_MODLIST_SELECTION -eq 1 ]]; then
|
|
echo "[DEBUG] Selection valid. Index: $((choice_num - 1)), Value: '${output_array[$((choice_num - 1))]}'" | tee -a "$LOGFILE"
|
|
fi
|
|
choice="${output_array[$((choice_num - 1))]}"
|
|
MODLIST=$(echo "$choice" | cut -d ' ' -f 3- | rev | cut -d ' ' -f 2- | rev)
|
|
log_status "DEBUG" "MODLIST: $MODLIST"
|
|
break # Exit the loop if selection is valid
|
|
else
|
|
if [[ $DEBUG_MODLIST_SELECTION -eq 1 ]]; then
|
|
echo "[DEBUG] Invalid selection. choice_num: '$choice_num', output_array length: ${#output_array[@]}" | tee -a "$LOGFILE"
|
|
fi
|
|
log_status "ERROR" "Invalid selection. Please enter a number between 1 and ${#output_array[@]}."
|
|
# Removed exit 1, so the loop continues
|
|
fi
|
|
done
|
|
|
|
# Add a newline after the selection for cleaner output
|
|
echo ""
|
|
|
|
# Initial detection phase
|
|
cleanup_wine_procs
|
|
set_appid
|
|
detect_game
|
|
detect_steam_library
|
|
detect_modlist_dir_path
|
|
|
|
# Set modlist_sdcard if required
|
|
modlist_sdcard=0
|
|
if [[ "$modlist_dir" =~ ^/run/media ]]; then
|
|
modlist_sdcard=1
|
|
fi
|
|
|
|
# Detect compatdata path and Proton version
|
|
detect_compatdata_path
|
|
detect_proton_version
|
|
|
|
# Get resolution preference
|
|
if [ "$steamdeck" -eq 1 ]; then
|
|
selected_resolution="1280x800"
|
|
log_status "INFO" "Steam Deck detected - Resolution will be set to 1280x800"
|
|
else
|
|
echo -e "Do you wish to set the display resolution? (This can be changed manually later)"
|
|
read -p $'\e[33mSet resolution? (y/N): \e[0m' response
|
|
|
|
if [[ "$response" =~ ^[Yy]$ ]]; then
|
|
while true; do
|
|
read -p $'\e[33mEnter resolution (e.g., 1920x1080): \e[0m' user_res
|
|
if [[ "$user_res" =~ ^[0-9]+x[0-9]+$ ]]; then
|
|
selected_resolution="$user_res"
|
|
log_status "DEBUG" "Resolution will be set to: $selected_resolution"
|
|
break
|
|
else
|
|
log_status "ERROR" "Invalid format. Please use format: 1920x1080"
|
|
fi
|
|
done
|
|
else
|
|
log_status "INFO" "Resolution setup skipped"
|
|
fi
|
|
fi
|
|
|
|
# Then show the detection summary including the resolution if set
|
|
echo -e "\n\e[1mDetection Summary:\e[0m" | tee -a "$LOGFILE"
|
|
echo -e "===================" | tee -a "$LOGFILE"
|
|
echo -e "Selected Modlist: \e[32m$MODLIST\e[0m" | tee -a "$LOGFILE"
|
|
echo -e "Game Type: \e[32m$gamevar\e[0m" | tee -a "$LOGFILE"
|
|
echo -e "Steam App ID: \e[32m$APPID\e[0m" | tee -a "$LOGFILE"
|
|
echo -e "Modlist Directory: \e[32m$modlist_dir\e[0m" | tee -a "$LOGFILE"
|
|
echo -e "Proton Version: \e[32m$proton_ver\e[0m" | tee -a "$LOGFILE"
|
|
if [[ -n "$selected_resolution" ]]; then
|
|
echo -e "Resolution: \e[32m$selected_resolution\e[0m" | tee -a "$LOGFILE"
|
|
fi
|
|
|
|
# Show simple confirmation with minimal info
|
|
read -rp $'\e[32mDo you want to proceed with the installation? (y/N)\e[0m ' proceed
|
|
|
|
if [[ $proceed =~ ^[Yy]$ ]]; then
|
|
if [ "$DEBUG" = "1" ]; then
|
|
{
|
|
# Protontricks setup (10%)
|
|
set_protontricks_perms
|
|
# Dotfiles (20%)
|
|
enable_dotfiles
|
|
# Modlist-specific steps (30%)
|
|
modlist_specific_steps
|
|
# Wine components (40%)
|
|
install_wine_components
|
|
# Windows 10 prefix (50%)
|
|
set_win10_prefix
|
|
# ModOrganizer configuration (70%)
|
|
backup_modorganizer
|
|
blank_downloads_dir
|
|
replace_gamepath
|
|
edit_binary_working_paths
|
|
# Resolution and additional tasks (90%)
|
|
edit_resolution
|
|
small_additional_tasks
|
|
create_dxvk_file
|
|
# Final steps (100%)
|
|
chown_chmod_modlist_dir
|
|
fnv_launch_options
|
|
} 2>&1 | tee -a "$LOGFILE"
|
|
else
|
|
# Function to update progress
|
|
update_progress() {
|
|
local percent=$1
|
|
local bar_length=50
|
|
local filled_length=$((percent * bar_length / 100))
|
|
local bar=""
|
|
for ((i = 0; i < bar_length; i++)); do
|
|
if [ $i -lt $filled_length ]; then
|
|
bar+="="
|
|
else
|
|
bar+=" "
|
|
fi
|
|
done
|
|
printf "\r[%-${bar_length}s] %d%%" "$bar" "$percent"
|
|
}
|
|
{
|
|
if [ "$DEBUG" != "1" ]; then
|
|
printf "\r\033[KProgress: [%-50s] %d%% - Setting up Protontricks..." " " "10"
|
|
fi
|
|
set_protontricks_perms >/dev/null 2>&1
|
|
if [ "$DEBUG" != "1" ]; then
|
|
printf "\r\033[KProgress: [%-50s] %d%% - Enabling dotfiles..." "========== " "20"
|
|
fi
|
|
enable_dotfiles >/dev/null 2>&1
|
|
if [ "$DEBUG" != "1" ]; then
|
|
modlist_specific_steps_spinner
|
|
else
|
|
modlist_specific_steps
|
|
fi
|
|
if [ "$DEBUG" != "1" ]; then
|
|
printf "\r\033[KProgress: [%-50s] %d%% - Installing Wine components..." "==================== " "40"
|
|
fi
|
|
install_wine_components >/dev/null 2>&1
|
|
if [ "$DEBUG" != "1" ]; then
|
|
printf "\r\033[KProgress: [%-50s] %d%% - Setting Windows 10 prefix..." "========================= " "50"
|
|
fi
|
|
set_win10_prefix >/dev/null 2>&1
|
|
if [ "$DEBUG" != "1" ]; then
|
|
printf "\r\033[KProgress: [%-50s] %d%% - Configuring Mod Organizer..." "=================================== " "70"
|
|
fi
|
|
backup_modorganizer >/dev/null 2>&1
|
|
blank_downloads_dir >/dev/null 2>&1
|
|
replace_gamepath >/dev/null 2>&1
|
|
edit_binary_working_paths >/dev/null 2>&1
|
|
if [ "$DEBUG" != "1" ]; then
|
|
printf "\r\033[KProgress: [%-50s] %d%% - Setting resolution and additional tasks..." "============================================ " "90"
|
|
fi
|
|
edit_resolution >/dev/null 2>&1
|
|
small_additional_tasks >/dev/null 2>&1
|
|
create_dxvk_file >/dev/null 2>&1
|
|
if [ "$DEBUG" != "1" ]; then
|
|
printf "\r\033[KProgress: [%-50s] %d%% - Completing installation..." "==================================================" "100"
|
|
fi
|
|
chown_chmod_modlist_dir
|
|
fnv_launch_options
|
|
} 2>>$LOGFILE
|
|
fi
|
|
# Show completion message
|
|
{
|
|
echo "" # Add blank line before success message
|
|
echo -e "\e[32m✓ Installation completed successfully!\e[0m"
|
|
echo -e "\n📝 Next Steps:"
|
|
echo " • Launch your modlist through Steam"
|
|
echo -e "\n💡 Detailed log available at: $LOGFILE\n"
|
|
} | tee -a "$LOGFILE"
|
|
# Show SD Card status if detected
|
|
if [[ "$steamdeck" -eq 1 ]]; then
|
|
if [[ "$modlist_dir" =~ ^/run/media/deck/[^/]+(/.*)?$ ]] || [[ "$modlist_dir" == "/run/media/mmcblk0p1"* ]]; then
|
|
echo -e "SD Card: \e[32mDetected\e[0m" | tee -a "$LOGFILE"
|
|
fi
|
|
else
|
|
if [[ "$modlist_dir" == "/run/media"* ]]; then
|
|
echo -e "Removable Media: \e[33mDetected at $modlist_dir\e[0m" | tee -a "$LOGFILE"
|
|
fi
|
|
fi
|
|
else
|
|
log_status "INFO" "Installation cancelled."
|
|
cleaner_exit
|
|
fi
|
|
|