xmdhs
本帖最后由 xmdhs 于 2021-7-31 16:53 编辑

gml-c-shared

简单说就是一个启动器库，可以以此简单的启动游戏和补全游戏文件。

是对于 gomclauncher 的封装，导出为 c 语言的动态链接库。大概大多数语言都能很好的调用。  

开源地址

mit 协议开源 https://github.com/xmdhs/gml-c-shared

支持功能

功能状况
正版登录√
authlib-injector 外置登录√
微软登录√
原版游戏下载√
多线程下载部分[1]
forge 等自动安装× [2]


注意事项

返回的 char* 和 char** 类型是分配在堆上的，需要释放内存，可以使用

  1. char *a;
  2. Freechar(a,0)
复制代码

释放 char*

  1. char **a
  2. Freechar(a,长度)
复制代码

释放 char**

当然不释放内存也完全没问题的，启动器本身不会长久运行，而且这点内存泄漏了也没多少。

char* 使用 utf-8 编码，无论在 liunx 还是 windows 都一样，所以直接用 c 语言调用的话，可能需要转码。

下载源的镜像使用了 bmclapi，需按照协议注明

BMCLAPI下的所有文件，除BMCLAPI本身的源码之外，归源站点所有
BMCLAPI会尽量保证文件的完整性、有效性和实时性，对于使用BMCLAPI带来的一切纠纷，与BMCLAPI无关。
BMCLAPI和BMCL不同，属于非开源项目
所有使用BMCLAPI的程序必需在下载界面或其他可视部分标明来源
禁止在BMCLAPI上二次封装其他协议  

https://bmclapidoc.bangbang93.com/

文档

