LinuxGSM/lgsm/modules/check_deps.sh

#!/bin/bash
# LinuxGSM check_deps.sh module
# Author: Daniel Gibbs
# Contributors: https://linuxgsm.com/contrib
# Website: https://linuxgsm.com
# Description: Checks and installs missing dependencies.

moduleselfname="$(basename "$(readlink -f "${BASH_SOURCE[0]}")")"

fn_install_dotnet_repo() {
	local dotnetpackage
	dotnetpackage="dotnet-runtime-7.0"

	for dep in "${array_deps_missing[@]}"; do
		if [[ "${dep}" == dotnet-runtime-* ]]; then
			dotnetpackage="${dep}"
			break
		fi
	done

	if [ "${distroid}" == "ubuntu" ] || [ "${distroid}" == "debian" ]; then
		# If the required .NET package is unavailable in Ubuntu/Debian repos, add the Microsoft repo.
		if ! apt-cache show "${dotnetpackage}" > /dev/null 2>&1; then
			if [ "${autodepinstall}" == "0" ]; then
				fn_fetch_file "https://packages.microsoft.com/config/${distroid}/${distroversion}/packages-microsoft-prod.deb" "" "" "" "/tmp" "packages-microsoft-prod.deb" "" "" "" ""
				sudo dpkg -i /tmp/packages-microsoft-prod.deb
			else
				fn_print_information_nl "Installing Microsoft repository."
				fn_print_warning_nl "${nosudomessage}"
				echo -e "Follow instructions on Microsoft website to install."
				echo -e "https://learn.microsoft.com/en-us/dotnet/core/install/linux"
				fn_script_log_warn "Unable to install Microsoft repository. ${nosudomessage}"
			fi
		fi
	fi
}

