自定义 Godot 服务器

前言

Godot将多线程实现为服务器. 服务器是管理数据, 处理数据和推送结果的守护进程. 服务器实现中介模式, 该模式解释引擎和其他模块的资源ID和处理数据. 此外, 服务器声明其RID分配的所有权.

本指南假设读者知道如何创建C++模块和Godot数据类型. 如果没有, 请参考 自定义 C++ 模块.

参考

可以做什么？

  • 添加人工智能.

  • 添加自定义异步线程.

  • 添加对新输入设备的支持.

  • 添加写线程.

  • 添加自定义 VoIP 协议。

  • 以及更多……

创建 Godot 服务器

服务器至少必须拥有静态的实例、睡眠计时器、线程循环、初始化状态、清理过程。

  1. #ifndef HILBERT_HOTEL_H
  2. #define HILBERT_HOTEL_H
  4. #include "core/list.h"
  5. #include "core/object.h"
  6. #include "core/os/thread.h"
  7. #include "core/os/mutex.h"
  8. #include "core/rid.h"
  9. #include "core/set.h"
  10. #include "core/variant.h"
  12. class HilbertHotel : public Object {
  13.         GDCLASS(HilbertHotel, Object);
  15.         static HilbertHotel *singleton;
  16.         static void thread_func(void *p_udata);
  18. private:
  19.         bool thread_exited;
  20.         mutable bool exit_thread;
  21.         Thread *thread;
  22.         Mutex *mutex;
  24. public:
  25.         static HilbertHotel *get_singleton();
  26.         Error init();
  27.         void lock();
  28.         void unlock();
  29.         void finish();
  31. protected:
  32.         static void _bind_methods();
  34. private:
  35.         uint64_t counter;
  36.         RID_Owner<InfiniteBus> bus_owner;
  37.         // https://github.com/godotengine/godot/blob/3.x/core/rid.h#L196
  38.         Set<RID> buses;
  39.         void _emit_occupy_room(uint64_t room, RID rid);
  41. public:
  42.         RID create_bus();
  43.         Variant get_bus_info(RID id);
  44.         bool empty();
  45.         bool delete_bus(RID id);
  46.         void clear();
  47.         void register_rooms();
  48.         HilbertHotel();
  49. };
  51. #endif
  1. #include "hilbert_hotel.h"
  3. #include "core/dictionary.h"
  4. #include "core/list.h"
  5. #include "core/os/os.h"
  6. #include "core/variant.h"
  8. #include "prime_225.h"
  10. void HilbertHotel::thread_func(void *p_udata) {
  12.         HilbertHotel *ac = (HilbertHotel *) p_udata;
  13.         uint64_t msdelay = 1000;
  15.         while (!ac->exit_thread) {
  16.                 if (!ac->empty()) {
  17.                         ac->lock();
  18.                         ac->register_rooms();
  19.                         ac->unlock();
  20.                 }
  21.                 OS::get_singleton()->delay_usec(msdelay * 1000);
  22.         }
  23. }
  25. Error HilbertHotel::init() {
  26.         thread_exited = false;
  27.         counter = 0;
  28.         mutex = Mutex::create();
  29.         thread = Thread::create(HilbertHotel::thread_func, this);
  30.         return OK;
  31. }
  33. HilbertHotel *HilbertHotel::singleton = NULL;
  35. HilbertHotel *HilbertHotel::get_singleton() {
  36.         return singleton;
  37. }
  39. void HilbertHotel::register_rooms() {
  40.         for (Set<RID>::Element *e = buses.front(); e; e = e->next()) {
  41.                 auto bus = bus_owner.getornull(e->get());
  43.                 if (bus) {
  44.                         uint64_t room = bus->next_room();
  45.                         _emit_occupy_room(room, bus->get_self());
  46.                 }
  47.         }
  48. }
  50. void HilbertHotel::unlock() {
  51.         if (!thread || !mutex) {
  52.                 return;
  53.         }
  55.         mutex->unlock();
  56. }
  58. void HilbertHotel::lock() {
  59.         if (!thread || !mutex) {
  60.                 return;
  61.         }
  63.         mutex->lock();
  64. }
  66. void HilbertHotel::_emit_occupy_room(uint64_t room, RID rid) {
  67.         _HilbertHotel::get_singleton()->_occupy_room(room, rid);
  68. }
  70. Variant HilbertHotel::get_bus_info(RID id) {
  71.         InfiniteBus *)bus = bus_owner.getornull(id);
  73.         if (bus) {
  74.                 Dictionary d;
  75.                 d["prime"] = bus->get_bus_num();
  76.                 d["current_room"] = bus->get_current_room();
  77.                 return d;
  78.         }
  80.         return Variant();
  81. }
  83. void HilbertHotel::finish() {
  84.         if (!thread) {
  85.                 return;
  86.         }
  88.         exit_thread = true;
  89.         Thread::wait_to_finish(thread);
  91.         memdelete(thread);
  93.         if (mutex) {
  94.                 memdelete(mutex);
  95.         }
  97.         thread = NULL;
  98. }
  100. RID HilbertHotel::create_bus() {
  101.         lock();
  102.         InfiniteBus *ptr = memnew(InfiniteBus(PRIME[counter++]));
  103.         RID ret = bus_owner.make_rid(ptr);
  104.         ptr->set_self(ret);
  105.         buses.insert(ret);
  106.         unlock();
  108.         return ret;
  109. }
  111. // https://github.com/godotengine/godot/blob/3.x/core/rid.h#L187
  112. bool HilbertHotel::delete_bus(RID id) {
  113.         if (bus_owner.owns(id)) {
  114.                 lock();
  115.                 InfiniteBus *b = bus_owner.get(id);
  116.                 bus_owner.free(id);
  117.                 buses.erase(id);
  118.                 memdelete(b);
  119.                 unlock();
  120.                 return true;
  121.         }
  123.         return false;
  124. }
  126. void HilbertHotel::clear() {
  127.         for (Set<RID>::Element *e = buses.front(); e; e = e->next()) {
  128.                 delete_bus(e->get());
  129.         }
  130. }
  132. bool HilbertHotel::empty() {
  133.         return buses.size() <= 0;
  134. }
  136. void HilbertHotel::_bind_methods() {
  137. }
  139. HilbertHotel::HilbertHotel() {
  140.         singleton = this;
  141. }
  1. /* prime_225.h */
  3. #include "core/int_types.h"
  5. const uint64_t PRIME[225] = {
  6.                 2,3,5,7,11,13,17,19,23,
  7.                 29,31,37,41,43,47,53,59,61,
  8.                 67,71,73,79,83,89,97,101,103,
  9.                 107,109,113,127,131,137,139,149,151,
  10.                 157,163,167,173,179,181,191,193,197,
  11.                 199,211,223,227,229,233,239,241,251,
  12.                 257,263,269,271,277,281,283,293,307,
  13.                 311,313,317,331,337,347,349,353,359,
  14.                 367,373,379,383,389,397,401,409,419,
  15.                 421,431,433,439,443,449,457,461,463,
  16.                 467,479,487,491,499,503,509,521,523,
  17.                 541,547,557,563,569,571,577,587,593,
  18.                 599,601,607,613,617,619,631,641,643,
  19.                 647,653,659,661,673,677,683,691,701,
  20.                 709,719,727,733,739,743,751,757,761,
  21.                 769,773,787,797,809,811,821,823,827,
  22.                 829,839,853,857,859,863,877,881,883,
  23.                 887,907,911,919,929,937,941,947,953,
  24.                 967,971,977,983,991,997,1009,1013,1019,
  25.                 1021,1031,1033,1039,1049,1051,1061,1063,1069,
  26.                 1087,1091,1093,1097,1103,1109,1117,1123,1129,
  27.                 1151,1153,1163,1171,1181,1187,1193,1201,1213,
  28.                 1217,1223,1229,1231,1237,1249,1259,1277,1279,
  29.                 1283,1289,1291,1297,1301,1303,1307,1319,1321,
  30.                 1327,1361,1367,1373,1381,1399,1409,1423,1427
  31. };

