152 lines
5.0 KiB
Python
152 lines
5.0 KiB
Python
import logging
|
|
import shlex
|
|
|
|
from core_lib.game.library import get_natives_platform_info
|
|
|
|
logger = logging.getLogger("Launcher.CoreLib")
|
|
|
|
def is_argument_allowed(argument: dict | str, allow_features: dict=dict) -> bool:
|
|
"""
|
|
Check if argument is allowed or not.
|
|
:param argument:
|
|
:param allow_features: Should be like {key: value}
|
|
:return:
|
|
allowed: bool
|
|
"""
|
|
if isinstance(argument, str):
|
|
return True
|
|
|
|
rules = argument.get('rules', {})
|
|
|
|
_, platform_rule_name, _ = get_natives_platform_info()
|
|
|
|
allowed = False
|
|
|
|
if not rules:
|
|
return True
|
|
|
|
for rule in rules:
|
|
rule_action = rule.get("action", None)
|
|
os_section = rule.get("os", {})
|
|
rule_os = os_section.get("name", None)
|
|
features_rule = rule.get("features", None)
|
|
|
|
if rule_os is not None and platform_rule_name != rule_os:
|
|
continue
|
|
|
|
matched = True
|
|
|
|
# Check feature dict
|
|
if features_rule:
|
|
for key, expected in features_rule.items():
|
|
if allow_features.get(key, False) != expected:
|
|
matched = False
|
|
break
|
|
|
|
if not matched:
|
|
continue
|
|
|
|
|
|
if rule_action == "allow":
|
|
allowed = True
|
|
elif rule_action == "disallow":
|
|
allowed = False
|
|
else:
|
|
logger.warning(f"Unknown action {rule_action}\n")
|
|
|
|
return allowed
|
|
|
|
def replace_placeholders(argument, placeholders: dict) -> str:
|
|
if argument:
|
|
for key, value in placeholders.items():
|
|
argument = argument.replace("${" + key + "}", "" if value is None else str(value))
|
|
|
|
return argument
|
|
|
|
class ArgumentMappings:
|
|
def __init__(self, player_name="Player", version_name="unknown",
|
|
game_directory=None, assets_root=None, assets_index_name=None,
|
|
auth_uuid="00000001-0002-0003-0004-000000000005",
|
|
auth_access_token="", clientid=None, auth_xuid=None,
|
|
user_type=None, version_type=None, natives_directory=None,
|
|
launcher_name=None, launcher_version=None,
|
|
classpath=None, classpath_separator=None, library_directory=None):
|
|
self.player_name = player_name
|
|
self.version_name = version_name
|
|
self.game_directory = game_directory
|
|
self.assets_root = assets_root
|
|
self.assets_index_name = assets_index_name
|
|
self.auth_uuid = auth_uuid
|
|
self.auth_access_token = auth_access_token
|
|
self.clientid = clientid
|
|
self.auth_xuid = auth_xuid
|
|
self.user_type = user_type
|
|
self.version_type = version_type
|
|
self.natives_directory = natives_directory
|
|
self.launcher_name = launcher_name
|
|
self.launcher_version = launcher_version
|
|
self.classpath = classpath
|
|
self.classpath_separator = classpath_separator
|
|
self.library_directory = library_directory
|
|
|
|
def generate_placeholders(self):
|
|
return {
|
|
"player_name": self.player_name,
|
|
"version_name": self.version_name,
|
|
"game_directory": self.game_directory,
|
|
"assets_root": self.assets_root,
|
|
"assets_index_name": self.assets_index_name,
|
|
"auth_uuid": self.auth_uuid,
|
|
"auth_access_token": self.auth_access_token,
|
|
"auth_player_name": self.player_name,
|
|
"clientid": self.clientid,
|
|
"auth_xuid": self.auth_xuid,
|
|
"user_type": self.user_type,
|
|
"version_type": self.version_type,
|
|
"natives_directory": self.natives_directory,
|
|
"launcher_name": self.launcher_name,
|
|
"launcher_version": self.launcher_version,
|
|
"classpath": self.classpath,
|
|
"classpath_separator": self.classpath_separator,
|
|
"library_directory": self.library_directory
|
|
}
|
|
|
|
def convert_argument_to_multiple_string(argument: str | dict) -> list[str]:
|
|
if isinstance(argument, str):
|
|
return [argument]
|
|
|
|
if isinstance(argument, dict):
|
|
value = argument.get("value", None)
|
|
|
|
if isinstance(value, list):
|
|
return [str(item) for item in value] # ensure all item are string
|
|
elif isinstance(value, str):
|
|
return [value]
|
|
|
|
raise TypeError("Argument must be of type str or dict")
|
|
|
|
def parse_and_generate_arguments(arguments: list | str, mappings: ArgumentMappings, features: dict=dict) -> list[str]:
|
|
parsed_arguments = []
|
|
|
|
if isinstance(arguments, str):
|
|
# Convert legacy argument into a list type
|
|
arguments = shlex.split(arguments)
|
|
|
|
placeholders = mappings.generate_placeholders()
|
|
|
|
for argument in arguments:
|
|
# Check rules
|
|
if not is_argument_allowed(argument, allow_features=features):
|
|
continue
|
|
|
|
# Each argument (section) may contain multiple items, convert it to list before replace placeholder
|
|
converted = convert_argument_to_multiple_string(argument)
|
|
|
|
for item in converted:
|
|
parsed = replace_placeholders(item, placeholders)
|
|
parsed_arguments.append(parsed)
|
|
|
|
return parsed_arguments
|
|
|
|
|