现在再来分析一下我们的启动器需要哪些功能吧。

功能列表

这是HMCL的启动器首页：image.png
这款启动器的主页上布置了账户登录、游戏列表、下载游戏、多人联机、设置、启动游戏，其实这也是大多数启动器的主页布局。我们已经在前文梳理过使用代码生成启动脚本的步骤了，现在就来重新回顾一下从JSON中提取并拼接脚本的步骤吧。

  1. class func:
  2.     # 线程配置
  3.     threading_manager = threading.Semaphore(value=config.max_threading_count)
  5.     def get_java_info(self: int):
  6.         java_list = local_files.java_versions_list(0)
  7.         return java_list
  9.     def get_version_info(self: int, game_version: str):
  10.         """
  11.         返回详细版本信息的函数。
  12.         :param game_version: 目标版本的自定义名称
  13.         :return: 如果版本存在，返回的元组中依次包括[0]游戏版本号、[1].minecraft文件夹路径、[2]该版本JSON文件路径、[3]版本natives库文件夹应在的路径、[4]版本libraries文件夹路径、[5]minecraft本体客户端路径，[6][7]以及两项启动参数；如果版本不存在，返回None
  14.         """
  15.         game_versions_list = local_files.game_versions_list(0)
  16.         # 这里通过先在本地文件中缓存能启动的版本列表，然后查询列表以获取启动需要的版本信息。
  17.         for i in game_versions_list:
  18.             if str(game_version) == i['name']:
  19.                 game_version_num: str = str(i['version'])
  20.                 version_file_path = config.self_path + r"\.minecraft"
  21.                 version_json_path = version_file_path + r"\versions" + "\\" + game_version + "\\" + game_version + ".json"
  22.                 libraries_path_1 = version_file_path + r"\versions" + "\\" + game_version + "\\" + game_version + "-natives"
  23.                 libraries_path_2 = version_file_path + r"\libraries" + "\\"
  24.                 minecraft_jar_path = version_file_path + r"\versions" + "\\" + game_version + "\\" + game_version + ".jar"
  25.                 Djava_library_path = r"-Djava.library.path=" + libraries_path_1
  26.                 Dminecraft_client_jar = r"-Dminecraft.client.jar=" + minecraft_jar_path
  27.                 assetsindex_path_part = version_file_path + "\\assets\\indexes"
  28.                 return (game_version_num, version_file_path, version_json_path,
  29.                         libraries_path_1, libraries_path_2, minecraft_jar_path,
  30.                         Djava_library_path, Dminecraft_client_jar, assetsindex_path_part)
  31.                 return None
  33.     # 这里是在解压natives库文件，目前还未先检测是否存在再解压的策略。
  34.     def zip_natives(self: int, natives_file: dict, libraries_path: str, natives_path: str):
  35.         file_temp_1 = natives_file['classifiers']
  36.         if "natives-windows-64" in file_temp_1:
  37.             file_temp_2: dict = dict(file_temp_1['natives-windows-64'])
  38.         elif "natives-windows" in file_temp_1:
  39.             file_temp_2: dict = dict(file_temp_1['natives-windows'])
  40.         else:
  41.             return None
  42.         file_temp_3: str = str(file_temp_2['path'])
  43.         file_temp_4 = list(file_temp_3.split("/"))
  44.         dividing_str_1 = "\\"
  45.         file_temp_5 = dividing_str_1.join(file_temp_4)
  46.         real_path = libraries_path + file_temp_5
  47.         with zipfile.ZipFile(file=real_path) as natives_temp:
  48.             natives_temp.extractall(path=natives_path)
  49.             return None
  52. class using:
  53.     def java_setting(self: int, java_setting_info: list):
  54.         """
  56.         :param java_setting_info: 该版本的相关信息组成的列表，需要：[0]最大内存，[1]最小内存，[2]Djava参数（natives），[3]Dminecraft参数
  57.         :return: 包含该.jar文件和其他有关参数的，可直接拼接成脚本使用的代码片段
  58.         """
  59.         info_max_memory = java_setting_info[0]
  60.         info_min_memory = java_setting_info[1]
  61.         Djava_library_path = java_setting_info[2]
  62.         Dminecraft_jar_path = java_setting_info[3]
  63.         output_java_setting = info_max_memory + " " + info_min_memory + " " \
  64.         + Djava_library_path + " " \
  65.         + Dminecraft_jar_path
  66.         return output_java_setting
  68.     def get_libraries_json(self: int, game_version_info: list):
  69.         """
  70.         返回拼接成的“-cp”+普通库1+普通库2+……
  71.         :param game_version_info: 该版本的相关信息组成的列表，需要：[0]版本名称，[1]版本JSON路径，[2]版本libraries路径，[3]版本游戏本体路径，[4]版本natives文件路径
  72.         :return 从该JSON文件中提取出的，可直接拼接成脚本使用的代码片段
  73.         """
  74.         output_path = []
  75.         game_version_name = game_version_info[0]
  76.         game_version_json_path = game_version_info[1]
  77.         libraries_path = game_version_info[2]
  78.         minecraft_jar_path = game_version_info[3]
  79.         natives_path = game_version_info[4]
  80.         with open(file=game_version_json_path) as json_file:
  81.             json_data = json.load(json_file)
  82.             info_back_type_list = json_data['libraries']
  83.             for i in info_back_type_list:
  84.                 if "rules" in i:
  85.                     data_temp_1 = list(i['rules'])
  86.                     if len(data_temp_1) == 1:
  87.                         allowing_list = list(dict(dict(data_temp_1[0])["os"])['name'])
  88.                         if not "windows" in allowing_list:
  89.                             continue
  90.                     if len(data_temp_1) == 2:
  91.                         disallowing_list = list(dict(dict(data_temp_1[1])['os'])['name'])
  92.                         if "windows" in disallowing_list:
  93.                             continue
  95.                 data_temp_2 = dict(i['downloads'])
  96.                 if "classifiers" in data_temp_2:
  97.                     func.zip_natives(0, data_temp_2, libraries_path, natives_path)
  98.                     continue
  99.                 elif not 'artifact' in data_temp_2:
  100.                     continue
  101.                 else:
  102.                     data_temp_2_ = dict(data_temp_2['artifact'])
  103.                 data_temp_3 = str(data_temp_2_['path'])
  104.                 data_temp_4 = list(data_temp_3.split("/"))
  105.                 dividing_str_1 = "\\"
  106.                 data_temp_5 = dividing_str_1.join(data_temp_4)
  107.                 real_path = libraries_path + data_temp_5
  108.                 if not real_path in output_path:
  109.                     output_path.append(real_path)
  110.             output_path.append(minecraft_jar_path)
  111.             dividing_str_2 = ";"
  112.             output_path_str = dividing_str_2.join(output_path)
  113.             return output_path_str
  115.     def get_player_info(self: int, get_player_info: list):
  116.         """
  117.         此函数可以生成启动脚本中的Minecraft参数。
  118.         :param get_player_info: 需要输入一个列表，内容分别为：[0]版本JSON文件路径，[1]玩家名，[2]玩家UUID，[3].minecraft文件夹路径，[4]assets文件夹路径
  119.         :return: 从该JSON文件中提取出的，以及输入的信息组成的，可直接拼接成脚本使用的代码片段
  120.         """
  121.         info_version_json_path = get_player_info[0]
  122.         info_player_name = get_player_info[1]
  123.         info_player_uuid = get_player_info[2]
  124.         info_minecraft_jar_path = get_player_info[3]
  125.         info_assets_path = get_player_info[4]
  127.         with open(file=info_version_json_path) as json_file:
  128.             json_data = json.load(json_file)
  129.             main_class = json_data['mainClass']
  130.             if "minecraftArguments" in json_data:
  131.                 minecraft_arguments_ = str(json_data['minecraftArguments'])
  132.                 assets_index_name = str(dict(json_data['assetIndex'])['id'])
  133.                 version_type = str(json_data['type'])
  134.                 minecraft_arguments = minecraft_arguments_.replace("${auth_player_name}", info_player_name) \
  135.                     .replace("${version_name}", "FanCraftLauncher") \
  136.                     .replace("${game_directory}", info_minecraft_jar_path) \
  137.                     .replace("${assets_root}", info_assets_path) \
  138.                     .replace("${assets_index_name}", assets_index_name) \
  139.                     .replace("${auth_uuid}", info_player_uuid) \
  140.                     .replace("${auth_access_token}", info_player_uuid) \
  141.                     .replace("${user_properties}", "{}") \
  142.                     .replace("${auth_xuid}", "{}") \
  143.                     .replace("${clientid}", "{}") \
  144.                     .replace("${user_type}", "legacy") \
  145.                     .replace("${version_type}", version_type)
  147.             # 1.13以后，JSON中的minecraftArguments键更名为arguments，并且键的结构发生了改变，
  148.             # 下面是对这种新结构的解析（并不全面，仅供参考）
  150.             elif "arguments" in json_data:
  151.                 temp_list = []
  152.                 minecraft_arguments__ = list(json_data["arguments"]["game"])
  153.                 assets_index_name = str(dict(json_data['assetIndex'])['id'])
  154.                 version_type = str(json_data['type'])
  155.                 for i in minecraft_arguments__:
  156.                     if type(i) == str:
  157.                         temp_list.append(i)
  158.                 minecraft_arguments_ = " ".join(temp_list)
  159.                 minecraft_arguments = minecraft_arguments_.replace("${auth_player_name}", info_player_name) \
  160.                     .replace("${version_name}", "FanCraftLauncher") \
  161.                     .replace("${game_directory}", info_minecraft_jar_path) \
  162.                     .replace("${assets_root}", info_assets_path) \
  163.                     .replace("${assets_index_name}", assets_index_name) \
  164.                     .replace("${auth_uuid}", info_player_uuid) \
  165.                     .replace("${auth_access_token}", info_player_uuid) \
  166.                     .replace("${user_properties}", "{}") \
  167.                     .replace("${auth_xuid}", "{}") \
  168.                     .replace("${clientid}", "{}") \
  169.                     .replace("${user_type}", "legacy") \
  170.                     .replace("${version_type}", version_type)
  171.             output_player_info = main_class + " " + minecraft_arguments
  172.         return output_player_info