fn_install_mono_repo() {
	if [ "${autodepinstall}" == "0" ]; then
		fn_print_information_nl "Automatically adding Mono repository."
		fn_script_log_info "Automatically adding Mono repository."
		if [ -z "${plainoutput}" ]; then
			echo -en ".\r"
			fn_sleep_time_1
			echo -en "..\r"
			fn_sleep_time_1
			echo -en "...\r"
			fn_sleep_time_1
			echo -en "   \r"
		fi
		if [ "${distroid}" == "ubuntu" ]; then
			if [ "${distroversion}" == "22.04" ]; then
				cmd="sudo apt-get install gnupg ca-certificates;sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;echo 'deb https://download.mono-project.com/repo/ubuntu stable-jammy main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			elif [ "${distroversion}" == "20.04" ]; then
				cmd="sudo apt-get install gnupg ca-certificates;sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;echo 'deb https://download.mono-project.com/repo/ubuntu stable-focal main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			elif [ "${distroversion}" == "18.04" ]; then
				cmd="sudo apt-get install gnupg ca-certificates;sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;echo 'deb https://download.mono-project.com/repo/ubuntu stable-bionic main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			elif [ "${distroversion}" == "16.04" ]; then
				cmd="sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;sudo apt install apt-transport-https ca-certificates;echo 'deb https://download.mono-project.com/repo/ubuntu stable-xenial main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			else
				monoautoinstall="1"
			fi
		elif [ "${distroid}" == "debian" ]; then
			if [ "${distroversion}" == "12" ]; then
				cmd="sudo apt-get install apt-transport-https dirmngr gnupg ca-certificates;sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;echo 'deb https://download.mono-project.com/repo/debian stable-bookworm main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			elif [ "${distroversion}" == "11" ]; then
				cmd="sudo apt-get install apt-transport-https dirmngr gnupg ca-certificates;sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;echo 'deb https://download.mono-project.com/repo/debian stable-bullseye main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			elif [ "${distroversion}" == "10" ]; then
				cmd="sudo apt-get install apt-transport-https dirmngr gnupg ca-certificates;sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;echo 'deb https://download.mono-project.com/repo/debian stable-buster main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			elif [ "${distroversion}" == "9" ]; then
				cmd="sudo apt-get install apt-transport-https dirmngr gnupg ca-certificates;sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF;echo 'deb https://download.mono-project.com/repo/debian stable-stretch main' | sudo tee /etc/apt/sources.list.d/mono-official-stable.list;sudo apt update"
			else
				monoautoinstall="1"
			fi
		elif [ "${distroid}" == "centos" ] || [ "${distroid}" == "almalinux" ] || [ "${distroid}" == "rocky" ]; then
			if [ "${distroversion}" == "8" ]; then
				cmd="sudo rpmkeys --import 'https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF';su -c 'curl https://download.mono-project.com/repo/centos8-stable.repo | tee /etc/yum.repos.d/mono-centos8-stable.repo'"
			elif [ "${distroversion}" == "7" ]; then
				cmd="sudo rpmkeys --import 'https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF';su -c 'curl https://download.mono-project.com/repo/centos7-stable.repo | tee /etc/yum.repos.d/mono-centos7-stable.repo'"
			else
				monoautoinstall="1"
			fi
		elif [ "${distroid}" == "fedora" ]; then
			if [ "${distroversion}" -ge "29" ]; then
				cmd="sudo rpm --import 'https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF';su -c 'curl https://download.mono-project.com/repo/centos8-stable.repo | tee /etc/yum.repos.d/mono-centos8-stable.repo';dnf update"
			else
				cmd="sudo rpm --import 'https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF';su -c 'curl https://download.mono-project.com/repo/centos7-stable.repo | tee /etc/yum.repos.d/mono-centos7-stable.repo';dnf update"
			fi
		else
			monoautoinstall="1"
		fi

		# Run the mono repo install.
		eval "${cmd}"
		monorepoexitcode=$?

		# Did Mono repo install correctly?
		if [ "${monoautoinstall}" != "1" ]; then
			if [ "${monorepoexitcode}" -ne 0 ]; then
				fn_print_failure_nl "Unable to install Mono repository."
				fn_script_log_fail "Unable to install Mono repository."
			else
				fn_print_success_nl "Installing Mono repository completed."
				fn_script_log_pass "Installing Mono repository completed."
			fi
		fi

		# Mono can not be auto installed with this distro.
		if [ "${monoautoinstall}" == "1" ]; then
			fn_print_warning_nl "Mono auto install not available for ${distroname}."
			echo -e "Follow instructions on Mono website to install."
			echo -e "https://www.mono-project.com/download/stable/#download-lin"
			fn_script_log_warn "Unable to install Mono repository. Mono auto install not available for ${distroname}."
		fi

	else
		fn_print_information_nl "Installing Mono repository."
		fn_print_warning_nl "${nosudomessage}"
		echo -e "Follow instructions on Mono website to install."
		echo -e "https://www.mono-project.com/download/stable/#download-lin"
		fn_script_log_warn "Unable to install Mono repository. ${nosudomessage}"
	fi
}

fn_deps_email() {
	# Adds postfix to required dependencies if email alert is enabled.
	if [ "${emailalert}" == "on" ]; then
		if [ -f /usr/bin/mailx ]; then
			if [ -d /etc/exim4 ]; then
				array_deps_required+=(exim4)
			elif [ -d /etc/sendmail ]; then
				array_deps_required+=(sendmail)
			elif [ "$(command -v apt 2> /dev/null)" ] && [ -d /etc/nullmailer ]; then
				# 'mailutils' provides the 'mail' binary, 'nullmailer' is the MTA
				array_deps_required+=(mailutils nullmailer)
			elif [ "$(command -v yum 2> /dev/null)" ] || [ "$(command -v dnf 2> /dev/null)" ]; then
				array_deps_required+=(s-nail postfix)
			elif [ "$(command -v apt 2> /dev/null)" ]; then
				array_deps_required+=(mailutils postfix)
			fi
		else
			if [ "$(command -v yum 2> /dev/null)" ] || [ "$(command -v dnf 2> /dev/null)" ]; then
				array_deps_required+=(s-nail postfix)
			elif [ "$(command -v apt 2> /dev/null)" ]; then
				array_deps_required+=(mailutils postfix)
			fi
		fi
	fi
}

