【Unity网络同步框架 - Nakama研究(二)】

Unity网络同步框架 - Nakama研究(二)

   虽说官方文档和网站以及论坛创建的不错，而且另有中文翻译且质量也不错，但是总会遇到一些词不达意，说了但是依旧没懂的部门，甚至问AI也问不出什么东西，所以必要有一些比较明显的博客来记录实战部门
  服务端搭建

   使用官方保举的Docker进行安装
  

• 在将Docker软件下载到Windows环境后，请确保已安装node-js、typescript、lua和Go等环境（后续的对应扩展必要），否则先进行npm相干库的安装，必要翻墙或者镜像库安装。
  
• 进入根目次，运行cmd控制台（在文件管理器上方地址栏直接输入cmd），输入docker compose up，即能运行服务器（如必要设置文件见下文）。如果更改模块，必要重新编译运行，请输入docker compose up --build nakama(或者在Docker中制止运行再打开)
  
• 如果遇到标题，一样平常环境是缺少对应的库，或者必要下载的库在墙外，下载超时了，很少会遇到不支持对应的数据库CockroachDB或者PostgreSQL啥的，如果遇到了其他标题，建议上官网或者论坛查查
  
• 运行乐成后，你应该能在Docker中看到如下：
  
  
  
  
  
  

这代表你的服务端已经正常开启了，接下来我们测试一下对应的一些方法和函数。
我的设置文件docker-compose（官网上也能找到类似的）

1. version: '3'
2. services:
3.   cockroachdb:
4.     image: cockroachdb/cockroach:latest-v23.1
5.     command: start-single-node --insecure --store=attrs=ssd,path=/var/lib/cockroach/
6.     restart: "no"
7.     volumes:
8.       - data:/var/lib/cockroach
9.     expose:
10.       - "8080"
11.       - "26257"
12.     ports:
13.       - "26257:26257"
14.       - "8080:8080"
15.     healthcheck:
16.       test: ["CMD", "curl", "-f", "http://localhost:8080/health?ready=1"]
17.       interval: 3s
18.       timeout: 3s
19.       retries: 5
21.   nakama:
22.     image: registry.heroiclabs.com/heroiclabs/nakama:3.22.0
23.     entrypoint:
24.       - "/bin/sh"
25.       - "-ecx"
26.       - >
27.           /nakama/nakama migrate up --database.address root@cockroachdb:26257 &&
28.           exec /nakama/nakama --name nakama1 --database.address root@cockroachdb:26257 --logger.level DEBUG --session.token_expiry_sec 7200 --metrics.prometheus_port 9100
29.     restart: "no"
30.     links:
31.       - "cockroachdb:db"
32.     depends_on:
33.       - cockroachdb
34.       - prometheus
35.     volumes:
36.       - ./:/nakama/data
37.     environment:
38.       - NAKAMA_RUNTIME_PATH=/nakama/data/modules
39.     expose:
40.       - "7349"
41.       - "7350"
42.       - "7351"
43.       - "9100"
44.     ports:
45.       - "7349:7349"
46.       - "7350:7350"
47.       - "7351:7351"
48.     healthcheck:
49.       test: ["CMD", "/nakama/nakama", "healthcheck"]
50.       interval: 10s
51.       timeout: 5s
52.       retries: 5
54.   prometheus:
55.     image: prom/prometheus
56.     entrypoint: /bin/sh -c
57.     command: |
58.       'sh -s <<EOF
59.         cat > ./prometheus.yml <<EON
60.       global:
61.         scrape_interval:     15s
62.         evaluation_interval: 15s
64.       scrape_configs:
65.         - job_name: prometheus
66.           static_configs:
67.           - targets: ['localhost:9090']
69.         - job_name: nakama
70.           metrics_path: /
71.           static_configs:
72.           - targets: ['nakama:9100']
73.       EON
74.       prometheus --config.file=./prometheus.yml
75.       EOF'
76.     ports:
77.       - '9090:9090'
79. volumes:
80.   data:

复制代码

服务器简单测试

   部署完了服务器，现在我们应该如何使用以及观察对应的服务器内的数据
  

• 为了方便测试，我们在这里先不使用Unity，直接打开一个C#程序，我们只是测试一下而已，按照简单的来。有几个重要的网站必要记一下：
  
  
  • 本地控制台
    
  • 接口Api地址(包含client和console)
    
  
  
• 测试代码如下：
  

