diff --git a/entities/entity.cpp b/entities/entity.cpp
index 27cf0dc..a9ac44e 100644
--- a/entities/entity.cpp
+++ b/entities/entity.cpp
@@ -263,7 +263,6 @@ void Entity::setc_seed(int value) {
 	_c_seed = value;
 }
 
-
 void Entity::setup() {
 	if (has_method("_setup")) {
 		call_multilevel("_setup");
@@ -4141,11 +4140,33 @@ Ref<Bag> Entity::gets_bag() const {
 	return _s_bag;
 }
 void Entity::sets_bag(const Ref<Bag> bag) {
+	if (_s_bag.is_valid()) {
+		_s_bag->disconnect("item_added", this, "ons_item_added");
+		_s_bag->disconnect("item_removed", this, "ons_item_removed");
+		_s_bag->disconnect("item_swapped", this, "ons_items_swapped");
+		_s_bag->disconnect("item_count_changed", this, "ons_item_count_changed");
+		_s_bag->disconnect("overburdened", this, "ons_overburdened");
+		_s_bag->disconnect("overburden_removed", this, "ons_overburden_removed");
+	}
+
 	_s_bag = bag;
 
+	if (_s_bag.is_valid()) {
+		_s_bag->connect("item_added", this, "ons_item_added");
+		_s_bag->connect("item_removed", this, "ons_item_removed");
+		_s_bag->connect("item_swapped", this, "ons_items_swapped");
+		_s_bag->connect("item_count_changed", this, "ons_item_count_changed");
+		_s_bag->connect("overburdened", this, "ons_overburdened");
+		_s_bag->connect("overburden_removed", this, "ons_overburden_removed");
+	}
+
 	emit_signal("sbag_changed", this, _s_bag);
 
-	ORPCOBJ(setc_bag_rpc, JSON::print(_s_bag->to_dict()), setc_bag, bag);
+	if (_s_bag.is_valid()) {
+		ORPC(setc_bag_rpc, JSON::print(_s_bag->to_dict()));
+	} else {
+		ORPC(setc_bag_rpc, "");
+	}
 }
 
 Ref<Bag> Entity::getc_bag() const {
@@ -4161,9 +4182,30 @@ Ref<Bag> Entity::gets_target_bag() const {
 	return _s_target_bag;
 }
 void Entity::sets_target_bag(const Ref<Bag> bag) {
+	if (_s_target_bag.is_valid()) {
+		_s_target_bag->disconnect("item_added", this, "ons_target_item_added");
+		_s_target_bag->disconnect("item_removed", this, "ons_target_item_removed");
+		_s_target_bag->disconnect("item_swapped", this, "ons_target_items_swapped");
+		_s_target_bag->disconnect("item_swapped", this, "ons_target_items_swapped");
+		_s_target_bag->disconnect("item_count_changed", this, "ons_target_item_count_changed");
+	}
+
 	_s_target_bag = bag;
 
-	ORPCOBJ(setc_target_bag_rpc, JSON::print(_s_target_bag->to_dict()), setc_target_bag, bag);
+	if (_s_target_bag.is_valid()) {
+		_s_target_bag->connect("item_added", this, "ons_target_item_added");
+		_s_target_bag->connect("item_removed", this, "ons_target_item_removed");
+		_s_target_bag->connect("item_swapped", this, "ons_target_items_swapped");
+		_s_target_bag->connect("item_count_changed", this, "ons_target_item_count_changed");
+	}
+
+	emit_signal("starget_bag_changed", this, _s_target_bag);
+
+	if (_s_target_bag.is_valid()) {
+		ORPC(setc_target_bag_rpc, JSON::print(_s_target_bag->to_dict()));
+	} else {
+		ORPC(setc_target_bag_rpc, "");
+	}
 }
 
 Ref<Bag> Entity::getc_target_bag() const {
@@ -4171,6 +4213,8 @@ Ref<Bag> Entity::getc_target_bag() const {
 }
 void Entity::setc_target_bag(const Ref<Bag> bag) {
 	_c_target_bag = bag;
+
+	emit_signal("ctarget_bag_changed", this, _s_target_bag);
 }
 
 void Entity::setc_bag_rpc(String data) {
@@ -4189,7 +4233,7 @@ void Entity::setc_target_bag_rpc(String data) {
 }
 
 void Entity::crequest_loot(int index) {
-	sloot(index);
+	RPCS(sloot, index);
 }
 void Entity::sloot(int index) {
 	ERR_FAIL_COND(!_s_bag.is_valid());
@@ -4202,6 +4246,156 @@ void Entity::sloot(int index) {
 		_s_bag->add_item(ii);
 	}
 }
+void Entity::cloot(int index) {
+	ERR_FAIL_COND(!_c_target_bag.is_valid());
+
+	_c_target_bag->remove_item(index);
+}
+
+void Entity::ons_item_added(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id) {
+	ORPCOBJP(cadd_item_rpc, slot_id, JSON::print(item->to_dict()), cadd_item, slot_id, item);
+}
+void Entity::cadd_item_rpc(int slot_id, String item_data) {
+	Ref<ItemInstance> ii;
+	ii.instance();
+	ii->from_dict(data_as_dict(item_data));
+
+	cadd_item(slot_id, ii);
+}
+void Entity::cadd_item(int slot_id, Ref<ItemInstance> item) {
+	ERR_FAIL_COND(!_c_bag.is_valid());
+
+	_c_bag->add_item_at(slot_id, item);
+}
+
+void Entity::ons_item_removed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id) {
+	ORPC(cremove_item, slot_id);
+}
+void Entity::sremove_item(const int slot_id) {
+	ERR_FAIL_COND(!_s_bag.is_valid());
+
+	_s_bag->remove_item(slot_id);
+}
+void Entity::cremove_item(const int slot_id) {
+	ERR_FAIL_COND(!_c_bag.is_valid());
+
+	_c_bag->remove_item(slot_id);
+}
+void Entity::cdenyremove_item(const int slot_id) {
+}
+void Entity::crequest_remove_item(const int slot_id) {
+	RPCS(sremove_item, slot_id);
+}
+
+void Entity::ons_items_swapped(Ref<Bag> bag, int slot_id_1, int slot_id_2) {
+	ORPC(cswap_items, slot_id_1, slot_id_2);
+}
+void Entity::sswap_items(int slot_id_1, int slot_id_2) {
+	ERR_FAIL_COND(!_s_bag.is_valid());
+
+	_s_bag->swap_items(slot_id_1, slot_id_2);
+}
+void Entity::cswap_items(int slot_id_1, int slot_id_2) {
+	ERR_FAIL_COND(!_c_bag.is_valid());
+
+	_c_bag->swap_items(slot_id_1, slot_id_2);
+}
+void Entity::cdeny_item_swap(int slot_id_1, int slot_id_2) {
+}
+void Entity::crequest_item_swap(int slot_id_1, int slot_id_2) {
+	RPCS(sswap_items, slot_id_1, slot_id_2);
+}
+
+void Entity::ons_item_count_changed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id) {
+	ERR_FAIL_COND(!item.is_valid());
+
+	ORPC(cchange_item_count, slot_id, item->get_stack_size());
+}
+void Entity::cchange_item_count(int slot_id, int new_count) {
+	ERR_FAIL_COND(!_c_bag.is_valid());
+
+	Ref<ItemInstance> ii = _c_bag->get_item(slot_id);
+
+	ERR_FAIL_COND(!ii.is_valid());
+
+	ii->set_stack_size(new_count);
+}
+
+void Entity::ons_overburdened(Ref<Bag> bag) {
+}
+void Entity::ons_overburden_removed(Ref<Bag> bag) {
+}
+
+//Target Bag
+
+void Entity::ons_target_item_added(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id) {
+	ORPCOBJP(cadd_target_item_rpc, slot_id, JSON::print(item->to_dict()), cadd_target_item, slot_id, item);
+}
+void Entity::cadd_target_item_rpc(int slot_id, String item_data) {
+	Ref<ItemInstance> ii;
+	ii.instance();
+	ii->from_dict(data_as_dict(item_data));
+
+	cadd_target_item(slot_id, ii);
+}
+void Entity::cadd_target_item(int slot_id, Ref<ItemInstance> item) {
+	ERR_FAIL_COND(!_c_target_bag.is_valid());
+
+	_c_target_bag->add_item_at(slot_id, item);
+}
+
+void Entity::ons_target_item_removed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id) {
+	ORPC(cremove_target_item, slot_id);
+}
+void Entity::sremove_target_item(const int slot_id) {
+	ERR_FAIL_COND(!_s_target_bag.is_valid());
+
+	_s_target_bag->remove_item(slot_id);
+}
+void Entity::cremove_target_item(const int slot_id) {
+	ERR_FAIL_COND(!_c_target_bag.is_valid());
+	
+	_c_target_bag->remove_item(slot_id);
+}
+void Entity::cdenyremove_target_item(const int slot_id) {
+}
+void Entity::crequest_target_remove_item(const int slot_id) {
+	RPCS(sremove_target_item, slot_id);
+}
+
+void Entity::ons_target_items_swapped(Ref<Bag> bag, int slot_id_1, int slot_id_2) {
+	ORPC(cswap_target_items, slot_id_1, slot_id_2);
+}
+void Entity::sswap_target_items(int slot_id_1, int slot_id_2) {
+	ERR_FAIL_COND(!_s_target_bag.is_valid());
+
+	_s_target_bag->swap_items(slot_id_1, slot_id_2);
+}
+void Entity::cswap_target_items(int slot_id_1, int slot_id_2) {
+	ERR_FAIL_COND(!_c_target_bag.is_valid());
+
+	_c_target_bag->swap_items(slot_id_1, slot_id_2);
+}
+void Entity::cdeny_target_item_swap(int slot_id_1, int slot_id_2) {
+}
+void Entity::crequest_target_item_swap(int slot_id_1, int slot_id_2) {
+	RPCS(sswap_target_items, slot_id_1, slot_id_2);
+}
+
+void Entity::ons_target_item_count_changed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id) {
+	ERR_FAIL_COND(!item.is_valid());
+
+	ORPC(cchange_target_item_count, slot_id, item->get_stack_size());
+}
+void Entity::cchange_target_item_count(int slot_id, int new_count) {
+	ERR_FAIL_COND(!_c_target_bag.is_valid());
+
+	Ref<ItemInstance> ii = _c_target_bag->get_item(slot_id);
+
+	ERR_FAIL_COND(!ii.is_valid());
+
+	ii->set_stack_size(new_count);
+}
 
 ////    DATA    ////
 void Entity::adds_data(Ref<EntityDataContainer> data) {
@@ -4774,6 +4968,25 @@ Entity::Entity() {
 	SET_RPC_REMOTE("setc_target_bag_rpc");
 
 	SET_RPC_REMOTE("sloot");
+	SET_RPC_REMOTE("cloot");
+
+	SET_RPC_REMOTE("cadd_item_rpc");
+	SET_RPC_REMOTE("sremove_item");
+	SET_RPC_REMOTE("cremove_item");
+	SET_RPC_REMOTE("cdenyremove_item");
+	SET_RPC_REMOTE("sswap_items");
+	SET_RPC_REMOTE("cswap_items");
+	SET_RPC_REMOTE("cdeny_item_swap");
+	SET_RPC_REMOTE("cchange_item_count");
+
+	SET_RPC_REMOTE("cadd_target_item_rpc");
+	SET_RPC_REMOTE("sremove_target_item");
+	SET_RPC_REMOTE("cremove_target_item");
+	SET_RPC_REMOTE("cdenyremove_target_item");
+	SET_RPC_REMOTE("sswap_target_items");
+	SET_RPC_REMOTE("cswap_target_items");
+	SET_RPC_REMOTE("cdeny_target_item_swap");
+	SET_RPC_REMOTE("cchange_target_item_count");
 
 	////    Data    ////
 
@@ -5652,6 +5865,9 @@ void Entity::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("setc_bag", "bag"), &Entity::setc_bag);
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "cbag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), "setc_bag", "getc_bag");
 
+	ADD_SIGNAL(MethodInfo("starget_bag_changed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag")));
+	ADD_SIGNAL(MethodInfo("ctarget_bag_changed", PropertyInfo(Variant::OBJECT, "entity", PROPERTY_HINT_RESOURCE_TYPE, "Entity"), PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag")));
+
 	ClassDB::bind_method(D_METHOD("gets_target_bag"), &Entity::gets_target_bag);
 	ClassDB::bind_method(D_METHOD("sets_target_bag", "bag"), &Entity::sets_target_bag);
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "starget_bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), "sets_target_bag", "gets_target_bag");
@@ -5665,6 +5881,50 @@ void Entity::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("crequest_loot"), &Entity::crequest_loot);
 	ClassDB::bind_method(D_METHOD("sloot"), &Entity::sloot);
+	ClassDB::bind_method(D_METHOD("cloot"), &Entity::cloot);
+
+	//Bag
+	ClassDB::bind_method(D_METHOD("ons_item_added", "bag", "item", "slot_id"), &Entity::ons_item_added);
+	ClassDB::bind_method(D_METHOD("cadd_item_rpc", "slot_id", "item_data"), &Entity::cadd_item_rpc);
+	ClassDB::bind_method(D_METHOD("cadd_item", "slot_id", "item"), &Entity::cadd_item);
+
+	ClassDB::bind_method(D_METHOD("ons_item_removed", "bag", "item", "slot_id"), &Entity::ons_item_removed);
+	ClassDB::bind_method(D_METHOD("sremove_item", "slot_id"), &Entity::sremove_item);
+	ClassDB::bind_method(D_METHOD("cremove_item", "slot_id"), &Entity::cremove_item);
+	ClassDB::bind_method(D_METHOD("cdenyremove_item", "slot_id"), &Entity::cdenyremove_item);
+	ClassDB::bind_method(D_METHOD("crequest_remove_item", "slot_id"), &Entity::crequest_remove_item);
+
+	ClassDB::bind_method(D_METHOD("ons_items_swapped", "bag", "slot_id_1", "slot_id_2"), &Entity::ons_items_swapped);
+	ClassDB::bind_method(D_METHOD("sswap_items", "slot_id_1", "slot_id_2"), &Entity::sswap_items);
+	ClassDB::bind_method(D_METHOD("cswap_items", "slot_id_1", "slot_id_2"), &Entity::cswap_items);
+	ClassDB::bind_method(D_METHOD("cdeny_item_swap", "slot_id_1", "slot_id_2"), &Entity::cdeny_item_swap);
+	ClassDB::bind_method(D_METHOD("crequest_item_swap", "slot_id_1", "slot_id_2"), &Entity::crequest_item_swap);
+
+	ClassDB::bind_method(D_METHOD("ons_item_count_changed", "bag", "item", "slot_id"), &Entity::ons_item_count_changed);
+	ClassDB::bind_method(D_METHOD("cchange_item_count", "slot_id", "new_count"), &Entity::cchange_item_count);
+
+	ClassDB::bind_method(D_METHOD("ons_overburdened", "bag"), &Entity::ons_overburdened);
+	ClassDB::bind_method(D_METHOD("ons_overburden_removed", "bag"), &Entity::ons_overburden_removed);
+
+	//target Bag
+	ClassDB::bind_method(D_METHOD("ons_target_item_added", "bag", "item", "slot_id"), &Entity::ons_target_item_added);
+	ClassDB::bind_method(D_METHOD("cadd_target_item_rpc", "slot_id", "item_data"), &Entity::cadd_target_item_rpc);
+	ClassDB::bind_method(D_METHOD("cadd_target_item", "slot_id", "item"), &Entity::cadd_target_item);
+
+	ClassDB::bind_method(D_METHOD("ons_target_item_removed", "bag", "item", "slot_id"), &Entity::ons_target_item_removed);
+	ClassDB::bind_method(D_METHOD("sremove_target_item", "slot_id"), &Entity::sremove_target_item);
+	ClassDB::bind_method(D_METHOD("cremove_target_item", "slot_id"), &Entity::cremove_target_item);
+	ClassDB::bind_method(D_METHOD("cdenyremove_target_item", "slot_id"), &Entity::cdenyremove_target_item);
+	ClassDB::bind_method(D_METHOD("crequest_target_remove_item", "slot_id"), &Entity::crequest_target_remove_item);
+
+	ClassDB::bind_method(D_METHOD("ons_target_items_swapped", "bag", "slot_id_1", "slot_id_2"), &Entity::ons_target_items_swapped);
+	ClassDB::bind_method(D_METHOD("sswap_target_items", "slot_id_1", "slot_id_2"), &Entity::sswap_target_items);
+	ClassDB::bind_method(D_METHOD("cswap_target_items", "slot_id_1", "slot_id_2"), &Entity::cswap_target_items);
+	ClassDB::bind_method(D_METHOD("cdeny_target_item_swap", "slot_id_1", "slot_id_2"), &Entity::cdeny_target_item_swap);
+	ClassDB::bind_method(D_METHOD("crequest_target_item_swap", "slot_id_1", "slot_id_2"), &Entity::crequest_target_item_swap);
+
+	ClassDB::bind_method(D_METHOD("ons_target_item_count_changed", "bag", "item", "slot_id"), &Entity::ons_target_item_count_changed);
+	ClassDB::bind_method(D_METHOD("cchange_target_item_count", "slot_id", "new_count"), &Entity::cchange_target_item_count);
 
 	//Actionbars
 
diff --git a/entities/entity.h b/entities/entity.h
index b5ef31b..7f7bc50 100644
--- a/entities/entity.h
+++ b/entities/entity.h
@@ -150,6 +150,13 @@ enum PlayerSendFlags {
 		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);
+
 // f.e. RSET(rset("property", "value"), property, value)
 #define RSET(rset_func, variable, value)                      \
 	if (is_inside_tree() && get_tree()->has_network_peer()) { \
@@ -726,6 +733,50 @@ public:
 
 	void crequest_loot(int index);
 	void sloot(int index);
+	void cloot(int index);
+
+	void ons_item_added(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
+	void cadd_item_rpc(int slot_id, String item_data);
+	void cadd_item(int slot_id, Ref<ItemInstance> item);
+
+	//Bag
+	void ons_item_removed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
+	void sremove_item(const int slot_id);
+	void cremove_item(const int slot_id);
+	void cdenyremove_item(const int slot_id);
+	void crequest_remove_item(const int slot_id);
+
+	void ons_items_swapped(Ref<Bag> bag, int slot_id_1, int slot_id_2);
+	void sswap_items(int slot_id_1, int slot_id_2);
+	void cswap_items(int slot_id_1, int slot_id_2);
+	void cdeny_item_swap(int slot_id_1, int slot_id_2);
+	void crequest_item_swap(int slot_id_1, int slot_id_2);
+
+	void ons_item_count_changed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
+	void cchange_item_count(int slot_id, int new_count);
+
+	void ons_overburdened(Ref<Bag> bag);
+	void ons_overburden_removed(Ref<Bag> bag);
+
+	//Target Bag
+	void ons_target_item_added(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
+	void cadd_target_item_rpc(int slot_id, String item_data);
+	void cadd_target_item(int slot_id, Ref<ItemInstance> item);
+
+	void ons_target_item_removed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
+	void sremove_target_item(const int slot_id);
+	void cremove_target_item(const int slot_id);
+	void cdenyremove_target_item(const int slot_id);
+	void crequest_target_remove_item(const int slot_id);
+
+	void ons_target_items_swapped(Ref<Bag> bag, int slot_id_1, int slot_id_2);
+	void sswap_target_items(int slot_id_1, int slot_id_2);
+	void cswap_target_items(int slot_id_1, int slot_id_2);
+	void cdeny_target_item_swap(int slot_id_1, int slot_id_2);
+	void crequest_target_item_swap(int slot_id_1, int slot_id_2);
+
+	void ons_target_item_count_changed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
+	void cchange_target_item_count(int slot_id, int new_count);
 
 	////    Data    ////
 
@@ -762,7 +813,6 @@ public:
 	Ref<AIFSMAction> gets_ai();
 	void sets_ai(Ref<AIFSMAction> value);
 
-
 	////    Serialization    ////
 
 	bool is_deserialized();
diff --git a/inventory/bag.cpp b/inventory/bag.cpp
index eb95857..c2d7f9f 100644
--- a/inventory/bag.cpp
+++ b/inventory/bag.cpp
@@ -75,14 +75,21 @@ bool Bag::add_item(Ref<ItemInstance> item) {
 	return true;
 }
 
-void Bag::set_item(int index, Ref<ItemInstance> item) {
-	if (has_method("_set_item")) {
-		call("_set_item", index, item);
+void Bag::add_item_at(int index, Ref<ItemInstance> item) {
+	ERR_FAIL_COND(!item.is_valid());
+
+	if (has_method("_add_item_at")) {
+		call("_add_item_at", index, item);
+		return;
 	}
 
-	ERR_FAIL_INDEX(index, _items.size());
+	if (_items.size() <= index) {
+		_items.resize(index + 1);
+	}
 
 	_items.set(index, item);
+
+	emit_signal("item_added", Ref<Bag>(this), item, index);
 }
 
 Ref<ItemInstance> Bag::get_item(const int index) {
@@ -138,6 +145,19 @@ void Bag::swap_items(const int item1_index, const int item2_index) {
 	emit_signal("item_swapped", Ref<Bag>(this), item1_index, item2_index);
 }
 
+void Bag::change_item_equip(int slot_id, Ref<ItemInstance> item) {
+	if (has_method("_change_item_equip")) {
+		call("_change_item_equip", slot_id, item);
+		return;
+	}
+
+	ERR_FAIL_INDEX(slot_id, _items.size());
+
+	_items.set(slot_id, item);
+
+	emit_signal("change_item_equip", Ref<Bag>(this), slot_id, item);
+}
+
 bool Bag::can_add_item(const Ref<ItemInstance> item) {
 	if (has_method("_can_add_item")) {
 		return call("_can_add_item", item);
@@ -327,7 +347,7 @@ Bag::~Bag() {
 
 void Bag::_bind_methods() {
 	BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "could_add"), "_add_item", PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance")));
-	BIND_VMETHOD(MethodInfo("_set_item", PropertyInfo(Variant::INT, "index") , PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance")));
+	BIND_VMETHOD(MethodInfo("_add_item_at", PropertyInfo(Variant::INT, "index") , PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance")));
 	BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance"), "_get_item", PropertyInfo(Variant::INT, "index")));
 	BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance"), "_remove_item", PropertyInfo(Variant::INT, "index")));
 	BIND_VMETHOD(MethodInfo("_swap_items", PropertyInfo(Variant::INT, "item1_index"), PropertyInfo(Variant::INT, "item2_index")));
@@ -340,25 +360,27 @@ void Bag::_bind_methods() {
 	BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "overburdened"), "_is_overburdened"));
 	BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "has"), "_has_item", PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemTemplate"), PropertyInfo(Variant::INT, "count")));
 	BIND_VMETHOD(MethodInfo("_remove_items", PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemTemplate"), PropertyInfo(Variant::INT, "count")));
+	BIND_VMETHOD(MethodInfo("_change_item_equip", PropertyInfo(Variant::INT, "slot_id"), PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance")));
 
 	ADD_SIGNAL(MethodInfo("item_added", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance"), PropertyInfo(Variant::INT, "slot_id")));
-	ADD_SIGNAL(MethodInfo("item_set", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance"), PropertyInfo(Variant::INT, "slot_id")));
 	ADD_SIGNAL(MethodInfo("item_removed", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance"), PropertyInfo(Variant::INT, "slot_id")));
 	ADD_SIGNAL(MethodInfo("item_swapped", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), PropertyInfo(Variant::INT, "slot_id_1"), PropertyInfo(Variant::INT, "slot_id_2")));
 	ADD_SIGNAL(MethodInfo("item_count_changed", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance"), PropertyInfo(Variant::INT, "slot_id")));
 	ADD_SIGNAL(MethodInfo("overburdened", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag")));
 	ADD_SIGNAL(MethodInfo("overburden_removed", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag")));
 	ADD_SIGNAL(MethodInfo("size_changed", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag")));
+	ADD_SIGNAL(MethodInfo("change_item_equip", PropertyInfo(Variant::OBJECT, "bag", PROPERTY_HINT_RESOURCE_TYPE, "Bag"), PropertyInfo(Variant::INT, "slot_id"), PropertyInfo(Variant::OBJECT, "item", PROPERTY_HINT_RESOURCE_TYPE, "ItemInstance")));
 
 	ClassDB::bind_method(D_METHOD("get_allowed_item_types"), &Bag::get_allowed_item_types);
 	ClassDB::bind_method(D_METHOD("set_allowed_item_types", "count"), &Bag::set_allowed_item_types);
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "allowed_item_types", PROPERTY_HINT_FLAGS, ItemEnums::BINDING_STRING_ITEM_TYPE_FLAGS), "set_allowed_item_types", "get_allowed_item_types");
 
 	ClassDB::bind_method(D_METHOD("add_item", "item"), &Bag::add_item);
-	ClassDB::bind_method(D_METHOD("set_item", "index", "item"), &Bag::set_item);
+	ClassDB::bind_method(D_METHOD("add_item_at", "index", "item"), &Bag::add_item_at);
 	ClassDB::bind_method(D_METHOD("get_item", "index"), &Bag::get_item);
 	ClassDB::bind_method(D_METHOD("remove_item", "index"), &Bag::remove_item);
 	ClassDB::bind_method(D_METHOD("swap_items", "item1_index", "item2_index"), &Bag::swap_items);
+	ClassDB::bind_method(D_METHOD("change_item_equip", "index", "item"), &Bag::change_item_equip);
 
 	ClassDB::bind_method(D_METHOD("can_add_item", "item"), &Bag::can_add_item);
 
diff --git a/inventory/bag.h b/inventory/bag.h
index 3359994..c182658 100644
--- a/inventory/bag.h
+++ b/inventory/bag.h
@@ -17,10 +17,11 @@ public:
 	void set_allowed_item_types(const int value);
 
 	bool add_item(Ref<ItemInstance> item);
-	void set_item(int index, Ref<ItemInstance> item);
+	void add_item_at(int index, Ref<ItemInstance> item);
 	Ref<ItemInstance> get_item(const int index);
     Ref<ItemInstance> remove_item(const int index);
     void swap_items(const int item1_index, const int item2_index);
+	void change_item_equip(int slot_id, Ref<ItemInstance> item);
     
     bool can_add_item(Ref<ItemInstance> item);