fn_install_missing_deps() {
	# If any dependencies are not installed.
	if [ "${#array_deps_missing[*]}" != "0" ]; then
		if [ "${commandname}" == "INSTALL" ]; then
			fn_print_warning_nl "Missing dependencies: ${red}${array_deps_missing[*]}${default}"
			fn_script_log_warn "Missing dependencies: ${array_deps_missing[*]}"
		else
			fn_print_dots "Missing dependencies"
			fn_print_warn "Missing dependencies: ${red}${array_deps_missing[*]}${default}"
			fn_script_log_warn "Missing dependencies: ${array_deps_missing[*]}"
		fi

		# Attempt automatic dependency installation.
		# Check for passwordless sudo first: sudo-rs (default sudo from Ubuntu 25.10) always asks
		# for a password for sudo -v, even when the user has NOPASSWD.
		if sudo -n true > /dev/null 2>&1; then
			autodepinstall="0"
		elif [ "${autoinstall}" == "1" ]; then
			autodepinstall="1"
			nosudomessage="sudo cannot run without a password during auto-install."
		else
			sudo -v > /dev/null 2>&1
			autodepinstall="$?"
			nosudomessage="$(whoami) does not have sudo access."
		fi

		if [ "${monoinstalled}" == "false" ]; then
			fn_install_mono_repo
		fi

		if [ "${dotnetinstalled}" == "false" ]; then
			fn_install_dotnet_repo
		fi

		if [ "${commandname}" == "INSTALL" ]; then
			if [ "${autodepinstall}" == "0" ]; then
				fn_print_information_nl "$(whoami) has sudo access."
				fn_script_log_info "$(whoami) has sudo access."
			else
				fn_print_warning_nl "${nosudomessage} Manually install dependencies or run ./${selfname} install as root."
				fn_script_log_warn "${nosudomessage} Manually install dependencies or run ./${selfname} install as root."
			fi
		fi

		# Add sudo dpkg --add-architecture i386 if using i386 packages.
		if [ "$(command -v apt 2> /dev/null)" ]; then
			if printf '%s\n' "${array_deps_required[@]}" | grep -q -P 'i386'; then
				i386installcommand="sudo dpkg --add-architecture i386; "
			fi
		fi

		# If automatic dependency install is available
		if [ "${autodepinstall}" == "0" ]; then
			fn_print_information_nl "Automatically installing missing dependencies."
			fn_script_log_info "Automatically installing missing dependencies."
			if [ -z "${plainoutput}" ]; then
				echo -en ".\r"
				fn_sleep_time_1
				echo -en "..\r"
				fn_sleep_time_1
				echo -en "...\r"
				fn_sleep_time_1
				echo -en "   \r"
			fi
			if [ "$(command -v apt 2> /dev/null)" ]; then
				cmd="echo steamcmd steam/question select \"I AGREE\" | sudo debconf-set-selections; echo steamcmd steam/license note '' | sudo debconf-set-selections; ${i386installcommand}sudo apt-get update; sudo apt-get -y install ${array_deps_missing[*]}"
				eval "${cmd}"
			elif [ "$(command -v dnf 2> /dev/null)" ]; then
				cmd="sudo dnf -y install ${array_deps_missing[*]}"
				eval "${cmd}"
			elif [ "$(command -v yum 2> /dev/null)" ]; then
				cmd="sudo yum -y install ${array_deps_missing[*]}"
				eval "${cmd}"
			fi
			autodepinstall="$?"

			# If auto install passes, remove steamcmd install failure and set exit code to 0.
			if [ "${autodepinstall}" == "0" ]; then
				unset steamcmdfail
				exitcode=0
			fi
		fi

		# If automatic dependency install is unavailable.
		if [ "${autodepinstall}" != "0" ]; then
			if [ "$(command -v apt 2> /dev/null)" ]; then
				echo -e " Run: '${green}${i386installcommand}sudo apt update; sudo apt install ${array_deps_missing[*]}${default}' as root to install missing dependencies."
			elif [ "$(command -v dnf 2> /dev/null)" ]; then
				echo -e " Run: '${green}sudo dnf install ${array_deps_missing[*]}${default}' as root to install missing dependencies."
			elif [ "$(command -v yum 2> /dev/null)" ]; then
				echo -e " Run: '${green}sudo yum install ${array_deps_missing[*]}${default}' as root to install missing dependencies."
			fi
		fi

		if [ "${steamcmdfail}" ]; then
			if [ "${commandname}" == "INSTALL" ]; then
				fn_print_failure_nl "Missing dependencies required to run SteamCMD."
				fn_script_log_fail "Missing dependencies required to run SteamCMD."
				core_exit.sh
			else
				fn_print_error_nl "Missing dependencies required to run SteamCMD."
				fn_script_log_error "Missing dependencies required to run SteamCMD."
			fi
		fi

	else
		if [ "${commandname}" == "INSTALL" ]; then
			fn_print_skip2_nl "Required dependencies already installed."
			fn_script_log_info "Required dependencies already installed."
		fi
	fi
}