1. using Newtonsoft.Json.Linq;
2. using System.Text;
4. class Program
5. {
6.         private static readonly string nakamaApiMatchUrl = "http://127.0.0.1:7350/v2/match";
7.         private static readonly string nakamaApiUrl = "http://127.0.0.1:7350/v2/account/authenticate/device?create=true";
8.         private static readonly string nakamaApiLogoutUrl = "http://127.0.0.1:7350/v2/session/logout";
9.         private static readonly string nakamaApiStorageUrl = "http://127.0.0.1:7350/v2/storage";
10.         private static readonly string nakamaApiKey = "defaultkey";
11.         private static string nakamaAuthToken = "nakama.autoToken";
13.         static async Task Main(string[] args)
14.         {
15.                 await AuthenticateDevice();
16.                 await FetchMatchList();
17.                 await FetchStorageObjectAsync();
18.                 await LogOut();
19.         }
20.        
21.         static async Task AuthenticateDevice()
22.         {
23.                 try
24.                 {
25.                         var authHeader = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{nakamaApiKey}:"));
26.        
27.                         var client = new HttpClient();
28.                         client.DefaultRequestHeaders.Add("Authorization", $"Basic {authHeader}");
29.        
30.                         var postData = new { id = "someuniqueidentifier" };
31.                         var json = Newtonsoft.Json.JsonConvert.SerializeObject(postData);
32.                         var content = new StringContent(json, Encoding.UTF8, "application/json");
33.        
34.                         var response = await client.PostAsync(nakamaApiUrl, content);
35.        
36.                         if (response.IsSuccessStatusCode)
37.                         {
38.                                 var responseContent = await response.Content.ReadAsStringAsync();
39.                                 var responseJson = JObject.Parse(responseContent);
40.        
41.                                 Console.WriteLine("Authentication successful.");
42.                                 Console.WriteLine($"Session Token: {responseJson["token"]}");
43.                                 if(responseJson.ContainsKey("token"))
44.                                         nakamaAuthToken = responseJson["token"].ToString();
45.                         }
46.                         else
47.                         {
48.                                 Console.WriteLine($"Error authenticating device: {response.StatusCode}");
49.                         }
50.                 }
51.                 catch (Exception ex)
52.                 {
53.                         Console.WriteLine($"Error occurred: {ex.Message}");
54.                         Console.WriteLine("Please check the URL and network connection. If the issue persists, ensure the URL is correct and the server is running.");
55.                 }
56.         }
57.        
58.         static async Task LogOut()
59.         {
60.                 try
61.                 {
62.                         var client = new HttpClient();
63.                         client.DefaultRequestHeaders.Add("Authorization", $"Bearer {nakamaAuthToken}");
64.        
65.                         var response = await client.PostAsync($"{nakamaApiLogoutUrl}", null);
66.        
67.                         if (response.IsSuccessStatusCode)
68.                         {
69.                                 var content = await response.Content.ReadAsStringAsync();
70.                                 var _content = JObject.Parse(content);
71.                         }
72.                         else
73.                         {
74.                                 Console.WriteLine($"Error : {response.StatusCode}");
75.                         }
76.                 }
77.                 catch (Exception ex)
78.                 {
79.                         Console.WriteLine($"Error occurred: {ex.Message}");
80.                 }
81.         }
82.        
83.         static async Task FetchMatchList()
84.         {
85.                 try
86.                 {
87.                         var client = new HttpClient();
88.                         client.DefaultRequestHeaders.Add("Authorization", $"Bearer {nakamaAuthToken}");
89.        
90.                         var response = await client.GetAsync($"{nakamaApiMatchUrl}?limit=10&min_size=1&max_size=10");
91.        
92.                         if (response.IsSuccessStatusCode)
93.                         {
94.                                 var content = await response.Content.ReadAsStringAsync();
95.                                 var matches = JObject.Parse(content);
96.        
97.                                 if(matches.ContainsKey("matches"))
98.                                 {
99.                                         foreach (var match in matches["matches"])
100.                                         {
101.                                                 Console.WriteLine($"Match ID: {match["match_id"]}, Size: {match["size"]}");
102.                                         }
103.                                 }
104.                                 else
105.                                 {
106.                                         Console.WriteLine($"Match list is empty");
107.                                 }
108.                         }
109.                         else
110.                         {
111.                                 Console.WriteLine($"Error fetching match list: {response.StatusCode}");
112.                         }
113.                 }
114.                 catch (Exception ex)
115.                 {
116.                         Console.WriteLine($"Error occurred: {ex.Message}");
117.                 }
118.         }
119.        
120.         static async Task FetchStorageObjectAsync()
121.         {
122.                 try
123.                 {
124.                         var client = new HttpClient();
125.                         client.DefaultRequestHeaders.Add("Authorization", $"Bearer {nakamaAuthToken}");
126.        
127.                         var response = await client.GetAsync($"{nakamaApiStorageUrl}/test/0ba39c8d-5b3d-429d-a570-85af6df61b49");
128.        
129.                         if (response.IsSuccessStatusCode)
130.                         {
131.                                 var content = await response.Content.ReadAsStringAsync();
132.                                 var storageContent = JObject.Parse(content);
133.                         }
134.                         else
135.                         {
136.                                 Console.WriteLine($"Error fetching match list: {response.StatusCode}");
137.                         }
138.                 }
139.                 catch (Exception ex)
140.                 {
141.                         Console.WriteLine($"Error occurred: {ex.Message}");
142.                 }
143.         }
145. }

复制代码

• 上面的代码中简单测试了几个功能部门：登录，获取比赛（房间）列表，存储数据，登出。
  
• 其中有一些坑必要留意一下：
  
  
  
  • 上面的设置中，不同的服务有不同的端口，其中7350是http请求的端口，也能自行指定；
    
  • Nakama中的比赛（房间）分为权势巨子（服务器创建）和非权势巨子（玩家自创建），要留意区分（查询时会返回不同）
    
  • 存储分为服务器内存的存储和数据库本地的持久存储，上面的测试是一个临时行的测试，请求的全文是/v2/storage/{collection}/{userId}，如果必要严格测试的话，该测试必要后期进行才气跑通
    
  
  
• 
  
  如果乐成的话，运行的效果应该是上面类似(有部门数据没有打印出来，偷懒直接断点看了)
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。