sfml3-rb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7a02547990eb0f6906513fabe688b9bcb43ba17aaa510f5732a3f441ca7ad3b0
+  data.tar.gz: 964b816e089af1e0ba5cfb23c8cbafd71cc3f1260aef6247174d7f7247accba8
+SHA512:
+  metadata.gz: 215e64381b46f7b7ab21ad2d8ec7bec060b983d544253063f160d0b293ca17455a54f32b9f01a9167affe0b31426fa7e43c7bc00688be6c0b64630b702c97e54
+  data.tar.gz: 0db0e2855768aeb46f2bccaded19fdc5534aac48e181aa70e34d5dcb84bf3592278f9fa1c07859ff6d42edd312cc5b5ed1173dbe3e4e213f9fb053ca902115f9

data/LICENSE.md

@@ -0,0 +1,14 @@
+BSD Zero Clause License
+
+Copyright (c) 2026 Algaves
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# sfml3.rb
+
+Ruby bindings for [SFML 3](https://www.sfml-dev.org/), via its C API, [CSFML](https://github.com/SFML/CSFML).
+
+## Status
+
+Bound against **CSFML 3**. See [TODO.md](TODO.md) for which parts of the SFML 3 API are ported so
+far, and [CHANGELOG.md](CHANGELOG.md) for what changed recently.
+
+## Install
+
+```sh
+gem install sfml3-rb
+```
+
+On a platform with a precompiled gem this installs a binary with FreeType, SFML 3 and CSFML 3
+already linked in — no toolchain, no build, nothing to install system-wide:
+
+| Platform | Status |
+| --- | --- |
+| `x86_64-linux-gnu` | built, installed and tested |
+| `x64-mingw-ucrt` (Windows, RubyInstaller 3.1+) | builds and links cleanly; not yet run on Windows |
+| `aarch64-linux-gnu`, `x86_64-linux-musl`, `x86_64-darwin`, `arm64-darwin` | experimental, not yet built |
+
+Each gem carries one extension per Ruby ABI, covering Ruby 3.1 through 4.0.
+
+Anywhere else, RubyGems falls back to the source gem, which downloads and builds FreeType, SFML 3
+and CSFML 3 from pinned, checksum-verified tarballs at install time. That takes a few minutes and
+needs:
+
+* A C/C++ toolchain and CMake >= 3.22
+* On Linux, the X11/udev/OpenGL development headers SFML links against — these can't be bundled.
+  On Fedora:
+
+  ```sh
+  sudo dnf install cmake gcc-c++ libX11-devel \
+    libXrandr-devel libXcursor-devel libXi-devel systemd-devel libglvnd-devel
+  ```
+
+  or on Debian/Ubuntu:
+
+  ```sh
+  sudo apt-get install cmake build-essential libx11-dev \
+    libxrandr-dev libxcursor-dev libxi-dev libudev-dev libgl1-mesa-dev
+  ```
+
+Each installed gem version builds its own copy; there's no build cache shared across versions.
+
+To link against a system CSFML 3 instead (no download, no build):
+
+```sh
+gem install sfml3-rb -- --enable-system-libraries
+```
+
+## Usage
+
+```ruby
+require 'sfml'
+include SFML
+
+window = Window.new VideoMode.new(640, 480, 32), 'SFML'
+event = Event.new
+
+while window.is_open?
+  while window.poll_event! event
+    window.close! if event.type == 'closed'
+  end
+
+  window.clear [51, 76, 102, 255] # [r, g, b, a], 0-255
+  window.display
+end
+```
+
+See [`test/hello-world.rb`](test/hello-world.rb) for a fuller example with shapes and transforms.
+
+## Development
+
+```sh
+rake ports    # build the vendored FreeType + SFML 3 + CSFML 3 (rake compile does this too)
+rake compile  # build the C extension into lib/sfml/
+rake test     # compile, then run the test suite
+rake gem      # build the source gem into pkg/
+```
+
+`CMakeLists.txt` is a CLion/IDE convenience build against the same vendored `ports/` prefix — `rake`
+is the build of record.
+
+### Building the binary gems
+
+Cross-compilation runs in [rake-compiler-dock](https://github.com/rake-compiler/rake-compiler-dock),
+which supplies the cross toolchains and the cross-compiled rubies. It needs Docker or Podman, and
+pulls a large image per platform on first use.
+
+```sh
+rake platforms            # list the targets
+rake gem:x86_64-linux-gnu # build one platform into pkg/
+rake gem:native           # build all of them
+```
+
+Each run provisions the container with [`script/provision.sh`](script/provision.sh) — a current
+CMake everywhere, plus the target-side X11/udev/GL development files on Linux targets, which the
+images don't ship. Windows and macOS need nothing extra: SFML uses OS libraries and frameworks the
+mingw toolchain and the osxcross SDK already provide.
+
+Binary gems carry one extension per Ruby ABI under `lib/sfml/<major.minor>/`; `lib/sfml.rb` prefers
+that and falls back to the single `lib/sfml/sfml_ext.so` a source build installs.
+
+## License
+
+[0BSD](LICENSE.md)

data/ext/circle.c

@@ -0,0 +1,198 @@
+#include "ext/klass/drawable/circle.h"
+
+#include <stdio.h>
+
+#include "ext/module/drawable/drawable.h"
+#include "ext/klass/target.h"
+#include "ext/klass/render_state.h"
+#include "ext/exceptions.h"
+#include "ext/module/transform.h"
+#include "ext/klass/transformable.h"
+#include "ext/klass/color.h"
+#include "ext/vec2.h"
+#include "ext/rect.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+
+static VALUE rb_cCircle;
+
+static sfCircleShape *Circle_create(float r) {
+    sfCircleShape *circle = sfCircleShape_create();
+
+    sfCircleShape_setRadius(circle, r);
+
+    return circle;
+}
+
+static void Circle_free(void *ptr) {
+    sfCircleShape_destroy(ptr);
+}
+
+static VALUE Circle_new(int argc, VALUE *argv, VALUE klass) {
+    sfCircleShape *circle;
+    float radius;
+    VALUE self;
+
+    if (argc > 1) {
+        raise_invalid_arguments_excepted(1, argc);
+    }
+
+    radius = 0;
+
+    if (argc == 1) {
+        radius = NUM2DBL(argv[0]);
+    }
+
+    circle = Circle_create(radius);
+
+    self = Data_Wrap_Struct(klass, 0, Circle_free, circle);
+
+    rb_obj_call_init(self, argc, argv);
+
+    return self;
+}
+
+static VALUE Circle_init(int argc, VALUE *argv, VALUE self) {
+    return self;
+}
+
+static VALUE Circle_set_fill_color(VALUE self, VALUE rb_color) {
+    color_check(rb_color);
+
+    sfCircleShape_setFillColor(Get_Circle_Struct(self), color_new_from_rb(rb_color));
+
+    return self;
+}
+
+static VALUE Circle_get_fill_color(VALUE self) {
+    sfColor color = sfCircleShape_getFillColor(Get_Circle_Struct(self));
+
+    return color_new_from_c(color);
+}
+
+static VALUE Circle_set_radius(VALUE self, VALUE rb_radius) {
+    sfCircleShape_setRadius(Get_Circle_Struct(self), NUM2DBL(rb_radius));
+
+    return self;
+}
+
+static VALUE Circle_set_position(VALUE self, VALUE rb_position) {
+    sfCircleShape_setPosition(Get_Circle_Struct(self), vec2f_new_from_ruby(rb_position));
+
+    return self;
+}
+
+static VALUE Circle_set_rotation(VALUE self, VALUE rb_angle) {
+    sfCircleShape_setRotation(Get_Circle_Struct(self), NUM2DBL(rb_angle));
+
+    return self;
+}
+
+static VALUE Circle_set_origin(VALUE self, VALUE rb_origin) {
+    sfCircleShape_setOrigin(Get_Circle_Struct(self), vec2f_new_from_ruby(rb_origin));
+
+    return self;
+}
+
+static VALUE Circle_set_scale(VALUE self, VALUE rb_scale) {
+    sfCircleShape_setScale(Get_Circle_Struct(self), vec2f_new_from_ruby(rb_scale));
+
+    return self;
+}
+
+static VALUE Circle_get_radius(VALUE self) {
+    return DBL2NUM(sfCircleShape_getRadius(Get_Circle_Struct(self)));
+}
+
+static VALUE Circle_get_position(VALUE self) {
+    return vec2f_new_from_c(sfCircleShape_getPosition(Get_Circle_Struct(self)));
+}
+
+static VALUE Circle_get_rotation(VALUE self) {
+    return DBL2NUM(sfCircleShape_getRotation(Get_Circle_Struct(self)));
+}
+
+static VALUE Circle_get_scale(VALUE self) {
+    return vec2f_new_from_c(sfCircleShape_getPosition(Get_Circle_Struct(self)));
+}
+
+static VALUE Circle_get_origin(VALUE self) {
+    return vec2f_new_from_c(sfCircleShape_getOrigin(Get_Circle_Struct(self)));
+}
+
+static VALUE Circle_move(VALUE self, VALUE rb_move) {
+    sfCircleShape_move(Get_Circle_Struct(self), vec2f_new_from_ruby(rb_move));
+    return self;
+}
+
+static VALUE Circle_rotate(VALUE self, VALUE rb_angle) {
+    sfCircleShape_rotate(Get_Circle_Struct(self), NUM2DBL(rb_angle));
+    return self;
+}
+
+static VALUE Circle_scale(VALUE self, VALUE rb_scale) {
+    sfCircleShape_scale(Get_Circle_Struct(self), vec2f_new_from_ruby(rb_scale));
+    return self;
+}
+
+static VALUE Circle_get_matrix(VALUE self) {
+    return Transform_MatrixToArray(sfCircleShape_getTransform(Get_Circle_Struct(self)).matrix);
+}
+
+static VALUE Circle_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
+    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
+        raise_invalid_argument_class(Get_Klass_Target());
+    }
+
+    if (!rb_obj_is_kind_of(rb_target, Get_Klass_RenderState())) {
+        raise_invalid_argument_class(Get_Klass_RenderState());
+    }
+
+    sfRenderWindow_drawCircleShape(((Target *) Get_Target_Struct(rb_target))->window, Get_Circle_Struct(self),
+                                   Get_RenderState_Struct(rb_state));
+    return Qnil;
+}
+
+void Init_Circle(VALUE rb_module) {
+    rb_cCircle = rb_define_class_under(rb_module, "Circle", rb_cObject);
+
+    rb_include_module(rb_cCircle, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cCircle, "new", Circle_new, -1);
+
+    // methods
+    rb_define_method(rb_cCircle, "initialize", Circle_init, -1);
+    rb_define_method(rb_cCircle, "move", Circle_move, 1);
+    rb_define_method(rb_cCircle, "rotate", Circle_rotate, 1);
+    rb_define_method(rb_cCircle, "escalate", Circle_scale, 1);
+    rb_define_method(rb_cCircle, "draw", Circle_draw, 2);
+
+    // setters
+    rb_define_method(rb_cCircle, "radius=", Circle_set_radius, 1);
+    rb_define_method(rb_cCircle, "position=", Circle_set_position, 1);
+    rb_define_method(rb_cCircle, "angle=", Circle_set_rotation, 1);
+    rb_define_method(rb_cCircle, "scale=", Circle_set_scale, 1);
+    rb_define_method(rb_cCircle, "origin=", Circle_set_origin, 1);
+    rb_define_method(rb_cCircle, "fill_color=", Circle_set_fill_color, 1);
+
+    // getters
+    rb_define_method(rb_cCircle, "radius", Circle_get_radius, 0);
+    rb_define_method(rb_cCircle, "position", Circle_get_position, 0);
+    rb_define_method(rb_cCircle, "angle", Circle_get_rotation, 0);
+    rb_define_method(rb_cCircle, "scale", Circle_get_scale, 0);
+    rb_define_method(rb_cCircle, "origin", Circle_get_origin, 0);
+    rb_define_method(rb_cCircle, "fill_color", Circle_get_fill_color, 0);
+    rb_define_method(rb_cCircle, "matrix", Circle_get_matrix, 0);
+
+}
+
+void *Get_Circle_Struct(VALUE self) {
+    sfCircleShape *ptr;
+    Data_Get_Struct(self, sfCircleShape, ptr);
+    return ptr;
+}
+
+VALUE Get_Klass_Circle() {
+    return rb_cCircle;
+}