fn_check_loop() {
	# Loop though required dependencies checking if they are installed.
	for deptocheck in "${array_deps_required[@]}"; do
		fn_deps_detector
	done

	# user will be informed of any missing dependencies.
	if [ "${depcheckonly}" != "1" ]; then
		fn_install_missing_deps
	fi
}

# Checks if dependency is installed or not.
fn_deps_version_ge() {
	[ "$(printf '%s\n' "$1" "$2" | sort -V | head -1)" == "$2" ]
}

fn_deps_detector() {
	## Check.
	# SteamCMD: Will be removed from required array if no appid is present or non-free repo is not available.
	# This will cause SteamCMD to be installed using tar.
	if [ "${deptocheck}" == "libsdl2-2.0-0:i386" ] && [ -z "${appid}" ]; then
		array_deps_required=("${array_deps_required[@]/libsdl2-2.0-0:i386/}")
		steamcmdstatus=1
		return
	elif [ "${deptocheck}" == "steamcmd" ] && [ -z "${appid}" ]; then
		array_deps_required=("${array_deps_required[@]/steamcmd/}")
		steamcmdstatus=1
		return
	# Checks classic and deb822 sources for an uncommented non-free component (non-free-firmware does not count).
	elif [ "${deptocheck}" == "steamcmd" ] && [ "${distroid}" == "debian" ] && ! grep -qE '^[[:space:]]*[^#[:space:]].*[[:space:]]non-free([[:space:]]|$)' /etc/apt/sources.list /etc/apt/sources.list.d/*.list /etc/apt/sources.list.d/*.sources 2> /dev/null; then
		array_deps_required=("${array_deps_required[@]/steamcmd/}")
		steamcmdstatus=1
		return
	# Java: Added for users using Oracle JRE to bypass check.
	elif [[ ${deptocheck} == "openjdk"* ]] || [[ ${deptocheck} == "java"* ]]; then
		# Is java already installed?
		if [ -n "${javaversion}" ]; then
			javamajorversion="$(echo "${javaversion}" | grep -Eo 'version "[0-9]+' | grep -Eo '[0-9]+' | head -1)"
			javarequiredmajor="$(echo "${deptocheck}" | grep -Eo '[0-9]+' | head -1)"
			if [ "${shortname}" == "mc" ] || [ "${shortname}" == "pmc" ]; then
				if [ "${mcversion}" == "latest" ]; then
					javarequiredmajor="25"
				elif [[ "${mcversion}" =~ ^[0-9]+\.[0-9]+([.][0-9]+)?$ ]]; then
					if fn_deps_version_ge "${mcversion}" "26.1"; then
						javarequiredmajor="25"
					elif [ "${shortname}" == "mc" ] && fn_deps_version_ge "${mcversion}" "1.20.5"; then
						javarequiredmajor="21"
					elif [ "${shortname}" == "pmc" ] && fn_deps_version_ge "${mcversion}" "1.20" && fn_deps_version_ge "1.21.11" "${mcversion}"; then
						javarequiredmajor="21"
					elif [ "${shortname}" == "pmc" ] && fn_deps_version_ge "${mcversion}" "1.17" && fn_deps_version_ge "1.19" "${mcversion}"; then
						javarequiredmajor="17"
					elif [ "${shortname}" == "pmc" ] && [ "${mcversion}" == "1.16.5" ]; then
						javarequiredmajor="16"
					elif [ "${shortname}" == "pmc" ] && fn_deps_version_ge "${mcversion}" "1.12" && ! fn_deps_version_ge "${mcversion}" "1.16.5"; then
						javarequiredmajor="11"
					elif [ "${shortname}" == "pmc" ] && ! fn_deps_version_ge "${mcversion}" "1.16.5"; then
						javarequiredmajor="8"
					fi
				fi
			fi
			if [ "${shortname}" == "hyt" ] && { [ -z "${javamajorversion}" ] || [ "${javamajorversion}" -lt "25" ]; }; then
				# Java 25 installed but not the active java: installing it again would not change that.
				if compgen -G "/usr/lib/jvm/*25*/bin/java" > /dev/null; then
					depstatus=0
					deptocheck="${javaversion}"
					fn_print_warn_nl "Java 25 is installed but the active java is version ${javamajorversion:-unknown}. Select Java 25 with: sudo update-alternatives --config java"
					fn_script_log_warn "Java 25 is installed but the active java is version ${javamajorversion:-unknown}"
				else
					depstatus=1
				fi
			elif [ -n "${javamajorversion}" ] && [ "${javamajorversion}" -lt "${javarequiredmajor}" ]; then
				if [ "${depcheckonly}" == "1" ]; then
					depstatus=1
				elif [ "${javarequiredmajor}" -gt "$(echo "${deptocheck}" | grep -Eo '[0-9]+' | head -1)" ]; then
					fn_print_failure_nl "${gamename} ${mcversion} requires Java ${javarequiredmajor}; ${distroname} does not provide that version as a package."
					echo -e "Install Java ${javarequiredmajor} manually or upgrade to Debian 13 or Ubuntu 24.04+."
					fn_script_log_fail "${gamename} ${mcversion} requires Java ${javarequiredmajor}; ${distroname} does not provide it as a package."
					core_exit.sh
				else
					fn_print_failure_nl "${gamename} ${mcversion} requires Java ${javarequiredmajor}; active Java is ${javamajorversion}."
					echo -e "Select a compatible Java runtime with: sudo update-alternatives --config java"
					fn_script_log_fail "${gamename} ${mcversion} requires Java ${javarequiredmajor}; active Java is ${javamajorversion}."
					core_exit.sh
				fi
			else
				# Added for users using Oracle JRE to bypass check.
				depstatus=0
				deptocheck="${javaversion}"
			fi
		else
			javarequiredmajor="$(echo "${deptocheck}" | grep -Eo '[0-9]+' | head -1)"
			if [ "${shortname}" == "mc" ] || [ "${shortname}" == "pmc" ]; then
				if [ "${mcversion}" == "latest" ] || fn_deps_version_ge "${mcversion}" "26.1"; then
					javarequiredmajor="25"
				elif { [ "${shortname}" == "mc" ] && fn_deps_version_ge "${mcversion}" "1.20.5"; } || { [ "${shortname}" == "pmc" ] && fn_deps_version_ge "${mcversion}" "1.20" && fn_deps_version_ge "1.21.11" "${mcversion}"; }; then
					javarequiredmajor="21"
				fi
			fi
			if [ "${javarequiredmajor}" -gt "$(echo "${deptocheck}" | grep -Eo '[0-9]+' | head -1)" ] && [ "${depcheckonly}" != "1" ]; then
				fn_print_failure_nl "${gamename} ${mcversion} requires Java ${javarequiredmajor}; ${distroname} does not provide that version as a package."
				echo -e "Install Java ${javarequiredmajor} manually or upgrade to Debian 13 or Ubuntu 24.04+."
				fn_script_log_fail "${gamename} ${mcversion} requires Java ${javarequiredmajor}; ${distroname} does not provide it as a package."
				core_exit.sh
			else
				depstatus=1
			fi
		fi
	# Mono: A Mono repo needs to be installed.
	elif [ "${deptocheck}" == "mono-complete" ]; then
		if [ -n "${monoversion}" ] && [ "${monoversion}" -ge "5" ]; then
			# Mono >= 5.0.0 already installed.
			depstatus=0
			monoinstalled=true
		else
			# Mono not installed or installed Mono < 5.0.0.
			depstatus=1
			monoinstalled=false
		fi
	# .NET runtime: check installed runtime version for any dotnet-runtime-X.Y package.
	elif [[ "${deptocheck}" =~ ^dotnet-runtime-([0-9]+\.[0-9]+)$ ]]; then
		dotnetrequired="${BASH_REMATCH[1]}"
		if [ "$(command -v dotnet 2> /dev/null)" ] && dotnet --list-runtimes | grep -q "Microsoft.NETCore.App ${dotnetrequired}"; then
			depstatus=0
			dotnetinstalled=true
		else
			depstatus=1
			dotnetinstalled=false
		fi
	elif [ "$(command -v apt 2> /dev/null)" ]; then
		dpkg-query -W -f='${Status}' "${deptocheck}" 2> /dev/null | grep -q -P '^install ok installed'
		depstatus=$?
	elif [ "$(command -v dnf 2> /dev/null)" ]; then
		dnf list installed "${deptocheck}" > /dev/null 2>&1
		depstatus=$?
	elif [ "$(command -v rpm 2> /dev/null)" ]; then
		rpm -q "${deptocheck}" > /dev/null 2>&1
		depstatus=$?
	fi

	# Outcome of Check.
	if [ "${steamcmdstatus}" == "1" ]; then
		# If SteamCMD is not available in repo dont check for it.
		unset steamcmdstatus
	elif [ "${depstatus}" == "0" ]; then
		# If dependency is found.
		missingdep=0
		if [ "${commandname}" == "INSTALL" ]; then
			echo -e "${green}${deptocheck}${default}"
			fn_sleep_time
		fi
	elif [ "${depstatus}" != "0" ]; then
		# If dependency is not found.
		missingdep=1
		if [ "${commandname}" == "INSTALL" ]; then
			echo -e "${red}${deptocheck}${default}"
			fn_sleep_time
		fi
		# If SteamCMD requirements are not met install will fail.
		if [ -n "${appid}" ]; then
			for steamcmddeptocheck in "${array_deps_required_steamcmd[@]}"; do
				if [ "${deptocheck}" != "steamcmd" ] && [ "${deptocheck}" == "${steamcmddeptocheck}" ]; then
					steamcmdfail=1
				fi
			done
		fi
	fi
	unset depstatus

	# Missing dependencies are added to array_deps_missing.
	if [ "${missingdep}" == "1" ]; then
		array_deps_missing+=("${deptocheck}")
	fi
}