自定义托管资源数据

Godot 服务器实现了中介模式。所有数据类型都继承 RID_Data。RID_Owner <MyRID_Data> 在调用 make_rid 时拥有对象。仅在调试模式期间，RID_Owner 维护 RID 列表。实际上，RID 类似于编写面向对象的 C 代码。

  1. class InfiniteBus : public RID_Data {
  2.         RID self;
  4. private:
  5.         uint64_t prime_num;
  6.         uint64_t num;
  8. public:
  9.         uint64_t next_room() {
  10.                 return prime_num * num++;
  11.         }
  13.         uint64_t get_bus_num() const {
  14.                 return prime_num;
  15.         }
  17.         uint64_t get_current_room() const {
  18.                 return prime_num * num;
  19.         }
  21.         _FORCE_INLINE_ void set_self(const RID &p_self) {
  22.                 self = p_self;
  23.         }
  25.         _FORCE_INLINE_ RID get_self() const {
  26.                 return self;
  27.         }
  29.         InfiniteBus(uint64_t prime) : prime_num(prime), num(1) {};
  30.         ~InfiniteBus() {};
  31. }

参考

在 GDScript 中注册类

服务器在 register_types.cpp 中分配。构造函数设置静态实例，init() 创建托管线程；unregister_types.cpp 清理服务器。

由于Godot服务类创建了一个实例并将其绑定到静态单例, 因此绑定该类可能不会引用正确的实例. 因此, 必须创建一个虚拟类来引用正确的Godot服务.

