Custom Godot servers

    This guide assumes the reader knows how to create C++ modules and Godot data types. If not, refer to .

    What for?

    • Adding artificial intelligence.

    • Adding custom asynchronous threads.

    • Adding support for a new input device.

    • Adding a custom VoIP protocol.

    • And more…

    At minimum, a server must have a static instance, a sleep timer, a thread loop, an initialization state and a cleanup procedure.

    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);
    72.         if (bus) {
    73.                 Dictionary d;
    74.                 d["prime"] = bus->get_bus_num();
    75.                 d["current_room"] = bus->get_current_room();
    76.                 return d;
    77.         }
    79.         return Variant();
    80. }
    82. void HilbertHotel::finish() {
    83.         if (!thread) {
    84.                 return;
    85.         }
    87.         exit_thread = true;
    90.         memdelete(thread);
    92.         if (mutex) {
    93.                 memdelete(mutex);
    94.         }
    96.         thread = NULL;
    97. }
    99. RID HilbertHotel::create_bus() {
    100.         lock();
    101.         InfiniteBus *ptr = memnew(InfiniteBus(PRIME[counter++]));
    102.         RID ret = bus_owner.make_rid(ptr);
    103.         ptr->set_self(ret);
    104.         buses.insert(ret);
    105.         unlock();
    107.         return ret;
    108. }
    110. // https://github.com/godotengine/godot/blob/3.x/core/rid.h#L187
    111. bool HilbertHotel::delete_bus(RID id) {
    112.         if (bus_owner.owns(id)) {
    113.                 lock();
    114.                 InfiniteBus *b = bus_owner.get(id);
    115.                 bus_owner.free(id);
    116.                 buses.erase(id);
    117.                 memdelete(b);
    118.                 unlock();
    119.                 return true;
    120.         }
    122.         return false;
    123. }
    125. void HilbertHotel::clear() {
    126.         for (Set<RID>::Element *e = buses.front(); e; e = e->next()) {
    127.                 delete_bus(e->get());
    128.         }
    129. }
    131. bool HilbertHotel::empty() {
    132.         return buses.size() <= 0;
    133. }
    135. void HilbertHotel::_bind_methods() {
    136. }
    138. HilbertHotel::HilbertHotel() {
    139.         singleton = this;
    140. }
    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.                 1021,1031,1033,1039,1049,1051,1061,1063,1069,
    25.                 1087,1091,1093,1097,1103,1109,1117,1123,1129,
    26.                 1151,1153,1163,1171,1181,1187,1193,1201,1213,
    27.                 1217,1223,1229,1231,1237,1249,1259,1277,1279,
    28.                 1283,1289,1291,1297,1301,1303,1307,1319,1321,
    29.                 1327,1361,1367,1373,1381,1399,1409,1423,1427
    30. };

    Custom managed resource data

    Godot servers implement a mediator pattern. All data types inherit RID_Data. RID_Owner<MyRID_Data> owns the object when make_rid is called. During debug mode only, RID_Owner maintains a list of RIDs. In practice, RIDs are similar to writing object-oriented C code.

    Servers are allocated in register_types.cpp. The constructor sets the static instance and creates the managed thread; unregister_types.cpp cleans up the server.

    In register_server_types(), Engine::get_singleton()->add_singleton is used to register the dummy class in 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();

    The dummy class binds singleton methods to GDScript. In most cases, the dummy class methods wraps around.

    Binding Signals

    It is possible to emit signals to GDScript by calling the GDScript dummy object.

    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

    MessageQueue

    In order to send commands into SceneTree, MessageQueue is a thread-safe buffer to queue set and call methods for other threads. To queue a command, obtain the target object RID and use either push_call, push_set, or push_notification to execute the desired behavior. The queue will be flushed whenever either SceneTree::idle or SceneTree::iteration is executed.

    Here is the GDScript sample code:

    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))