偷懒，直接在头文件上写注释，应该足够了吧

  1. //仅作注释用，不要导入此文件


  4. //char* 均使用 utf-8 编码

  6. typedef struct
  7. {
  8.     //游戏路径，需要创建一个 .minecraft 文件夹，例如 D:/mc/.minecraft
  9.     char *Minecraftpath;
  10.     //分配内存大小，单位为 mb
  11.     long long RAM;
  12.     //玩家名
  13.     char *Name;
  14.     //uuid
  15.     char *UUID;
  16.     //正版/外置登录相关，离线登录可随便设置
  17.     char *AccessToken;
  18.     //要启动的游戏版本，可用 ListVersion 方法找到被识别的版本
  19.     char *Version;
  20.     //外置登录的 api 地址。
  21.     char *ApiAddress;
  22.     //自定义的 java 参数，字符串数组，可以通过 NewChar 和 SetChar 来构建
  23.     char **Flag;
  24.     //字符串数组的长度
  25.     int  flag_len;
  26.     //是否开启外置登录
  27.     int  independent;
  28. } Gameinfo;

  30. typedef struct
  31. {
  32.     //code 对应的信息见下方注释
  33.     int  code;
  34.     //详细的错误信息
  35.     char *msg;
  36. } err;

  38. /*code | msg
  39. -----|----------------------------------------------
  40. -1   | 未知错误
  41. 0    | 正常
  42. 1    | 文件不存在
  43. 2    | json 错误
  44. 3    | minecraft json 格式错误
  45. 4    | 找不到该版本
  46. 5    | 下载失败次数过多
  47. 6    | authlib 登录时，有多个账户，且并没有选择（也就是没有设置 username 参数）
  48. 7    | 没有这个角色
  49. 8    | 通常是密码错误，或者登录过期
  50. 9    | authlib 找不到可用档案，也就是没有创建角色之类的
  51. 10   | accessToken 失效
  52. 11   | 登录微软账户时打开的浏览器中，打开了其他页面
  53. 12   | 尝试重新登录微软账户
  54. 13   | 没有购买游戏或者没有迁移账号
  55. 14   | 没有安装 chrome 或者新版本的 edge（windows only）
  56. */

  58. typedef struct
  59. {
  60.     //字符串数组
  61.     char **charlist;
  62.     //字符串数组的长度
  63.     int len;
  64.     //错误
  65.     err e;

  67. } GmlReturn;

  69. //当下载文件时，发生错误时将调用此函数。
  70. typedef void (*Fail)(char*);

  72. //下载文件成功后，会调用此函数
  73. //第一个参数表示下载成功的类型
  74. /*第一个参数见下方表格解释。第二个参数传递剩余没下载的文件数量，成功下载一次，调用一次。

  76. code | msg
  77. -----|-------
  78. 1    | 下载游戏核心
  79. 2    | 下载资源文件
  80. 3    | 下载游戏库
  81. */
  82. typedef void (*Ok)(int,int);

  84. //下载或检查游戏，成功或失败时，将调用此函数
  85. typedef void (*gmlfinish)(err);

  87. typedef struct
  88. {
  89.     char *Username;
  90.     char *ClientToken;
  91.     char *UUID;
  92.     char *AccessToken;
  93.     char *ApiAddress;
  94.     //可用的用户名，当 Auth 返回 6 错误时，可以选择此列表中的用户名，设置在 Auth 的 username 参数上，来选择档案。
  95.     //只有外置登录有单账号，多档案。
  96.     char **availableProfiles;
  97.     //长度
  98.     int availableProfilesLen;
  99. } AuthDate;

  101. typedef struct
  102. {
  103.     char *Username;
  104.     char *UUID;
  105.     char *AccessToken;
  106. } MsAuthDate;

  108. #ifdef __cplusplus
  109. extern "C" {
  110. #endif

  112. //获取字符串数组中的字符串
  113. extern char* Getchar(char** charlist, long long int index);
  114. //释放字符串数组的内存，下面的函数返回的字符串数组都是分配在堆上的，需要用此函数释放
  115. extern void Freechar(char** charlist, long long int len);
  116. //创建一个字符串数组
  117. extern char** NewChar(long long int len);
  118. //设置字符串数组指定的位置的字符串
  119. extern void SetChar(char** cc, long long int index, char* achar);
  120. //其实就是导出了 c 语言的 malloc 函数，为了避免变量名冲突，所以首字母大写了
  121. extern void* Malloc(int i);
  122. //生成启动游戏需要的参数
  123. extern GmlReturn GenCmdArgs(Gameinfo g);
  124. //设置下载文件和正版登录的代理，非线程安全，全局共用
  125. extern err SetProxy(char* httpProxy);
  126. //下载游戏
  127. //version 下载版本，可通过 ListDownloadVersion 查找可下载的版本
  128. //Type 下载使用的下载源，留空将按照权重的随机使用三个下载源，也可以自行设置。例如 vanilla|bmclapi 表示随机使用原版下载源和 bmclapi 下载源。mcbbs 表示只使用 mcbbs 下载源
  129. //downInt 下载协程数，通常 64 即可，因为一个文件还是使用一个协程下载，多了没意义
  130. //Minecraftpath 下载的路径，例如 D:/mc/.minecraft
  131. //调用后将立刻返回一个 int64，可以使用 Cancel 函数，将此 int64 传入，取消下载操作
  132. extern long long int Download(char* version, char* Type, char* Minecraftpath, int downInt, Fail fail, Ok ok, gmlfinish finish);
  133. //检查游戏的完整性，第一次某个版本时，必须检查一次。
  134. extern long long int Check(char* version, char* Type, char* Minecraftpath, int downInt, Fail fail, Ok ok, gmlfinish finish);
  135. //取消下载或者检查游戏完整性
  136. extern void Cancel(long long int id);
  137. //列出可启动版本
  138. //path 例如 D:/mc/.minecraft/version
  139. extern GmlReturn ListVersion(char* path);
  140. //查看可下载游戏版本类型，比如正式版之类的。 type 参数和 Download 里的意义一样
  141. extern GmlReturn ListDownloadType(char* Type);
  142. //查看此类型中所有的可下载的版本
  143. extern GmlReturn ListDownloadVersion(char* VerType, char* Type);

  145. /* Return type for Auth */
  146. struct Auth_return {
  147.     AuthDate r0;
  148.     err r1;
  149. };
  150. //外置登录和正版登录
  151. //clientToken 客户端 id，可随机生成，需保证每个用户对应的 ClientToken 是不变的，否则会要求重新登录。建议直接 md5 用户名就行。
  152. //ApiAddress 可不输入完整的 api 地址，会按照协议补全，如果正版登录，则无需设置此项。
  153. //username 外置登录时需要，具体见 AuthDate 处的注释
  154. //不要保存密码，保存 AccessToken
  155. extern struct Auth_return Auth(char* ApiAddress, char* username, char* email, char* password, char* clientToken);
  156. //验证 AccessToken 的有效性，建议每次启动游戏前，都验证一次
  157. extern err Validate(char* AccessToken, char* ClientToken, char* ApiAddress);

  159. /* Return type for Refresh */
  160. struct Refresh_return {
  161.     AuthDate r0;
  162.     err r1;
  163. };
  164. //若 Validate 验证 AccessToken 失效，则可通过此方法刷新，如果刷新无效，则重新登录就是。
  165. extern struct Refresh_return Refresh(char* AccessToken, char* ClientToken, char* ApiAddress);

  167. /* Return type for MsAuth */
  168. struct MsAuth_return {
  169.     MsAuthDate r0;
  170.     err r1;
  171. };
  172. //微软登录，将弹出一个窗口让玩家在其中进行登录，需要安装 chrome，或者新版 edge（windows only）
  173. extern struct MsAuth_return MsAuth();

  175. /* Return type for MsAuthValidate */
  176. struct MsAuthValidate_return {
  177.     MsAuthDate r0;
  178.     err r1;
  179. };
  180. //验证微软登录的 AccessToken 有效性，建议首次登录后也使用此方法验证，因为即使没有购买游戏，MsAuth 也会返回有效的内容。
  181. extern struct MsAuthValidate_return MsAuthValidate(char* AccessToken);

  183. #ifdef __cplusplus
  184. }
  185. #endif
