Update CBindings

8 files changed, 767 insertions, 11 deletions

diff --git a/core/bindings/lang/clang/headers/nogamepads.h b/core/bindings/lang/clang/headers/nogamepads.h
index f1ac85a..3242a44 100644
--- a/core/bindings/lang/clang/headers/nogamepads.h
+++ b/core/bindings/lang/clang/headers/nogamepads.h
@@ -1,4 +1,4 @@
-// 自动生成的头文件 - 请勿手动编辑
+// Auto generated by cbindgen 0.29.0
 
 #ifndef NOGAMEPADS_H
 #define NOGAMEPADS_H
@@ -8,6 +8,59 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+typedef enum FfiConnectionMessageTag {
+  Join,
+  RequestGameInfos,
+  RequestLayoutConfigure,
+  RequestSkinPackage,
+  Ready,
+  Err,
+} FfiConnectionMessageTag;
+
+typedef enum FfiConnectionResponseMessageTag {
+  GameInfos,
+  Deny,
+  Fail,
+  Ok,
+  Welcome,
+  Err,
+} FfiConnectionResponseMessageTag;
+
+typedef enum FfiControlMessageTag {
+  Msg,
+  Pressed,
+  Released,
+  Axis,
+  Dir,
+  Exit,
+  Err,
+  End,
+} FfiControlMessageTag;
+
+typedef enum FfiExitReason {
+  Exit,
+  GameOver,
+  ServerClosed,
+  YouAreKicked,
+  YouAreBanned,
+  Err,
+} FfiExitReason;
+
+typedef enum FfiGameMessageTag {
+  EventTrigger,
+  Msg,
+  LetExit,
+  Err,
+  End,
+} FfiGameMessageTag;
+
+typedef enum FfiJoinFailedMessage {
+  ContainIdenticalPlayer,
+  PlayerBanned,
+  GameLocked,
+  UnknownError,
+} FfiJoinFailedMessage;
+
 typedef struct FfiAccount {
   char *id;
   char *player_hash;
@@ -25,10 +78,76 @@ typedef struct FfiPlayer {
   struct FfiCustomize *customize;
 } FfiPlayer;
 
+typedef struct FfiKeyAndAxis {
+  uint8_t key;
+  double axis;
+} FfiKeyAndAxis;
+
+typedef struct FfiKeyAndDirection {
+  uint8_t key;
+  double x;
+  double y;
+} FfiKeyAndDirection;
+
+typedef union FfiControlMessageUnion {
+  char *message;
+  uint8_t key;
+  struct FfiKeyAndAxis key_and_axis;
+  struct FfiKeyAndDirection key_and_direction;
+} FfiControlMessageUnion;
+
+typedef struct FfiControlMessage {
+  enum FfiControlMessageTag tag;
+  union FfiControlMessageUnion data;
+} FfiControlMessage;
+
+typedef union FfiGameMessageUnion {
+  uint8_t key;
+  char *message;
+  enum FfiExitReason exit_reason;
+} FfiGameMessageUnion;
+
+typedef struct FfiGameMessage {
+  enum FfiGameMessageTag tag;
+  union FfiGameMessageUnion data;
+} FfiGameMessage;
+
+typedef union FfiConnectionMessageUnion {
+  struct FfiPlayer player;
+} FfiConnectionMessageUnion;
+
+typedef struct FfiConnectionMessage {
+  enum FfiConnectionMessageTag tag;
+  union FfiConnectionMessageUnion data;
+} FfiConnectionMessage;
+
+typedef struct KeyValuePair {
+  char *key;
+  char *value;
+} KeyValuePair;
+
+typedef struct FfiGameInfo {
+  struct KeyValuePair *data;
+  uintptr_t len;
+  uintptr_t cap;
+} FfiGameInfo;
+
+typedef union FfiConnectionResponseMessageUnion {
+  struct FfiGameInfo game_info;
+  enum FfiJoinFailedMessage failed_message;
+} FfiConnectionResponseMessageUnion;
+
+typedef struct FfiConnectionResponseMessage {
+  enum FfiConnectionResponseMessageTag tag;
+  union FfiConnectionResponseMessageUnion data;
+} FfiConnectionResponseMessage;
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
+ngp_ void free_c_string(char *ptr);
+
 ngp_ struct FfiPlayer *player_register(const char *id, const char *password);
 
 ngp_ bool player_check(const struct FfiPlayer *player, const char *password);
@@ -41,6 +160,20 @@ ngp_ void player_set_hsv(struct FfiPlayer *player, int hue, double saturation, d
 
 ngp_ void player_free(struct FfiPlayer *player);
 
+ngp_ void free_control_message(struct FfiControlMessage msg);
+
+ngp_ void free_game_message(struct FfiGameMessage msg);
+
+ngp_ void free_exit_reason(enum FfiExitReason msg);
+
+ngp_ void free_connection_message(struct FfiConnectionMessage msg);
+
+ngp_ void free_connection_response_message(struct FfiConnectionResponseMessage msg);
+
+ngp_ void free_join_failed_message(enum FfiJoinFailedMessage msg);
+
+ngp_ void free_game_info(struct FfiGameInfo map);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus
diff --git a/core/bindings/lang/clang/src/converter/mod.rs b/core/bindings/lang/clang/src/converter/mod.rs
new file mode 100644
index 0000000..86708b0
--- /dev/null
+++ b/core/bindings/lang/clang/src/converter/mod.rs
@@ -0,0 +1 @@
+pub mod string_converter;
\ No newline at end of file
diff --git a/core/bindings/lang/clang/src/converter/string_converter.rs b/core/bindings/lang/clang/src/converter/string_converter.rs
new file mode 100644
index 0000000..7345f5a
--- /dev/null
+++ b/core/bindings/lang/clang/src/converter/string_converter.rs
@@ -0,0 +1,24 @@
+use std::ffi::{c_char, CStr, CString};
+
+pub unsafe fn str_rs_to_c(content: String) -> *mut c_char {
+    let c_str = CString::new(content).expect("CString::new failed");
+
+    c_str.into_raw()
+}
+
+pub unsafe fn str_c_to_rs(content_ptr: *mut c_char) -> String {
+    let c_str = unsafe { CStr::from_ptr(content_ptr) };
+
+    c_str.to_str()
+        .expect("Invalid UTF-8 sequence")
+        .to_owned()
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_c_string(ptr: *mut c_char) {
+    if ptr.is_null() {
+        return;
+    }
+
+    let _ = unsafe { CString::from_raw(ptr) };
+}
\ No newline at end of file
diff --git a/core/bindings/lang/clang/src/data/mod.rs b/core/bindings/lang/clang/src/data/mod.rs
index 32af6d8..c93e7f0 100644
--- a/core/bindings/lang/clang/src/data/mod.rs
+++ b/core/bindings/lang/clang/src/data/mod.rs
@@ -1 +1,3 @@
-pub mod ngpd_player;
\ No newline at end of file
+pub mod ngpd_player;
+pub mod ngpd_message;
+mod ngpd_game_info;
\ No newline at end of file
diff --git a/core/bindings/lang/clang/src/data/ngpd_game_info.rs b/core/bindings/lang/clang/src/data/ngpd_game_info.rs
new file mode 100644
index 0000000..af45758
--- /dev/null
+++ b/core/bindings/lang/clang/src/data/ngpd_game_info.rs
@@ -0,0 +1,109 @@
+use std::collections::HashMap;
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
+
+#[repr(C)]
+pub struct KeyValuePair {
+    key: *mut c_char,
+    value: *mut c_char,
+}
+
+#[repr(C)]
+pub struct FfiGameInfo {
+    data: *mut KeyValuePair,
+    len: usize,
+    cap: usize,
+}
+
+impl From<&HashMap<String, String>> for FfiGameInfo {
+    fn from(map: &HashMap<String, String>) -> Self {
+        let mut kv_pairs: Vec<KeyValuePair> = map
+            .into_iter()
+            .map(|(k, v)| {
+                KeyValuePair {
+                    key: CString::new(k.clone()).unwrap().into_raw(),
+                    value: CString::new(v.clone()).unwrap().into_raw(),
+                }
+            })
+            .collect();
+
+        let cap = kv_pairs.capacity();
+        let len = kv_pairs.len();
+        let data_ptr = kv_pairs.as_mut_ptr();
+
+        std::mem::forget(kv_pairs);
+
+        FfiGameInfo {
+            data: data_ptr,
+            len,
+            cap,
+        }
+    }
+}
+
+impl TryFrom<&FfiGameInfo> for HashMap<String, String> {
+    type Error = String;
+
+    fn try_from(ffi_info: &FfiGameInfo) -> Result<Self, Self::Error> {
+        if ffi_info.len == 0 {
+            return Ok(HashMap::new());
+        }
+
+        if ffi_info.data.is_null() {
+            return Err("FfiGameInfo data pointer is null".to_string());
+        }
+
+        let kv_slice = unsafe {
+            std::slice::from_raw_parts(ffi_info.data, ffi_info.len)
+        };
+
+        let mut map = HashMap::with_capacity(ffi_info.len);
+
+        for (i, pair) in kv_slice.iter().enumerate() {
+            if pair.key.is_null() {
+                return Err(format!("Key pointer is null at index {}", i));
+            }
+
+            if pair.value.is_null() {
+                return Err(format!("Value pointer is null at index {}", i));
+            }
+
+            let key_str = unsafe {
+                CStr::from_ptr(pair.key)
+                    .to_str()
+                    .map_err(|_| "Invalid UTF-8 in key")?
+            };
+
+            let value_str = unsafe {
+                CStr::from_ptr(pair.value)
+                    .to_str()
+                    .map_err(|_| "Invalid UTF-8 in value")?
+            };
+
+            map.insert(key_str.to_owned(), value_str.to_owned());
+        }
+
+        Ok(map)
+    }
+}
+
+impl From<&FfiGameInfo> for Option<HashMap<String, String>> {
+    fn from(ffi_info: &FfiGameInfo) -> Self {
+        match HashMap::try_from(ffi_info) {
+            Ok(map) => Some(map),
+            Err(_) => None,
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_game_info(map: FfiGameInfo) {
+    let kv_pairs = unsafe { Vec::from_raw_parts(map.data, map.len, map.cap) };
+
+    for pair in kv_pairs {
+        unsafe {
+            let _ = CString::from_raw(pair.key);
+            let _ = CString::from_raw(pair.value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/core/bindings/lang/clang/src/data/ngpd_message.rs b/core/bindings/lang/clang/src/data/ngpd_message.rs
new file mode 100644
index 0000000..c669299
--- /dev/null
+++ b/core/bindings/lang/clang/src/data/ngpd_message.rs
@@ -0,0 +1,486 @@
+use crate::converter::string_converter::{str_c_to_rs, str_rs_to_c};
+use crate::data::ngpd_game_info::FfiGameInfo;
+use crate::data::ngpd_player::FfiPlayer;
+use nogamepads_core::data::message::message_enums::{ConnectionMessage, ConnectionResponseMessage, ControlMessage, ExitReason, GameMessage, JoinFailedMessage};
+use std::mem::ManuallyDrop;
+use std::ops::Deref;
+use std::os::raw::{c_char, c_double};
+
+#[repr(C)]
+pub struct FfiControlMessage {
+    pub tag: FfiControlMessageTag,
+    pub data: FfiControlMessageUnion
+}
+
+#[repr(C)]
+pub enum FfiControlMessageTag {
+    Msg, Pressed, Released, Axis, Dir, Exit, Err, End
+}
+
+#[repr(C)]
+pub union FfiControlMessageUnion {
+    pub none: (),
+    pub message: *mut c_char,
+    pub key: u8,
+    pub key_and_axis: ManuallyDrop<FfiKeyAndAxis>,
+    pub key_and_direction: ManuallyDrop<FfiKeyAndDirection>,
+}
+
+#[repr(C)]
+pub struct FfiKeyAndAxis {
+    pub key: u8,
+    pub axis: c_double
+}
+
+#[repr(C)]
+pub struct FfiKeyAndDirection {
+    pub key: u8,
+    pub x: c_double,
+    pub y: c_double
+}
+
+#[repr(C)]
+pub struct FfiGameMessage {
+    pub tag: FfiGameMessageTag,
+    pub data: FfiGameMessageUnion
+}
+
+#[repr(C)]
+pub enum FfiGameMessageTag {
+    EventTrigger, Msg, LetExit, Err, End
+}
+
+#[repr(C)]
+pub union FfiGameMessageUnion {
+    pub none: (),
+    pub key: u8,
+    pub message: *mut c_char,
+    pub exit_reason: ManuallyDrop<FfiExitReason>,
+}
+
+#[repr(C)]
+pub enum FfiExitReason {
+    Exit, GameOver, ServerClosed, YouAreKicked, YouAreBanned, Err
+}
+
+#[repr(C)]
+pub struct FfiConnectionMessage {
+    pub tag: FfiConnectionMessageTag,
+    pub data: FfiConnectionMessageUnion
+}
+
+#[repr(C)]
+pub enum FfiConnectionMessageTag {
+    Join, RequestGameInfos, RequestLayoutConfigure, RequestSkinPackage, Ready, Err
+}
+
+#[repr(C)]
+pub union FfiConnectionMessageUnion {
+    pub none: (),
+    pub player: ManuallyDrop<FfiPlayer>
+}
+
+#[repr(C)]
+pub struct FfiConnectionResponseMessage {
+    pub tag: FfiConnectionResponseMessageTag,
+    pub data: FfiConnectionResponseMessageUnion
+}
+
+#[repr(C)]
+pub enum FfiConnectionResponseMessageTag {
+    GameInfos, Deny, Fail, Ok, Welcome, Err
+}
+
+#[repr(C)]
+pub union FfiConnectionResponseMessageUnion {
+    pub none: (),
+    pub game_info: ManuallyDrop<FfiGameInfo>,
+    pub failed_message: ManuallyDrop<FfiJoinFailedMessage>
+}
+
+#[repr(C)]
+pub enum FfiJoinFailedMessage {
+    ContainIdenticalPlayer, PlayerBanned, GameLocked, UnknownError
+}
+
+impl From<ControlMessage> for FfiControlMessage {
+    fn from(value: ControlMessage) -> Self {
+        match value {
+            ControlMessage::Msg(msg) => unsafe {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Msg,
+                    data: FfiControlMessageUnion {
+                        message: str_rs_to_c(msg),
+                    }
+                }
+            }
+            ControlMessage::Pressed(key) => {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Pressed,
+                    data: FfiControlMessageUnion {
+                        key: key.into()
+                    }
+                }
+            }
+            ControlMessage::Released(key) => {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Released,
+                    data: FfiControlMessageUnion {
+                        key: key.into()
+                    }
+                }
+            }
+            ControlMessage::Axis(key, axis) => {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Axis,
+                    data: FfiControlMessageUnion {
+                        key_and_axis: ManuallyDrop::new(FfiKeyAndAxis {
+                            key: key.into(),
+                            axis: axis.into()
+                        })
+                    }
+                }
+            }
+            ControlMessage::Dir(key, (x, y)) => {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Axis,
+                    data: FfiControlMessageUnion {
+                        key_and_direction: ManuallyDrop::new(FfiKeyAndDirection {
+                            key: key.into(),
+                            x, y
+                        })
+                    }
+                }
+            }
+            ControlMessage::Exit => {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Axis,
+                    data: FfiControlMessageUnion { none: () }
+                }
+            }
+            ControlMessage::Err => {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Axis,
+                    data: FfiControlMessageUnion { none: () }
+                }
+            }
+            ControlMessage::End => {
+                FfiControlMessage {
+                    tag: FfiControlMessageTag::Axis,
+                    data: FfiControlMessageUnion { none: () }
+                }
+            }
+        }
+    }
+}
+
+impl From<FfiControlMessage> for ControlMessage {
+    fn from(value: FfiControlMessage) -> Self {
+        match value.tag {
+            FfiControlMessageTag::Msg => unsafe {
+                ControlMessage::Msg(str_c_to_rs(value.data.message))
+            }
+            FfiControlMessageTag::Pressed => unsafe {
+                ControlMessage::Pressed(value.data.key.into())
+            }
+            FfiControlMessageTag::Released => unsafe {
+                ControlMessage::Released(value.data.key.into())
+            }
+            FfiControlMessageTag::Axis => {
+                let value = unsafe { value.data.key_and_axis };
+                ControlMessage::Axis(value.key.into(), value.axis.into())
+            }
+            FfiControlMessageTag::Dir => {
+                let value = unsafe { value.data.key_and_direction };
+                ControlMessage::Dir(value.key.into(), (value.x.into(), value.y.into()))
+            }
+            FfiControlMessageTag::Exit => {
+                ControlMessage::Exit
+            }
+            FfiControlMessageTag::Err => {
+                ControlMessage::Err
+            }
+            FfiControlMessageTag::End => {
+                ControlMessage::End
+            }
+        }
+    }
+}
+
+impl From<GameMessage> for FfiGameMessage {
+    fn from(value: GameMessage) -> Self {
+        match value {
+            GameMessage::EventTrigger(key) => {
+                FfiGameMessage {
+                    tag: FfiGameMessageTag::EventTrigger,
+                    data: FfiGameMessageUnion {
+                        key: key.into()
+                    }
+                }
+            }
+            GameMessage::Msg(msg) => unsafe {
+                FfiGameMessage {
+                    tag: FfiGameMessageTag::Msg,
+                    data: FfiGameMessageUnion {
+                        message: str_rs_to_c(msg)
+                    }
+                }
+            }
+            GameMessage::LetExit(reason) => {
+                FfiGameMessage {
+                    tag: FfiGameMessageTag::LetExit,
+                    data: FfiGameMessageUnion {
+                        exit_reason: ManuallyDrop::new(FfiExitReason::from(&reason))
+                    }
+                }
+            }
+            GameMessage::Err => {
+                FfiGameMessage {
+                    tag: FfiGameMessageTag::Err,
+                    data: FfiGameMessageUnion { none: () }
+                }
+            }
+            GameMessage::End => {
+                FfiGameMessage {
+                    tag: FfiGameMessageTag::End,
+                    data: FfiGameMessageUnion { none: () }
+                }
+            }
+        }
+    }
+}
+
+impl From<FfiGameMessage> for GameMessage {
+    fn from(value: FfiGameMessage) -> Self {
+        match value.tag {
+            FfiGameMessageTag::EventTrigger => unsafe {
+                GameMessage::EventTrigger(value.data.key.into())
+            }
+            FfiGameMessageTag::Msg => unsafe {
+                GameMessage::Msg(str_c_to_rs(value.data.message))
+            }
+            FfiGameMessageTag::LetExit => unsafe {
+                GameMessage::LetExit(value.data.exit_reason.deref().into())
+            }
+            FfiGameMessageTag::Err => {
+                GameMessage::Err
+            }
+            FfiGameMessageTag::End => {
+                GameMessage::End
+            }
+        }
+    }
+}
+
+impl From<&ExitReason> for FfiExitReason {
+    fn from(value: &ExitReason) -> Self {
+        match value {
+            ExitReason::Exit => { FfiExitReason::Exit }
+            ExitReason::GameOver => { FfiExitReason::GameOver }
+            ExitReason::ServerClosed => { FfiExitReason::ServerClosed }
+            ExitReason::YouAreKicked => { FfiExitReason::YouAreKicked }
+            ExitReason::YouAreBanned => { FfiExitReason::YouAreBanned }
+            ExitReason::Err => { FfiExitReason::Err }
+        }
+    }
+}
+
+impl From<&FfiExitReason> for ExitReason {
+    fn from(value: &FfiExitReason) -> Self {
+        match value {
+            FfiExitReason::Exit => { ExitReason::Exit }
+            FfiExitReason::GameOver => { ExitReason::GameOver }
+            FfiExitReason::ServerClosed => { ExitReason::ServerClosed }
+            FfiExitReason::YouAreKicked => { ExitReason::YouAreKicked }
+            FfiExitReason::YouAreBanned => { ExitReason::YouAreBanned }
+            FfiExitReason::Err => { ExitReason::Err }
+        }
+    }
+}
+
+impl From<ConnectionMessage> for FfiConnectionMessage {
+    fn from(value: ConnectionMessage) -> Self {
+        match value {
+            ConnectionMessage::Join(player) => {
+                let c_player : FfiPlayer = (&player).into();
+                FfiConnectionMessage {
+                    tag: FfiConnectionMessageTag::Join,
+                    data: FfiConnectionMessageUnion {
+                        player: ManuallyDrop::new(c_player),
+                    }
+                }
+            }
+            ConnectionMessage::RequestGameInfos => {
+                FfiConnectionMessage {
+                    tag: FfiConnectionMessageTag::RequestGameInfos,
+                    data: FfiConnectionMessageUnion { none: () }
+                }
+            }
+            ConnectionMessage::RequestLayoutConfigure => {
+                FfiConnectionMessage {
+                    tag: FfiConnectionMessageTag::RequestLayoutConfigure,
+                    data: FfiConnectionMessageUnion { none: () }
+                }
+            }
+            ConnectionMessage::RequestSkinPackage => {
+                FfiConnectionMessage {
+                    tag: FfiConnectionMessageTag::RequestSkinPackage,
+                    data: FfiConnectionMessageUnion { none: () }
+                }
+            }
+            ConnectionMessage::Ready => {
+                FfiConnectionMessage {
+                    tag: FfiConnectionMessageTag::Ready,
+                    data: FfiConnectionMessageUnion { none: () }
+                }
+            }
+            ConnectionMessage::Err => {
+                FfiConnectionMessage {
+                    tag: FfiConnectionMessageTag::Err,
+                    data: FfiConnectionMessageUnion { none: () }
+                }
+            }
+        }
+    }
+}
+
+impl From<FfiConnectionMessage> for ConnectionMessage {
+    fn from(value: FfiConnectionMessage) -> Self {
+        match value.tag {
+            FfiConnectionMessageTag::Join => unsafe {
+                ConnectionMessage::Join(value.data.player.deref().try_into().unwrap_or_default())
+            }
+            FfiConnectionMessageTag::RequestGameInfos => { ConnectionMessage::RequestGameInfos }
+            FfiConnectionMessageTag::RequestLayoutConfigure => { ConnectionMessage::RequestLayoutConfigure }
+            FfiConnectionMessageTag::RequestSkinPackage => { ConnectionMessage::RequestSkinPackage }
+            FfiConnectionMessageTag::Ready => { ConnectionMessage::Ready }
+            FfiConnectionMessageTag::Err => { ConnectionMessage::Err }
+        }
+    }
+}
+
+impl From<ConnectionResponseMessage> for FfiConnectionResponseMessage {
+    fn from(value: ConnectionResponseMessage) -> Self {
+        match value {
+            ConnectionResponseMessage::GameInfos(info) => {
+                FfiConnectionResponseMessage {
+                    tag: FfiConnectionResponseMessageTag::GameInfos,
+                    data: FfiConnectionResponseMessageUnion {
+                        game_info: ManuallyDrop::new((&info).into())
+                    }
+                }
+            }
+            ConnectionResponseMessage::Deny(fail) => {
+                FfiConnectionResponseMessage {
+                    tag: FfiConnectionResponseMessageTag::Deny,
+                    data: FfiConnectionResponseMessageUnion {
+                        failed_message: ManuallyDrop::new((&fail).into())
+                    }
+                }
+            }
+            ConnectionResponseMessage::Fail(fail) => {
+                FfiConnectionResponseMessage {
+                    tag: FfiConnectionResponseMessageTag::Fail,
+                    data: FfiConnectionResponseMessageUnion {
+                        failed_message: ManuallyDrop::new((&fail).into())
+                    }
+                }
+            }
+            ConnectionResponseMessage::Ok => {
+                FfiConnectionResponseMessage {
+                    tag: FfiConnectionResponseMessageTag::Ok,
+                    data: FfiConnectionResponseMessageUnion { none: () }
+                }
+            }
+            ConnectionResponseMessage::Welcome => {
+                FfiConnectionResponseMessage {
+                    tag: FfiConnectionResponseMessageTag::Welcome,
+                    data: FfiConnectionResponseMessageUnion { none: () }
+                }
+            }
+            ConnectionResponseMessage::Err => {
+                FfiConnectionResponseMessage {
+                    tag: FfiConnectionResponseMessageTag::Err,
+                    data: FfiConnectionResponseMessageUnion { none: () }
+                }
+            }
+        }
+    }
+}
+
+impl From<FfiConnectionResponseMessage> for ConnectionResponseMessage {
+    fn from(value: FfiConnectionResponseMessage) -> Self {
+        match value.tag {
+            FfiConnectionResponseMessageTag::GameInfos => unsafe {
+                ConnectionResponseMessage::GameInfos(value.data.game_info.deref().try_into().unwrap_or_default())
+            }
+            FfiConnectionResponseMessageTag::Deny => unsafe {
+                ConnectionResponseMessage::Deny(value.data.failed_message.deref().try_into().unwrap_or_default())
+            }
+            FfiConnectionResponseMessageTag::Fail => unsafe {
+                ConnectionResponseMessage::Fail(value.data.failed_message.deref().try_into().unwrap_or_default())
+            }
+            FfiConnectionResponseMessageTag::Ok => {
+                ConnectionResponseMessage::Ok
+            }
+            FfiConnectionResponseMessageTag::Welcome => {
+                ConnectionResponseMessage::Welcome
+            }
+            FfiConnectionResponseMessageTag::Err => {
+                ConnectionResponseMessage::Err
+            }
+        }
+    }
+}
+
+impl From<&JoinFailedMessage> for FfiJoinFailedMessage {
+    fn from(value: &JoinFailedMessage) -> Self {
+        match value {
+            JoinFailedMessage::ContainIdenticalPlayer => { FfiJoinFailedMessage::ContainIdenticalPlayer }
+            JoinFailedMessage::PlayerBanned => { FfiJoinFailedMessage::PlayerBanned }
+            JoinFailedMessage::GameLocked => { FfiJoinFailedMessage::GameLocked }
+            JoinFailedMessage::UnknownError => { FfiJoinFailedMessage::UnknownError }
+        }
+    }
+}
+
+impl From<&FfiJoinFailedMessage> for JoinFailedMessage {
+    fn from(value: &FfiJoinFailedMessage) -> Self {
+        match value {
+            FfiJoinFailedMessage::ContainIdenticalPlayer => { JoinFailedMessage::ContainIdenticalPlayer }
+            FfiJoinFailedMessage::PlayerBanned => { JoinFailedMessage::PlayerBanned }
+            FfiJoinFailedMessage::GameLocked => { JoinFailedMessage::GameLocked }
+            FfiJoinFailedMessage::UnknownError => { JoinFailedMessage::UnknownError }
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn free_control_message(msg: FfiControlMessage) {
+    let _ = msg;
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn free_game_message(msg: FfiGameMessage) {
+    let _ = msg;
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn free_exit_reason(msg: FfiExitReason) {
+    let _ = msg;
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn free_connection_message(msg: FfiConnectionMessage) {
+    let _ = msg;
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn free_connection_response_message(msg: FfiConnectionResponseMessage) {
+    let _ = msg;
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn free_join_failed_message(msg: FfiJoinFailedMessage) {
+    let _ = msg;
+}
\ No newline at end of file
diff --git a/core/bindings/lang/clang/src/data/ngpd_player.rs b/core/bindings/lang/clang/src/data/ngpd_player.rs
index 2ab615c..a1a8370 100644
--- a/core/bindings/lang/clang/src/data/ngpd_player.rs
+++ b/core/bindings/lang/clang/src/data/ngpd_player.rs
@@ -32,10 +32,10 @@ impl From<Account> for FfiAccount {
     }
 }
 
-impl From<Player> for FfiPlayer {
-    fn from(player: Player) -> Self {
-        let account = FfiAccount::from(player.account);
-        let customize = player.customize.map(|c| {
+impl From<&Player> for FfiPlayer {
+    fn from(player: &Player) -> Self {
+        let account = FfiAccount::from(player.account.clone());
+        let customize = player.clone().customize.map(|c| {
             Box::into_raw(Box::new(FfiCustomize {
                 nickname: CString::new(c.nickname).unwrap().into_raw(),
                 color_hue: c.color_hue,
@@ -79,7 +79,7 @@ pub extern "C" fn player_register(id: *const c_char, password: *const c_char) ->
     let pass_str = unsafe { CStr::from_ptr(password) }.to_string_lossy();
 
     let player = Player::register(id_str.into_owned(), pass_str.into_owned());
-    Box::into_raw(Box::new(FfiPlayer::from(player)))
+    Box::into_raw(Box::new(FfiPlayer::from(&player)))
 }
 
 #[unsafe(no_mangle)]
@@ -98,7 +98,7 @@ pub extern "C" fn player_set_nickname(player: *mut FfiPlayer, nickname: *const c
     let mut rust_player : Player = unsafe { (&*player).try_into().unwrap() };
 
     rust_player.nickname(&nickname_str);
-    *unsafe { &mut *player } = FfiPlayer::from(rust_player);
+    *unsafe { &mut *player } = FfiPlayer::from(&rust_player);
 }
 
 #[unsafe(no_mangle)]
@@ -106,7 +106,7 @@ pub extern "C" fn player_set_hue(player: *mut FfiPlayer, hue: c_int) {
     let mut rust_player : Player = unsafe { (&*player).try_into().unwrap() };
 
     rust_player.hue(hue);
-    *unsafe { &mut *player } = FfiPlayer::from(rust_player);
+    *unsafe { &mut *player } = FfiPlayer::from(&rust_player);
 }
 
 #[unsafe(no_mangle)]
@@ -116,7 +116,7 @@ pub extern "C" fn player_set_hsv(
     let mut rust_player : Player = unsafe { (&*player).try_into().unwrap() };
 
     rust_player.hsv(hue, saturation, value);
-    *unsafe { &mut *player } = FfiPlayer::from(rust_player);
+    *unsafe { &mut *player } = FfiPlayer::from(&rust_player);
 }
 
 #[unsafe(no_mangle)]
diff --git a/core/bindings/lang/clang/src/lib.rs b/core/bindings/lang/clang/src/lib.rs
index 12e35bb..9a8fe37 100644
--- a/core/bindings/lang/clang/src/lib.rs
+++ b/core/bindings/lang/clang/src/lib.rs
@@ -1 +1,2 @@
-pub mod data;
\ No newline at end of file
+pub mod converter;
+pub mod data;