data/ext/clock.c

@@ -0,0 +1,65 @@
+#include "ext/klass/clock.h"
+
+#include <stdio.h>
+
+#include "ext/vec2.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+static VALUE rb_cClock;
+
+static sfClock *Clock_create() {
+    return sfClock_create();
+}
+
+static void Clock_free(void *ptr) {
+    sfClock_destroy(ptr);
+}
+
+static VALUE Clock_new(VALUE klass) {
+    sfClock *clock;
+    VALUE self;
+
+    clock = Clock_create();
+
+    self = Data_Wrap_Struct(klass, 0, Clock_free, clock);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE Clock_init(VALUE self) {
+    return self;
+}
+
+static VALUE Clock_get_elapsed_time(VALUE self) {
+    return DBL2NUM(sfTime_asSeconds(sfClock_getElapsedTime(Get_Clock_Struct(self))));
+}
+
+static VALUE Clock_restart(VALUE self) {
+    return DBL2NUM(sfTime_asSeconds(sfClock_restart(Get_Clock_Struct(self))));
+}
+
+void Init_Clock(VALUE rb_module) {
+    rb_cClock = rb_define_class_under(rb_module, "Clock", rb_cObject);
+
+    rb_define_singleton_method(rb_cClock, "new", Clock_new, 0);
+
+    // methods
+    rb_define_method(rb_cClock, "initialize", Clock_init, 0);
+    rb_define_method(rb_cClock, "restart!", Clock_restart, 0);
+
+    // getters
+    rb_define_method(rb_cClock, "elapsed_time", Clock_get_elapsed_time, 0);
+}
+
+void *Get_Clock_Struct(VALUE self) {
+    sfClock *clock;
+    Data_Get_Struct(self, sfClock, clock);
+    return clock;
+}
+
+VALUE Get_Klass_Clock() {
+    return rb_cClock;
+}

data/ext/color.c

@@ -0,0 +1,43 @@
+#include "ext/klass/color.h"
+
+#include <ruby.h>
+#include <stdio.h>
+
+#include "ext/exceptions.h"
+
+VALUE color_new(int r, int g, int b, int a) {
+    VALUE rb_arr;
+
+    rb_arr = rb_ary_new();
+
+    rb_ary_push(rb_arr, INT2NUM(r));
+    rb_ary_push(rb_arr, INT2NUM(g));
+    rb_ary_push(rb_arr, INT2NUM(b));
+    rb_ary_push(rb_arr, INT2NUM(a));
+
+    return rb_arr;
+}
+
+void color_check(VALUE rb_arr) {
+    if (rb_array_len(rb_arr) != VALID_LENGTH_COLOR) {
+        raise_invalid_array_length(VALID_LENGTH_COLOR);
+    }
+}
+
+void color_swap(sfColor *color_a, sfColor *color_b) {
+    sfColor c;
+
+    c = *color_b;
+    *color_b = *color_a;
+    *color_a = c;
+}
+
+sfColor color_new_from_rb(VALUE rb_arr) {
+    sfColor color = COLOR_RB2C(rb_arr);
+
+    return color;
+}
+
+VALUE color_new_from_c(sfColor color) {
+    return COLOR_C2RB(color);
+}

data/ext/drawable.c

@@ -0,0 +1,39 @@
+#include "ext/module/drawable/drawable.h"
+
+#include <ruby.h>
+#include <stdio.h>
+
+#include "ext/module/transform.h"
+#include "ext/klass/transformable.h"
+#include "ext/klass/render_state.h"
+#include "ext/klass/target.h"
+#include "ext/klass/window.h"
+#include <ext/exceptions.h>
+#include "ext/vec2.h"
+#include "ext/rect.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+static VALUE rb_mDrawable;
+
+static VALUE Drawable_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
+    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
+
+    }
+
+    if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
+
+    }
+
+    return Qnil;
+}
+
+void Init_Drawable(VALUE rb_module) {
+    rb_mDrawable = rb_define_module_under(rb_module, "Drawable");
+
+    rb_define_method(rb_mDrawable, "draw", Drawable_draw, 2);
+}
+
+VALUE Get_Module_Drawable() {
+    return rb_mDrawable;
+}