复制代码

示例

使用 java，用 jna 库调用，简单的下载游戏和启动。

  1. import com.sun.jna.*;

  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.nio.charset.StandardCharsets;
  7. import java.util.*;
  8. import java.util.concurrent.locks.Condition;
  9. import java.util.concurrent.locks.Lock;
  10. import java.util.concurrent.locks.ReentrantLock;

  12. public class Main {

  14.     public interface fail extends Callback {
  15.         void Fail(Pointer c);
  16.     }

  18.     public static class c implements fail {
  19.         @Override
  20.         public void Fail(Pointer c) {
  21.             String s = c.getString(0, "UTF-8");
  22.             System.out.println("java: " + s);
  23.         }
  24.     }

  26.     public interface ok extends Callback {
  27.         void Ok(int i1, int i2);
  28.     }

  30.     private static Map<Integer, String> m = new HashMap<>();

  32.     static {
  33.         m.put(1, "下载游戏核心");
  34.         m.put(2, "下载资源文件");
  35.         m.put(3, "下载游戏库");
  36.     }

  38.     public static class f implements ok {
  39.         @Override
  40.         public void Ok(int i1, int i2) {
  41.             String s = m.get(i1);
  42.             System.out.println(s + "剩余：" + i2);
  43.         }
  44.     }

  46.     public static class GoErr extends Structure implements Structure.ByValue {
  47.         public int r0;
  48.         public Pointer r1;

  50.         protected List<String> getFieldOrder() {
  51.             return Arrays.asList("r0", "r1");
  52.         }
  53.     }


  56.     public interface finish extends Callback {
  57.         void gmlfinish(GoErr c);
  58.     }

  60.     public static class f3 implements finish {
  61.         @Override
  62.         public void gmlfinish(GoErr c) {
  63.             if (c.r0 == 0) {
  64.                 lock.lock();
  65.                 condition.signalAll();
  66.                 lock.unlock();
  67.                 return;
  68.             }
  69.             String s = c.r1.getString(0, "UTF-8");
  70.             System.out.println("code: " + c.r0 + " msg: " + s);
  71.             lock.lock();
  72.             condition.signalAll();
  73.             lock.unlock();
  74.         }
  75.     }

  77.     public static class GmlReturn extends Structure implements Structure.ByValue {
  78.         public Pointer r0;
  79.         public int r1;
  80.         public GoErr r2;

  82.         protected List<String> getFieldOrder() {
  83.             return Arrays.asList("r0", "r1", "r2");
  84.         }
  85.     }

  87.     public static class AuthDate extends Structure implements Structure.ByValue {
  88.         public Pointer Username;
  89.         public Pointer ClientToken;
  90.         public Pointer UUID;
  91.         public Pointer AccessToken;
  92.         public Pointer ApiAddress;
  93.         public Pointer availableProfiles;
  94.         public int availableProfilesLen;

  96.         protected List<String> getFieldOrder() {
  97.             return Arrays.asList("Username", "ClientToken", "UUID", "AccessToken", "ApiAddress", "availableProfiles", "availableProfilesLen");
  98.         }
  99.     }

  101.     public static class Auth_return extends Structure implements Structure.ByValue {
  102.         public AuthDate r0;
  103.         public GoErr r1;

  105.         protected List<String> getFieldOrder() {
  106.             return Arrays.asList("r0", "r1");
  107.         }
  108.     }

  110.     public interface Lib extends Library {

  112.         Lib INSTANCE = Native.load("C:/Users/xmdhs/Desktop/untitled/libgml.dll", Lib.class);

  114.         long Download(Pointer version, Pointer type, Pointer path, int downint, Callback fail, Callback ok, Callback finish);

  116.         long Check(Pointer version, Pointer type, Pointer path, int downint, Callback fail, Callback ok, Callback finish);

  118.         GmlReturn GenCmdArgs(Gameinfo g);

  120.         Pointer NewChar(long len);

  122.         void SetChar(Pointer cc, long index, Pointer achar);

  124.         void Freechar(Pointer cc, long len);

  126.         Pointer Malloc(int i);

  128.         Auth_return Auth(Pointer ApiAddress, Pointer username, Pointer email, Pointer password, Pointer clientToken);
  129.     }

  131.     public static class Gameinfo extends Structure implements Structure.ByValue {
  132.         public Pointer Minecraftpath;
  133.         //分配内存大小，单位为 mb
  134.         public long RAM;
  135.         //玩家名
  136.         public Pointer Name;
  137.         //uuid
  138.         public Pointer UUID;
  139.         //正版/外置登录相关，离线登录可随便设置
  140.         public Pointer AccessToken;
  141.         //要启动的游戏版本，可用 ListVersion 方法找到被识别的版本
  142.         public Pointer Version;
  143.         //外置登录的 api 地址。
  144.         public Pointer ApiAddress;
  145.         //自定义的 java 参数，字符串数组，可以通过 NewChar 和 SetChar 来构建
  146.         public Pointer Flag;
  147.         //字符串数组的长度
  148.         public int flag_len;
  149.         //是否开启外置登录
  150.         public int independent;

  152.         protected List<String> getFieldOrder() {
  153.             return Arrays.asList("Minecraftpath", "RAM", "Name", "UUID", "AccessToken", "Version", "ApiAddress", "Flag", "flag_len", "independent");
  154.         }
  155.     }

  157.     private static Pointer String2char(String s) {
  158.         Pointer m = Lib.INSTANCE.Malloc(s.getBytes(StandardCharsets.UTF_8).length + 1);
  159.         m.setString(0, s, StandardCharsets.UTF_8.name());
  160.         return m;
  161.     }

  163.     private static final Lock lock = new ReentrantLock();
  164.     private static final Condition condition = lock.newCondition();

  166.     static c fail = new c();
  167.     static f ok = new f();
  168.     static finish finish = new f3();

  170.     public static void main(String[] args) throws InterruptedException, IOException {
  171.         Auth_return ar = Lib.INSTANCE.Auth(String2char(""), String2char(""),
  172.                 String2char("[email protected]"), String2char("Aaaa"),
  173.                 String2char("123"));
  174.         if (ar.r1.r0 != 0){
  175.             System.out.println(ar.r1.r1.getString(0,"UTF-8"));
  176.             return;
  177.         }

  179.         Pointer a1 = String2char("1.17");
  180.         Lib.INSTANCE.Download(a1, String2char(""), String2char("C:/Users/xmdhs/Desktop/新建文件夹/.minecraft"),
  181.                 64, fail, ok, finish);
  182.         //其实通过 String2char 创建的字符串，都需要用 Freechar 释放，但是这里偷懒了，反正进程结束也会释放。
  183.         Lib.INSTANCE.Freechar(a1, 0);
  184.         lock.lock();
  185.         condition.await();
  186.         lock.unlock();

  188.         Gameinfo g = new Gameinfo();
  189.         g.AccessToken = ar.r0.AccessToken;
  190.         g.ApiAddress = String2char("");
  191.         Pointer list = Lib.INSTANCE.NewChar(1);
  192.         Lib.INSTANCE.SetChar(list, 0, String2char("-XX:+UseG1GC"));
  193.         g.Flag = list;
  194.         g.flag_len = 1;
  195.         g.independent = 1;
  196.         g.Minecraftpath = String2char("C:/Users/xmdhs/Desktop/新建文件夹/.minecraft");
  197.         g.Name = ar.r0.Username;
  198.         g.UUID = ar.r0.UUID;
  199.         g.RAM = 2000;
  200.         g.Version = String2char("1.17");
  201.         GmlReturn r = Lib.INSTANCE.GenCmdArgs(g);
  202.         if (r.r2.r0 != 0) {
  203.             System.out.println(r.r2.r0 + ": " + r.r2.r1.getString(0, StandardCharsets.UTF_8.name()));
  204.             return;
  205.         }
  206.         String[] l = r.r0.getStringArray(0, r.r1, StandardCharsets.UTF_8.name());
  207.         System.out.println(Arrays.toString(l));

  209.         String[] ll = new String[l.length + 1];
  210.         ll[0] = "java";
  211.         int i = 1;
  212.         for (String v : l) {
  213.             ll[i] = v;
  214.             i++;
  215.         }
  216.         Lib.INSTANCE.Freechar(r.r0, r.r1);
  217.         Lib.INSTANCE.Freechar(list, 1);
  218.         ProcessBuilder p = new ProcessBuilder(ll);
  219.         Process pp = p.start();
  220.         BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(pp.getInputStream()));
  221.         BufferedReader stderrReader = new BufferedReader(new InputStreamReader(pp.getErrorStream()));
  222.         String line;
  223.         while ((line = stdoutReader.readLine()) != null) {
  224.             System.out.println(line);
  225.         }
  226.         while ((line = stderrReader.readLine()) != null) {
  227.             System.out.println(line);
  228.         }
  229.         System.out.println(pp.waitFor());

  231.     }
  232. }
复制代码

下载

其实推荐自行编译。需要安装 golang https://golang.google.cn/ 和 gcc 或者 clang （windows 下不能用 clang）。

然后在项目内执行 go build -trimpath -ldflags "-w -s" -buildmode=c-shared -o libgml.dll

就可以看到 libgml.dll 和 libgml.h，后缀不重要，可以自己改的。

已经编译好的 https://github.com/xmdhs/gml-c-shared/actions

linux.zip (2.44 MB, 下载次数: 4) windows.zip (2.25 MB, 下载次数: 15)

macos 就自己编译吧。
kirito=-=
竟然有Linux版本的 太感谢了
zhou_xin_yi
评论少得可怜......话说我也看得一知半解
2640982408
谢了awa，学习到了
666lwj666
评论少得可怜......话说我也看得一知半解
第一页 上一页 下一页 最后一页