diff --git a/entities/entity.h b/entities/entity.h
index c506482..2914258 100644
--- a/entities/entity.h
+++ b/entities/entity.h
@@ -29,7 +29,6 @@ SOFTWARE.
 #include "core/string/ustring.h"
 #include "core/templates/vector.h"
 
-
 #include "scene/main/multiplayer_peer.h"
 
 #include "scene/main/node.h"
@@ -39,8 +38,8 @@ SOFTWARE.
 #include "../data/spells/spell.h"
 
 #include "core/io/json.h"
-#include "core/math/transform_3d.h"
 #include "core/math/transform_2d.h"
+#include "core/math/transform_3d.h"
 
 #include "../data/spells/spell.h"
 #include "./resources/entity_resource.h"
@@ -137,99 +136,135 @@ struct EntityStat {
 #define SET_RPC_PUPPETSYNC(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_PUPPETSYNC);
 
 // f.e.   RPC(method, arg0, arg1, etc)
-#define RPC(func, ...)                                                                           \
-	if (is_inside_tree() && get_tree()->has_network_peer() && get_tree()->is_network_server()) { \
-		rpc(#func, ##__VA_ARGS__);                                                               \
-	}                                                                                            \
+#define RPC(func, ...)                                                      \
+	{                                                                       \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();           \
+		if (_multiplayer_api.is_valid() && _multiplayer_api->is_server()) { \
+			rpc(#func, ##__VA_ARGS__);                                      \
+		}                                                                   \
+	}                                                                       \
 	func(__VA_ARGS__);
 
-#define VRPC(func, ...)                                                                          \
-	if (is_inside_tree() && get_tree()->has_network_peer() && get_tree()->is_network_server()) { \
-		vrpc(#func, ##__VA_ARGS__);                                                              \
-	}                                                                                            \
+#define VRPC(func, ...)                                                     \
+	{                                                                       \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();           \
+		if (_multiplayer_api.is_valid() && _multiplayer_api->is_server()) { \
+			vrpc(#func, ##__VA_ARGS__);                                     \
+		}                                                                   \
+	}                                                                       \
 	func(__VA_ARGS__);
 
-#define ORPC(func, ...)                                             \
-	if (is_inside_tree() && get_tree()->has_network_peer()) {       \
-		if (get_tree()->is_network_server()) {                      \
-			if (get_network_master() != 1) {                        \
-				rpc_id(get_network_master(), #func, ##__VA_ARGS__); \
-			} else {                                                \
-				func(__VA_ARGS__);                                  \
-			}                                                       \
-		}                                                           \
-	} else {                                                        \
-		func(__VA_ARGS__);                                          \
+#define ORPC(func, ...)                                                        \
+	{                                                                          \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();              \
+		if (_multiplayer_api.is_valid()) {                                     \
+			if (_multiplayer_api->is_server()) {                               \
+				if (get_multiplayer_authority() != 1) {                        \
+					rpc_id(get_multiplayer_authority(), #func, ##__VA_ARGS__); \
+				} else {                                                       \
+					func(__VA_ARGS__);                                         \
+				}                                                              \
+			}                                                                  \
+		} else {                                                               \
+			func(__VA_ARGS__);                                                 \
+		}                                                                      \
 	}
 
-#define RPCS(func, ...)                                       \
-	if (is_inside_tree() && get_tree()->has_network_peer()) { \
-		if (get_tree()->is_network_server()) {                \
-			func(__VA_ARGS__);                                \
-		} else {                                              \
-			rpc_id(1, #func, ##__VA_ARGS__);                  \
-		}                                                     \
-	} else {                                                  \
-		func(__VA_ARGS__);                                    \
+#define RPCS(func, ...)                                           \
+	{                                                             \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer(); \
+		if (_multiplayer_api.is_valid()) {                        \
+			if (_multiplayer_api->is_server()) {                  \
+				func(__VA_ARGS__);                                \
+			} else {                                              \
+				rpc_id(1, #func, ##__VA_ARGS__);                  \
+			}                                                     \
+		} else {                                                  \
+			func(__VA_ARGS__);                                    \
+		}                                                         \
 	}
 
 //RPC Objects
 
-#define RPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var)      \
-	if (is_inside_tree() && get_tree()->has_network_peer()) { \
-		rpc(#rpcfunc, rpc_var);                               \
-	}                                                         \
-	normalfunc(normal_var);
+#define RPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var)          \
+	{                                                             \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer(); \
+		if (_multiplayer_api.is_valid()) {                        \
+			rpc(#rpcfunc, rpc_var);                               \
+		}                                                         \
+		normalfunc(normal_var);                                   \
+	}
 
-#define VRPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var)     \
-	if (is_inside_tree() && get_tree()->has_network_peer()) { \
-		vrpc(#rpcfunc, rpc_var);                              \
-	}                                                         \
-	normalfunc(normal_var);
+#define VRPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var)         \
+	{                                                             \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer(); \
+		if (_multiplayer_api.is_valid()) {                        \
+			vrpc(#rpcfunc, rpc_var);                              \
+		}                                                         \
+		normalfunc(normal_var);                                   \
+	}
 
-#define VRPCOBJ12(rpcfunc, rpc_var, normalfunc, normal_var1, normal_var2)                        \
-	if (is_inside_tree() && get_tree()->has_network_peer() && get_tree()->is_network_server()) { \
-		vrpc(#rpcfunc, rpc_var);                                                                 \
-	}                                                                                            \
-	normalfunc(normal_var1, normal_var2);
+#define VRPCOBJ12(rpcfunc, rpc_var, normalfunc, normal_var1, normal_var2)   \
+	{                                                                       \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();           \
+		if (_multiplayer_api.is_valid() && _multiplayer_api->is_server()) { \
+			vrpc(#rpcfunc, rpc_var);                                        \
+		}                                                                   \
+		normalfunc(normal_var1, normal_var2);                               \
+	}
 
-#define VRPCOBJP(rpcfunc, rpc_var1, rpc_var2, normalfunc, normal_var1, normal_var2)              \
-	if (is_inside_tree() && get_tree()->has_network_peer() && get_tree()->is_network_server()) { \
-		vrpc(#rpcfunc, rpc_var1, rpc_var2);                                                      \
-	}                                                                                            \
-	normalfunc(normal_var1, normal_var2);
+#define VRPCOBJP(rpcfunc, rpc_var1, rpc_var2, normalfunc, normal_var1, normal_var2) \
+	{                                                                               \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();                   \
+		if (_multiplayer_api.is_valid() && _multiplayer_api->is_server()) {         \
+			vrpc(#rpcfunc, rpc_var1, rpc_var2);                                     \
+		}                                                                           \
+		normalfunc(normal_var1, normal_var2);                                       \
+	}
 
-#define ORPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var)                 \
-	if (is_inside_tree() && get_tree()->has_network_peer()) {             \
-		if (get_tree()->is_network_server() && get_network_master() != 1) \
-			rpc_id(get_network_master(), #rpcfunc, rpc_var);              \
-	}                                                                     \
-	normalfunc(normal_var);
+#define ORPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var)                          \
+	{                                                                              \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();                  \
+		if (_multiplayer_api.is_valid()) {                                         \
+			if (_multiplayer_api->is_server() && get_multiplayer_authority() != 1) \
+				rpc_id(get_multiplayer_authority(), #rpcfunc, rpc_var);            \
+		}                                                                          \
+		normalfunc(normal_var);                                                    \
+	}
 
-#define RPCSOBJ(rpcfunc, rpc_var, normalfunc, normal_var)     \
-	if (is_inside_tree() && get_tree()->has_network_peer()) { \
-		if (get_tree()->is_network_server()) {                \
-			normalfunc(normal_var);                           \
-		} else {                                              \
-			rpc_id(1, #rpcfunc, rpc_var);                     \
-		}                                                     \
-	} else {                                                  \
-		normalfunc(normal_var);                               \
+#define RPCSOBJ(rpcfunc, rpc_var, normalfunc, normal_var)         \
+	{                                                             \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer(); \
+		if (_multiplayer_api.is_valid()) {                        \
+			if (_multiplayer_api->is_server()) {                  \
+				normalfunc(normal_var);                           \
+			} else {                                              \
+				rpc_id(1, #rpcfunc, rpc_var);                     \
+			}                                                     \
+		} else {                                                  \
+			normalfunc(normal_var);                               \
+		}                                                         \
 	}
 
 #define ORPCOBJP(rpcfunc, rpc_var1, rpc_var2, normalfunc, normal_var1, normal_var2) \
-	if (is_inside_tree() && get_tree()->has_network_peer()) {                       \
-		if (get_tree()->is_network_server() && get_network_master() != 1)           \
-			rpc_id(get_network_master(), #rpcfunc, rpc_var1, rpc_var2);             \
-	}                                                                               \
-	normalfunc(normal_var1, normal_var2);
+	{                                                                               \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();                   \
+		if (_multiplayer_api.is_valid()) {                                          \
+			if (_multiplayer_api->is_server() && get_multiplayer_authority() != 1)  \
+				rpc_id(get_multiplayer_authority(), #rpcfunc, rpc_var1, rpc_var2);  \
+		}                                                                           \
+		normalfunc(normal_var1, normal_var2);                                       \
+	}
 
 // f.e. RSET(rset("property", "value"), property, value)
-#define RSET(rset_func, variable, value)                                                         \
-	if (is_inside_tree() && get_tree()->has_network_peer() && get_tree()->is_network_server()) { \
-		rset_func;                                                                               \
-	}                                                                                            \
-	variable = value;
+#define RSET(rset_func, variable, value)                                    \
+	{                                                                       \
+		Ref<MultiplayerAPI> _multiplayer_api = get_multiplayer();           \
+		if (_multiplayer_api.is_valid() && _multiplayer_api->is_server()) { \
+			rset_func;                                                      \
+		}                                                                   \
+		variable = value;                                                   \
+	}
 
 class Entity : public Node {
 	GDCLASS(Entity, Node);