if [ "${commandname}" == "DETAILS" ] || [ "${commandname}" == "POST-DETAILS" ]; then
	depcheckonly="1"
fi

if [ "${commandname}" == "INSTALL" ]; then
	if [ "$(whoami)" == "root" ]; then
		echo -e ""
		echo -e "${bold}${lightyellow}Checking ${gamename} Dependencies as root${default}"
		fn_messages_separator
		fn_print_information_nl "Checking any missing dependencies for ${gamename} server only."
		fn_print_information_nl "This will NOT install a ${gamename} server."
	else
		echo -e ""
		echo -e "${bold}${lightyellow}Checking ${gamename} Dependencies${default}"
		fn_messages_separator
	fi
fi

info_distro.sh

if [ "${depcheckonly}" != "1" ]; then
	# Will warn user if their distro is no longer supported by the vendor.
	if [ -n "${distrosupport}" ]; then
		if [ "${distrosupport}" == "unsupported" ]; then
			fn_print_warning_nl "${distroname} is no longer supported by the vendor or LinuxGSM. Upgrading is recommended."
			fn_script_log_warn "${distroname} is no longer supported by the vendor or LinuxGSM. Upgrading is recommended."
		fi
	fi

	# These titles are only supported up to Ubuntu 20.04 and Debian 11.
	if { [ "${distroid}" == "ubuntu" ] && dpkg --compare-versions "${distroversion}" "gt" "20.04"; } || { [ "${distroid}" == "debian" ] && dpkg --compare-versions "${distroversion}" "gt" "11"; }; then
		if [ "${shortname}" == "onset" ] || [ "${shortname}" == "btl" ]; then
			fn_print_failure_nl "${gamename} is not supported on ${distroname} (requires Ubuntu <= 20.04 or Debian <= 11)."
			fn_script_log_fail "${gamename} is not supported on ${distroname}."
			core_exit.sh
		fi
	fi

	# Vintage Story tracks newer .NET runtimes; older distro releases may not ship required packages.
	if [ "${shortname}" == "vints" ]; then
		if { [ "${distroid}" == "ubuntu" ] && dpkg --compare-versions "${distroversion}" "lt" "24.04"; } || { [ "${distroid}" == "debian" ] && dpkg --compare-versions "${distroversion}" "lt" "12"; } || [ "${distroid}" == "centos" ] || [ "${distroid}" == "rhel" ] || [ "${distroid}" == "rocky" ] || [ "${distroid}" == "almalinux" ]; then
			fn_print_warning_nl "${gamename} may require newer .NET runtimes than ${distroname} provides."
			echo -e "If startup fails due to missing .NET runtime, upgrading to Ubuntu 24.04+ or Debian 12+ is recommended."
			fn_script_log_warn "${gamename} may require newer .NET runtimes than ${distroname} provides."
		fi
	fi

	# Hytale needs Java 25, which Ubuntu before 22.04, Debian before 13 and RHEL before 9 do not package.
	if [ "${shortname}" == "hyt" ]; then
		if { [ "${distroid}" == "ubuntu" ] && [ "${distroversion}" != "22.04" ] && dpkg --compare-versions "${distroversion}" "lt" "24.04"; } || { [ "${distroid}" == "debian" ] && dpkg --compare-versions "${distroversion}" "lt" "13"; } || { [ -n "${distroversionrh}" ] && [ "${distroversionrh}" -lt "9" ]; }; then
			if ! echo "${javaversion}" | grep -Eq 'version "(2[5-9]|[3-9][0-9])'; then
				fn_print_warning_nl "${gamename} requires Java 25, which ${distroname} does not provide."
				echo -e "Install Java 25 manually or upgrade to Ubuntu 22.04+, Debian 13+ or a RHEL 9 based distro."
				fn_script_log_warn "${gamename} requires Java 25, which ${distroname} does not provide."
			fi
		fi
	fi