在 register_server_types() 中，Engine :: get_singleton() -> add_singleton 用于在 GDScript 中注册虚拟类。

  1. /* register_types.cpp */
  3. #include "register_types.h"
  5. #include "core/class_db.h"
  6. #include "core/engine.h"
  8. #include "hilbert_hotel.h"
  10. static HilbertHotel *hilbert_hotel = NULL;
  11. static _HilbertHotel *_hilbert_hotel = NULL;
  13. void register_hilbert_hotel_types() {
  14.         hilbert_hotel = memnew(HilbertHotel);
  15.         hilbert_hotel->init();
  16.         _hilbert_hotel = memnew(_HilbertHotel);
  17.         ClassDB::register_class<_HilbertHotel>();
  18.         Engine::get_singleton()->add_singleton(Engine::Singleton("HilbertHotel", _HilbertHotel::get_singleton()));
  19. }
  21. void unregister_hilbert_hotel_types() {
  22.         if (hilbert_hotel) {
  23.                 hilbert_hotel->finish();
  24.                 memdelete(hilbert_hotel);
  25.         }
  27.         if (_hilbert_hotel) {
  28.                 memdelete(_hilbert_hotel);
  29.         }
  30. }
  1. /* register_types.h */
  3. /* Yes, the word in the middle must be the same as the module folder name */
  4. void register_hilbert_hotel_types();
  5. void unregister_hilbert_hotel_types();

绑定方法

虚拟类将单例方法绑定到GDScript. 在大多数情况下, 虚拟类方法封装在内.

  1. Variant _HilbertHotel::get_bus_info(RID id) {
  2.         return HilbertHotel::get_singleton()->get_bus_info(id);
  3. }

绑定信号

可以通过调用GDScript虚拟对象向GDScript发出信号.

  1. void HilbertHotel::_emit_occupy_room(uint64_t room, RID rid) {
  2.         _HilbertHotel::get_singleton()->_occupy_room(room, rid);
  3. }
  1. class _HilbertHotel : public Object {
  2.         GDCLASS(_HilbertHotel, Object);
  4.         friend class HilbertHotel;
  5.         static _HilbertHotel *singleton;
  7. protected:
  8.         static void _bind_methods();
  10. private:
  11.         void _occupy_room(int room_number, RID bus);
  13. public:
  14.         RID create_bus();
  15.         void connect_signals();
  16.         bool delete_bus(RID id);
  17.         static _HilbertHotel *get_singleton();
  18.         Variant get_bus_info(RID id);
  20.         _HilbertHotel();
  21.         ~_HilbertHotel();
  22. };
  24. #endif
  1. _HilbertHotel *_HilbertHotel::singleton = NULL;
  2. _HilbertHotel *_HilbertHotel::get_singleton() { return singleton; }
  4. RID _HilbertHotel::create_bus() {
  5.         return HilbertHotel::get_singleton()->create_bus();
  6. }
  8. bool _HilbertHotel::delete_bus(RID rid) {
  9.         return HilbertHotel::get_singleton()->delete_bus(rid);
  10. }
  12. void _HilbertHotel::_occupy_room(int room_number, RID bus) {
  13.         emit_signal("occupy_room", room_number, bus);
  14. }
  16. Variant _HilbertHotel::get_bus_info(RID id) {
  17.         return HilbertHotel::get_singleton()->get_bus_info(id);
  18. }
  20. void _HilbertHotel::_bind_methods() {
  21.         ClassDB::bind_method(D_METHOD("get_bus_info", "r_id"), &_HilbertHotel::get_bus_info);
  22.         ClassDB::bind_method(D_METHOD("create_bus"), &_HilbertHotel::create_bus);
  23.         ClassDB::bind_method(D_METHOD("delete_bus"), &_HilbertHotel::delete_bus);
  24.         ADD_SIGNAL(MethodInfo("occupy_room", PropertyInfo(Variant::INT, "room_number"), PropertyInfo(Variant::_RID, "r_id")));
  25. }
  27. void _HilbertHotel::connect_signals() {
  28.         HilbertHotel::get_singleton()->connect("occupy_room", _HilbertHotel::get_singleton(), "_occupy_room");
  29. }
  31. _HilbertHotel::_HilbertHotel() {
  32.         singleton = this;
  33. }
  35. _HilbertHotel::~_HilbertHotel() {
  36. }

MessageQueue

为了将命令发送到SceneTree中,MessageQueue是线程安全的缓冲区, 用于将其他线程的设置和调用方法排队. 要对命令进行排队, 请获取目标对象RID并使用 push_call, push_set, 或 push_notification 执行所需的行为. 每当执行 SceneTree::idle 或 SceneTree::iteration 时, 都会刷新队列.

参考：

总结

这是GDScript示例代码:

  1. extends Node
  3. func _ready():
  4.     print("Start debugging")
  5.     HilbertHotel.connect("occupy_room", self, "_print_occupy_room")
  6.     var rid = HilbertHotel.create_bus()
  7.     OS.delay_msec(2000)
  8.     HilbertHotel.create_bus()
  9.     OS.delay_msec(2000)
  10.     HilbertHotel.create_bus()
  11.     OS.delay_msec(2000)
  12.     print(HilbertHotel.get_bus_info(rid))
  13.     HilbertHotel.delete_bus(rid)
  14.     print("Ready done")
  16. func _print_occupy_room(room_number, r_id):
  17.     print("Room number: "  + str(room_number) + ", RID: " + str(r_id))
  18.     print(HilbertHotel.get_bus_info(r_id))

注意