然后只需要通过另外一个函数，先后调用这些函数来获取脚本的不同片段，再首尾拼接起来即可。

  1. def launcher_playing_vanilla(config_: list):
  2.     """
  3.     此函数用于创建子线程启动Minecraft。
  4.     :param config_: 以元组形式，先后输入：[0]Java版本，[1]游戏版本，[2]最大内存，[3]最小内存，[4]玩家名，[5]玩家uuid。
  5.     :return: 此函数无论是否顺利执行都不返回值。
  6.     """
  7.     launch_java_path = ""
  8.     info_java_version = config_[0]
  9.     info_game_version = config_[1]
  10.     info_max_memory = config_[2]
  11.     info_min_memory = config_[3]
  12.     info_player_name = config_[4]
  13.     info_player_uuid = config_[5]
  15.     java_list = func.get_java_info(0)
  16.     for i in java_list:
  17.         if info_java_version == i['version']:
  18.             launch_java_path = i['path']
  19.     if not launch_java_path:
  20.         logger.Logger.warning("指定Java版本不存在。")
  21.         # Logger是我在别处定义的日志记录器，会将日志同时输出在控制台上和log文件里。
  22.         return None
  23.     back_info = func.get_version_info(0, info_game_version)
  24.     # 首先获取该版本的信息，如果版本不存在就报错。
  25.     if not back_info:
  26.         logger.Logger.warning("指定Minecraft版本不存在。")
  27.         return None
  29.     info_version_name = back_info[0]
  30.     info__minecraft_path = back_info[1]
  31.     info_assets_path = info__minecraft_path + r"\assets"
  32.     info_version_json_path = back_info[2]
  33.     info_natives_path = back_info[3]
  34.     info_libraries_path = back_info[4]
  35.     info_minecraft_jar_path = back_info[5]
  36.     info_Djava_libraries = back_info[6]
  37.     info_Dminecraft_path = back_info[7]
  38.     # 获取版本有关的各种信息。
  40.     get_libraries_json_package = [info_version_name, info_version_json_path, info_libraries_path, info_minecraft_jar_path, info_natives_path]
  41.     java_setting_package = [info_max_memory, info_min_memory, info_Djava_libraries, info_Dminecraft_path]
  42.     get_player_info_package = [info_version_json_path, info_player_name, info_player_uuid, info__minecraft_path, info_assets_path]
  43.     # 将各种信息组合成三个列表，准备分别调用上面的函数以获取脚本片段。这样弄比较简洁。
  45.     result = '"' + launch_java_path + '" ' \
  46.              + using.java_setting(0, java_setting_package) + " -cp " \
  47.              + using.get_libraries_json(0, get_libraries_json_package) + " " \
  48.              + using.get_player_info(0, get_player_info_package)
  49.     # 开始调用函数并拼接脚本。
  51.     logger.Logger.debug("成功输出启动脚本：" + result)
  52.     logger.Logger.info("启动脚本已输出，准备启动。")
  54.     # 创建一个子进程，并使用os库中的system来将启动脚本输入cmd控制台。
  55.     func.threading_manager.acquire()
  56.     threading.Thread(target=os.system, args=(result,), name="Os_cmd_launcher").start()
  57.     func.threading_manager.release()

这样就能启动游戏了！