fi

if [ ! -f "${tmpdir}/dependency-no-check.tmp" ] && [ ! -f "${datadir}/${distroid}-${distroversioncsv}.csv" ]; then
	# Check that the distro dependency csv file exists.
	fn_check_file_github "lgsm/data" "${distroid}-${distroversioncsv}.csv"
	if [ -n "${checkflag}" ] && [ "${checkflag}" == "0" ]; then
		fn_fetch_file_github "lgsm/data" "${distroid}-${distroversioncsv}.csv" "${datadir}" "chmodx" "norun" "noforce" "nohash"
	fi
fi

# If the file successfully downloaded run the dependency check.
if [ -f "${datadir}/${distroid}-${distroversioncsv}.csv" ]; then
	depall=$(awk -F, '$1=="all" {$1=""; print $0}' "${datadir}/${distroid}-${distroversioncsv}.csv")
	depsteamcmd=$(awk -F, '$1=="steamcmd" {$1=""; print $0}' "${datadir}/${distroid}-${distroversioncsv}.csv")
	depshortname=$(awk -v shortname="${shortname}" -F, '$1==shortname {$1=""; print $0}' "${datadir}/${distroid}-${distroversioncsv}.csv")

	# Generate array of missing deps.
	array_deps_missing=()

	array_deps_required=("${depall} ${depsteamcmd} ${depshortname}")
	array_deps_required_steamcmd=("${depsteamcmd}")
	fn_deps_email
	if [ "${logtimestamp}" == "on" ]; then
		array_deps_required+=(gawk)
	fi
	# Unique sort dependency array.
	IFS=" " read -r -a array_deps_required <<< "$(echo "${array_deps_required[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' ')"

	fn_check_loop
elif [ "${depcheckonly}" == "1" ]; then
	# shellcheck disable=SC2034 # Used by info_messages.sh.
	depcheckunavailable="1"
# Warn the user that dependency checking is unavailable for their distro.
elif [ "${commandname}" == "INSTALL" ] || [ -n "${checkflag}" ] && [ "${checkflag}" != "0" ]; then
	fn_print_warning_nl "LinuxGSM dependency checking currently unavailable for ${distroname}."
	# Prevent future dependency checking if unavailable for the distro.
	echo "${version}" > "${tmpdir}/dependency-no-check.tmp"
elif [ -f "${tmpdir}/dependency-no-check.tmp" ]; then
	# Allow LinuxGSM to try a dependency check if LinuxGSM has been recently updated.
	nocheckversion=$(cat "${tmpdir}/dependency-no-check.tmp")
	if [ "${version}" != "${nocheckversion}" ]; then
		rm -f "${tmpdir:?}/dependency-no-check.tmp"
	fi
fi