data/ext/event.c

@@ -0,0 +1,148 @@
+#include "ext/klass/event.h"
+
+#include <ruby.h>
+#include <stdio.h>
+
+#include "ext/klass/event/event_name.h"
+#include "ext/klass/keyboard.h"
+#include "ext/klass/video_mode.h"
+#include "ext/vec2.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+static VALUE rb_cEvent;
+
+static sfEvent *Event_create() {
+    return malloc(sizeof(sfEvent));
+}
+
+static void Event_free(void *ptr) {
+    free(ptr);
+}
+
+static VALUE Event_new(VALUE klass) {
+    VALUE self;
+    sfEvent *event;
+
+    VALUE argv[] = {};
+
+    event = Event_create();
+    self = Data_Wrap_Struct(klass, 0, Event_free, event);
+
+    rb_obj_call_init(self, 0, argv);
+
+    return self;
+}
+
+static VALUE Event_init(VALUE self) {
+    return self;
+}
+
+static VALUE Event_type(VALUE self) {
+    sfEvent *event = Get_Event_Struct(self);
+    return rb_str_new2(get_event_name(event->type));
+}
+
+static VALUE Event_key(VALUE self) {
+    VALUE arr;
+    VALUE hash;
+    sfEvent *event = Get_Event_Struct(self);
+
+    const char *key_name = get_key_event(event->key.code);
+
+    /*
+    event->key.system;
+    event->key.alt;
+    event->key.control;
+    event->key.shift;
+    */
+
+    arr = rb_ary_new();
+    rb_ary_push(arr, rb_str_new2(key_name));
+    rb_ary_push(arr, INT2NUM((int) event->key.system));
+    rb_ary_push(arr, INT2NUM((int) event->key.alt));
+    rb_ary_push(arr, INT2NUM((int) event->key.control));
+    rb_ary_push(arr, INT2NUM((int) event->key.shift));
+
+    return arr;
+}
+
+static VALUE Event_size(VALUE self) {
+    sfEvent *event = Get_Event_Struct(self);
+
+    return vec2_new(event->size.size.x, event->size.size.y);
+}
+
+static VALUE Event_text(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_mouse_move(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_mouse_button(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_mouse_wheel(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_mouse_wheel_scroll(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_joystick_move(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_joystick_button(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_joystick_connect(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_touch(VALUE self) {
+    return Qnil;
+}
+
+static VALUE Event_sensor(VALUE self) {
+    return Qnil;
+}
+
+void Init_Event(VALUE rb_module) {
+    rb_cEvent = rb_define_class_under(rb_module, "Event", rb_cObject);
+
+    rb_define_singleton_method(rb_cEvent, "new", Event_new, 0);
+
+    // methods
+    rb_define_method(rb_cEvent, "initialize", Event_init, 0);
+
+    // getters
+    rb_define_method(rb_cEvent, "type", Event_type, 0);
+    rb_define_method(rb_cEvent, "key", Event_key, 0);
+    rb_define_method(rb_cEvent, "size", Event_size, 0);
+    rb_define_method(rb_cEvent, "text", Event_text, 0);
+    rb_define_method(rb_cEvent, "mouse_move", Event_mouse_move, 0);
+    rb_define_method(rb_cEvent, "mouse_button", Event_mouse_button, 0);
+    rb_define_method(rb_cEvent, "mouse_wheel", Event_mouse_wheel, 0);
+    rb_define_method(rb_cEvent, "mouse_wheel_scroll", Event_mouse_wheel_scroll, 0);
+    rb_define_method(rb_cEvent, "joystick_move", Event_joystick_move, 0);
+    rb_define_method(rb_cEvent, "joystick_button", Event_joystick_button, 0);
+    rb_define_method(rb_cEvent, "joystick_connect", Event_joystick_connect, 0);
+    rb_define_method(rb_cEvent, "touch", Event_touch, 0);
+    rb_define_method(rb_cEvent, "sensor", Event_sensor, 0);
+}
+
+void *Get_Event_Struct(VALUE self) {
+    sfEvent *ptr;
+    Data_Get_Struct(self, sfEvent, ptr);
+    return ptr;
+}
+
+VALUE Get_Klass_Event() {
+    return rb_cEvent;
+}

data/ext/event_name.c

@@ -0,0 +1,45 @@
+#include "ext/klass/event/event_name.h"
+
+#include <stddef.h>
+
+#include "ext/sfml.h"
+
+/* Indexed by sfEventType rather than by position. The CSFML 2.x table was
+   positional, which broke silently under CSFML 3: the enum still has 24
+   entries, but MouseWheelMoved was removed and MouseMovedRaw added, shifting
+   every name from index 7 onward without any bounds error. */
+static const char *events[] = {
+        [sfEvtClosed] = "closed",
+        [sfEvtResized] = "resized",
+        [sfEvtFocusLost] = "lost-focus",
+        [sfEvtFocusGained] = "gained-focus",
+        [sfEvtTextEntered] = "text-entered",
+        [sfEvtKeyPressed] = "key-pressed",
+        [sfEvtKeyReleased] = "key-released",
+        [sfEvtMouseWheelScrolled] = "mouse-wheel-scrolled",
+        [sfEvtMouseButtonPressed] = "mouse-button-pressed",
+        [sfEvtMouseButtonReleased] = "mouse-button-released",
+        [sfEvtMouseMoved] = "mouse-moved",
+        [sfEvtMouseMovedRaw] = "mouse-moved-raw",
+        [sfEvtMouseEntered] = "mouse-entered",
+        [sfEvtMouseLeft] = "mouse-left",
+        [sfEvtJoystickButtonPressed] = "joystick-button-pressed",
+        [sfEvtJoystickButtonReleased] = "joystick-button-released",
+        [sfEvtJoystickMoved] = "joystick-moved",
+        [sfEvtJoystickConnected] = "joystick-connected",
+        [sfEvtJoystickDisconnected] = "joystick-disconnected",
+        [sfEvtTouchBegan] = "touch-began",
+        [sfEvtTouchMoved] = "touch-moved",
+        [sfEvtTouchEnded] = "touch-ended",
+        [sfEvtSensorChanged] = "sensor-changed"
+};
+
+#define LENGTH_EVENTS (sizeof(events) / sizeof(events[0]))
+
+const char *get_event_name(size_t name) {
+    if (name < LENGTH_EVENTS && events[name] != NULL) {
+        return events[name];
+    }
+
+    return "";
+}