Implemented event subscriptions for specific senders

assets/scenes/scene_1.symtres

@@ -10,16 +10,18 @@ Scene_Config
 	debug_draw_enabled : false
 	debug_draw_mode : 0
 	ambient_light : 0.100 0.100 0.100
+	init_func: scene_1
+	cleanup_func: scene_1
 }
 
 Player
 {
 	type : 2
 	scale : 1.000 1.000 1.000
-	rotation : 0.000 -1.001 0.000 -0.000
+	rotation : 0.000 -0.612 0.000 0.792
 	active : true
 	player_key_mask : 0
-	position : -18.634 2.167 -45.517
+	position : -33.501 2.167 -45.463
 	player_health : 100
 	name : Player
 	bounding_box_min : -1.500 -1.500 -1.000
@@ -101,9 +103,9 @@ Scene_Entity_Entry
 
 Scene_Entity_Entry
 {
-	scale : 135.000 5.000 1.000
+	scale : 135.000 11.000 1.000
 	rotation : 0.000 0.000 0.000 1.000
-	position : -17.000 3.000 -87.000
+	position : -17.000 6.000 -87.000
 	filename : cube_uv
 	name : Cube
 }
@@ -117,6 +119,15 @@ Scene_Entity_Entry
 	name : Cube
 }
 
+Scene_Entity_Entry
+{
+	scale : 51.000 11.000 1.000
+	rotation : 0.000 -0.707 0.000 0.707
+	position : 18.000 6.000 -55.000
+	filename : cube_uv
+	name : Cube
+}
+
 Scene_Entity_Entry
 {
 	scale : 1.000 1.000 1.000
@@ -162,6 +173,15 @@ Scene_Entity_Entry
 	name : Turret
 }
 
+Scene_Entity_Entry
+{
+	scale : 30.500 11.000 55.000
+	rotation : 0.000 0.000 0.000 1.000
+	position : 34.000 6.000 -59.000
+	filename : trigger
+	name : Scene_End_Trigger
+}
+
 Scene_Entity_Entry
 {
 	scale : 1.000 1.000 1.000
@@ -171,3 +191,12 @@ Scene_Entity_Entry
 	name : Door
 }
 
+Scene_Entity_Entry
+{
+	scale : 1.000 1.000 1.000
+	rotation : 0.000 0.707 0.000 0.707
+	position : 18.000 1.000 -84.000
+	filename : door
+	name : Door
+}
+

src/common/version.h

@@ -4,7 +4,7 @@
 /* Auto generated version file. DO NOT MODIFY */
 #define SYMMETRY_VERSION_MAJOR 0
 #define SYMMETRY_VERSION_MINOR 1
-#define SYMMETRY_VERSION_REVISION 349
+#define SYMMETRY_VERSION_REVISION 350
 #define SYMMETRY_VERSION_BRANCH "dev"
 
 #endif

src/game/door.c

@@ -30,7 +30,7 @@ void door_init(struct Door* door, int mask)
 	door->close_position = 0.f;
 	door->state          = DOOR_CLOSED;
 
-	event_manager_subscribe_with_object(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door);
+	event_manager_subscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door);
 }
 
 void door_reset(struct Door* door)
@@ -39,8 +39,8 @@ void door_reset(struct Door* door)
 	door->speed = 0.f;
 
 	struct Event_Manager* event_manager = game_state_get()->event_manager;
-	event_manager_unsubscribe_with_object(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door);
+	event_manager_unsubscribe_with_subscriber(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door);
-	event_manager_unsubscribe_with_object(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door);
+	event_manager_unsubscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door);
 }
 
 struct Door* door_read(struct Parser_Object* object, const char* name, struct Entity* parent_entity)
@@ -169,7 +169,7 @@ void door_on_scene_loaded(struct Event* event, void* door_ptr)
 	{
 		door->trigger = door_trigger[0];
 		struct Event_Manager* event_manager = game_state_get()->event_manager;
-		event_manager_subscribe_with_object(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door);
+		event_manager_subscribe_with_subscriber(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door);
 	}
 	else
 	{

src/game/editor.c

@@ -43,8 +43,9 @@
 #include <limits.h>
 #include <math.h>
 
-#define LABEL_FLAGS_ALIGN_LEFT  NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_LEFT
+#define LABEL_FLAGS_ALIGN_LEFT     NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_LEFT
-#define LABEL_FLAGS_ALIGN_RIGHT NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_RIGHT
+#define LABEL_FLAGS_ALIGN_RIGHT    NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_RIGHT
+#define LABEL_FLAGS_ALIGN_CENTERED NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_CENTERED
 
 enum Editor_Tool
 {

src/game/enemy.c

@@ -61,7 +61,7 @@ void enemy_init(struct Enemy* enemy, int type)
 	}
 
 	struct Event_Manager* event_manager = game_state->event_manager;
-	event_manager_subscribe_with_object(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy);
+	event_manager_subscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy);
 }
 
 void enemy_weapon_sound_set(struct Enemy* enemy, const char* sound_filename, int type)
@@ -120,7 +120,7 @@ void enemy_reset(struct Enemy* enemy)
 	enemy->health = 0;
 
 	struct Event_Manager* event_manager = game_state_get()->event_manager;
-	event_manager_unsubscribe_with_object(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy);
+	event_manager_unsubscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy);
 }
 
 struct Enemy* enemy_read(struct Parser_Object* object, const char* name, struct Entity* parent_entity)

src/game/event.c

@@ -38,7 +38,7 @@ void event_manager_subscribe(struct Event_Manager* event_manager, int event_type
 	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
 	{
 		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
-		if(subscription->type == EST_WITHOUT_OBJECT && subscription->event_type == event_type && subscription->handler == handler_func)
+		if(subscription->type == EST_WITHOUT_OBJECTS && subscription->event_type == event_type && subscription->Subscription_Without_Objects.handler == handler_func)
 		{
 			log_message("Already subscibed to %s event", event_name_get(event_type));
 			subscribed = true;
@@ -55,10 +55,10 @@ void event_manager_subscribe(struct Event_Manager* event_manager, int event_type
 			struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
 			if(subscription->type == EST_NONE)
 			{
-				subscription->type       = EST_WITHOUT_OBJECT;
+				subscribed                                         = true;
-				subscription->event_type = event_type;
+				subscription->type                                 = EST_WITHOUT_OBJECTS;
-				subscription->handler    = handler_func;
+				subscription->event_type                           = event_type;
-				subscribed               = true;
+				subscription->Subscription_Without_Objects.handler = handler_func;
 				break;
 			}
 		}
@@ -77,31 +77,33 @@ void event_manager_unsubscribe(struct Event_Manager* event_manager, int event_ty
 	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
 	{
 		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
-		if(subscription->type != EST_WITHOUT_OBJECT) continue;
+		if(subscription->type != EST_WITHOUT_OBJECTS) continue;
-		if(subscription->event_type == event_type && subscription->handler == handler_func)
+		if(subscription->event_type == event_type && subscription->Subscription_Without_Objects.handler == handler_func)
 		{
-			subscription->handler    = NULL;
+			subscription->Subscription_Without_Objects.handler = NULL;
-			subscription->event_type = EVT_NONE;
+			subscription->event_type                           = EVT_NONE;
-			subscription->type       = EST_NONE;
+			subscription->type                                 = EST_NONE;
 			break;
 		}
 	}
 }
 
-void event_manager_unsubscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber)
+void event_manager_unsubscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber)
 {
 	assert(event_manager && event_type < EVT_MAX);
 
 	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
 	{
 		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
-		if(subscription->type != EST_WITH_OBJECT) continue;
+		if(subscription->type != EST_SUBSCRIBER) continue;
-		if(subscription->event_type == event_type && subscription->handler_with_object == handler_func && subscription->subscriber == subscriber)
+		if(subscription->event_type == event_type && 
+		   subscription->Subscription_Subscriber.handler == handler_func && 
+		   subscription->Subscription_Subscriber.subscriber == subscriber)
 		{
-			subscription->handler_with_object = NULL;
+			subscription->Subscription_Subscriber.handler    = NULL;
-			subscription->event_type          = EVT_NONE;
+			subscription->event_type                         = EVT_NONE;
-			subscription->type                = EST_NONE;
+			subscription->type                               = EST_NONE;
-			subscription->subscriber          = NULL;
+			subscription->Subscription_Subscriber.subscriber = NULL;
 			break;
 		}
 	}
@@ -235,19 +237,26 @@ void event_manager_poll_events(struct Event_Manager* event_manager)
 				for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
 				{
 					struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
-					if(subscription->type == EST_NONE) continue;
+					if(subscription->type != EST_NONE && subscription->event_type == user_event->type)
-
-					if(subscription->event_type == user_event->type)
 					{
-						if(subscription->type == EST_WITHOUT_OBJECT)
+						switch(subscription->type)
-						{
-							if(subscription->handler) 
-								subscription->handler(user_event);
-						}
-						else if(subscription->type == EST_WITH_OBJECT)
 						{
-							if(subscription->handler_with_object)
+						case EST_WITHOUT_OBJECTS:
-								subscription->handler_with_object(user_event, subscription->subscriber);
+							if(subscription->Subscription_Without_Objects.handler)
+								subscription->Subscription_Without_Objects.handler(user_event);
+							break;
+						case EST_SENDER:
+							if(subscription->Subscription_Sender.handler)
+								subscription->Subscription_Sender.handler(user_event, subscription->Subscription_Sender.sender);
+							break;
+						case EST_SUBSCRIBER:
+							if(subscription->Subscription_Subscriber.handler)
+								subscription->Subscription_Subscriber.handler(user_event, subscription->Subscription_Subscriber.subscriber);
+							break;
+						case EST_SUBSCRIBER_SENDER:
+							if(subscription->Subscription_Subscriber_Sender.handler)
+								subscription->Subscription_Subscriber_Sender.handler(user_event, subscription->Subscription_Subscriber_Sender.subscriber, subscription->Subscription_Subscriber_Sender.sender);
+							break;
 						}
 					}
 				}
@@ -262,7 +271,7 @@ void event_manager_poll_events(struct Event_Manager* event_manager)
 	}
 }
 
-void event_manager_subscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber)
+void event_manager_subscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber)
 {
 	assert(event_manager && event_type < EVT_MAX && event_type > EVT_NONE);
 
@@ -271,7 +280,10 @@ void event_manager_subscribe_with_object(struct Event_Manager* event_manager, in
 	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
 	{
 		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
-		if(subscription->type == EST_WITH_OBJECT && subscription->event_type == event_type && subscription->handler_with_object == handler_func && subscription->subscriber == subscriber)
+		if(subscription->type == EST_SUBSCRIBER && 
+		   subscription->event_type == event_type && 
+		   subscription->Subscription_Subscriber.handler == handler_func && 
+		   subscription->Subscription_Subscriber.subscriber == subscriber)
 		{
 			log_message("Already subscibed to %s event", event_name_get(event_type));
 			subscribed = true;
@@ -288,11 +300,11 @@ void event_manager_subscribe_with_object(struct Event_Manager* event_manager, in
 			struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
 			if(subscription->type == EST_NONE)
 			{
-				subscription->type                = EST_WITH_OBJECT;
+				subscribed                                       = true;
-				subscription->event_type          = event_type;
+				subscription->type                               = EST_SUBSCRIBER;
-				subscription->handler_with_object = handler_func;
+				subscription->event_type                         = event_type;
-				subscription->subscriber          = subscriber;
+				subscription->Subscription_Subscriber.handler    = handler_func;
-				subscribed                        = true;
+				subscription->Subscription_Subscriber.subscriber = subscriber;
 				break;
 			}
 		}
@@ -341,11 +353,149 @@ void event_manager_send_event_entity(struct Event_Manager* event_manager, struct
 	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
 	{
 		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
-		if(subscription->type != EST_WITH_OBJECT) continue;
+		if(subscription->type != EST_SUBSCRIBER) continue;
+
+		if(subscription->event_type == event->type && 
+		   subscription->Subscription_Subscriber.subscriber == entity &&
+		   subscription->Subscription_Subscriber.handler)
+		{
+			subscription->Subscription_Subscriber.handler(event, (void*)entity);
+			break;
+		}
+	}
+}
+
+void event_manager_subscribe_with_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender)
+{
+	assert(event_manager && event_type < EVT_MAX && event_type > EVT_NONE && sender);
+
+	//Check if this handler/subscriber already exists
+	bool subscribed = false;
+	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
+	{
+		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
+		if(subscription->type == EST_SENDER &&
+		   subscription->event_type == event_type &&
+		   subscription->Subscription_Sender.handler == handler_func &&
+		   subscription->Subscription_Sender.sender == sender)
+		{
+			log_message("Already subscibed to %s event", event_name_get(event_type));
+			subscribed = true;
+			break;
+		}
+	}
+
+	//Now that we've established that we are not subscribed already we find an empty slot and 
+	//create a new subscription there
+	if(!subscribed)
+	{
+		for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
+		{
+			struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
+			if(subscription->type == EST_NONE)
+			{
+				subscribed                                = true;
+				subscription->type                        = EST_SENDER;
+				subscription->event_type                  = event_type;
+				subscription->Subscription_Sender.handler = handler_func;
+				subscription->Subscription_Sender.sender  = sender;
+				break;
+			}
+		}
+	}
+
+	//if subscribed is still not true, it can only mean that all the existing slots are taken
+	//Show an error message in that case
+	if(!subscribed)
+		log_error("event_manager:subscribe_with_sender", "Could not subscribe to %s event", event_name_get(event_type));
+}
+
+void event_manager_subscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender)
+{
+	assert(event_manager && event_type < EVT_MAX && event_type > EVT_NONE && sender && subscriber);
+
+	//Check if this handler/subscriber/sender already exists
+	bool subscribed = false;
+	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
+	{
+		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
+		if(subscription->type == EST_SUBSCRIBER_SENDER && 
+		   subscription->event_type == event_type && 
+		   subscription->Subscription_Subscriber_Sender.handler == handler_func && 
+		   subscription->Subscription_Subscriber_Sender.sender == sender &&
+		   subscription->Subscription_Subscriber_Sender.subscriber == subscriber)
+		{
+			log_message("Already subscibed to %s event", event_name_get(event_type));
+			subscribed = true;
+			break;
+		}
+	}
+
+	//Now that we've established that we are not subscribed already we find an empty slot and 
+	//create a new subscription there
+	if(!subscribed)
+	{
+		for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
+		{
+			struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
+			if(subscription->type == EST_NONE)
+			{
+				subscribed                                              = true;
+				subscription->type                                      = EST_SUBSCRIBER_SENDER;
+				subscription->event_type                                = event_type;
+				subscription->Subscription_Subscriber_Sender.handler    = handler_func;
+				subscription->Subscription_Subscriber_Sender.sender     = sender;
+				subscription->Subscription_Subscriber_Sender.subscriber = subscriber;
+				break;
+			}
+		}
+	}
+
+	//if subscribed is still not true, it can only mean that all the existing slots are taken
+	//Show an error message in that case
+	if(!subscribed)
+		log_error("event_manager:subscribe_with_sender", "Could not subscribe to %s event", event_name_get(event_type));
+}
+
+void event_manager_unsubscribe_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender)
+{
+	assert(event_manager && event_type < EVT_MAX);
+
+	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
+	{
+		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
+		if(subscription->type != EST_SENDER) continue;
+		if(subscription->event_type == event_type && 
+		   subscription->Subscription_Sender.handler == handler_func && 
+		   subscription->Subscription_Sender.sender == sender)
+		{
+			subscription->event_type                  = EVT_NONE;
+			subscription->type                        = EST_NONE;
+			subscription->Subscription_Sender.handler = NULL;
+			subscription->Subscription_Sender.sender  = NULL;
+			break;
+		}
+	}
+}
 
-		if(subscription->event_type == event->type && subscription->subscriber == entity && subscription->handler_with_object)
+void event_manager_unsubscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender)
+{
+	assert(event_manager && event_type < EVT_MAX);
+
+	for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++)
+	{
+		struct Event_Subscription* subscription = &event_manager->event_subsciptions[i];
+		if(subscription->type != EST_SUBSCRIBER) continue;
+		if(subscription->event_type == event_type && 
+		   subscription->Subscription_Subscriber_Sender.handler == handler_func && 
+		   subscription->Subscription_Subscriber_Sender.subscriber == subscriber &&
+		   subscription->Subscription_Subscriber_Sender.sender == sender)
 		{
-			subscription->handler_with_object(event, (void*)entity);
+			subscription->event_type                                = EVT_NONE;
+			subscription->type                                      = EST_NONE;
+			subscription->Subscription_Subscriber_Sender.handler    = NULL;
+			subscription->Subscription_Subscriber_Sender.subscriber = NULL;
+			subscription->Subscription_Subscriber_Sender.sender     = NULL;
 			break;
 		}
 	}

src/game/event.h

@@ -9,7 +9,9 @@ struct Entity;
 struct Trigger;
 
 typedef void (*Event_Handler) (const struct Event* event);
-typedef void (*Event_Handler_Object) (const struct Event* event, void* subscriber);
+typedef void (*Event_Handler_Sender) (const struct Event* event, void* sender);
+typedef void (*Event_Handler_Subscriber) (const struct Event* event, void* subscriber);
+typedef void (*Event_Handler_Subscriber_Sender) (const struct Event* event, void* subscriber, void* sender);
 
 
 enum Event_Types
@@ -33,8 +35,10 @@ enum Event_Types
 enum Event_Subscription_Type
 {
 	EST_NONE = 0,
-	EST_WITHOUT_OBJECT,
+	EST_WITHOUT_OBJECTS,
-	EST_WITH_OBJECT
+	EST_SENDER,
+	EST_SUBSCRIBER,
+	EST_SUBSCRIBER_SENDER
 };
 
 struct Input_Map_Event
@@ -120,16 +124,29 @@ struct Event_Subscription
 	int event_type;
 	union
 	{
-		struct
+		struct 
 		{
 			Event_Handler handler;
-		};
+		} Subscription_Without_Objects;
 
-		struct
+		struct 
 		{
-			Event_Handler_Object handler_with_object;
+			Event_Handler_Subscriber handler;
-			void*                subscriber;
+			void*                    subscriber;
-		};
+		} Subscription_Subscriber;
+
+		struct 
+		{
+			Event_Handler_Sender handler;
+			void*                sender;
+		} Subscription_Sender;
+
+		struct 
+		{
+			Event_Handler_Subscriber_Sender handler;
+			void*                           sender;
+			void*                           subscriber;
+		} Subscription_Subscriber_Sender;
 	};
 };
 
@@ -142,9 +159,13 @@ struct Event_Manager
 
 void          event_manager_init(struct Event_Manager* event_manager);
 void          event_manager_subscribe(struct Event_Manager* event_manager, int event_type, Event_Handler event_handler_func);
-void          event_manager_subscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber);
+void          event_manager_subscribe_with_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender);
-void          event_manager_unsubscribe(struct Event_Manager* event_manager, int event_type, Event_Handler subscriber);
+void          event_manager_subscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber);
-void          event_manager_unsubscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber);
+void          event_manager_subscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender);
+void          event_manager_unsubscribe(struct Event_Manager* event_manager, int event_type, Event_Handler handler_func);
+void          event_manager_unsubscribe_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender);
+void          event_manager_unsubscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber);
+void          event_manager_unsubscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender);
 struct Event* event_manager_create_new_event(struct Event_Manager* event_manager);
 void          event_manager_send_event(struct Event_Manager* event_manager, struct Event* event);
 void          event_manager_send_event_entity(struct Event_Manager* event_manager, struct Event* event, struct Entity* entity);

src/game/scene_funcs.c

@@ -1,7 +1,11 @@
 #include "scene_funcs.h"
+#include "event.h"
+#include "game.h"
 
 #include "../common/log.h"
 
+static void scene_on_end_trigger(const struct Event* event, void* sender);
+
 void scene_init_stub(struct Scene* scene)
 {
 	log_warning("Scene Init Stub Called");
@@ -14,10 +18,30 @@ void scene_cleanup_stub(struct Scene* scene)
 
 void scene_1_init(struct Scene* scene)
 {
-	log_message("Scene 1 init called");
+	struct Trigger* scene_end_trigger = scene_trigger_find(scene, "Scene_End_Trigger");
+	if(scene_end_trigger)
+	{
+		struct Event_Manager* event_manager = game_state_get()->event_manager;
+		event_manager_subscribe_with_sender(event_manager, EVT_TRIGGER, &scene_on_end_trigger, scene_end_trigger);
+		log_message("Scene End Event set");
+	}
+	else
+	{
+		log_message("Trigger not found");
+	}
 }
 
 void scene_1_cleanup(struct Scene* scene)
 {
-	log_message("Scene 1 cleanup called");
+	struct Trigger* scene_end_trigger = scene_trigger_find(scene, "Scene_End_Trigger");
+	if(scene_end_trigger)
+	{
+		struct Event_Manager* event_manager = game_state_get()->event_manager;
+		event_manager_unsubscribe_sender(event_manager, EVT_TRIGGER, &scene_on_end_trigger, scene_end_trigger);
+	}
+}
+
+void scene_on_end_trigger(const struct Event* event, void* sender)
+{
+	log_message("Scene_End_Trigger triggered, Move to next scene now!");
 }

todo.txt

@@ -1,13 +1,15 @@
 Todo:
-	- Player/enemies getting hit by bullets
 	- Win/fail States
+	- Save scene init/cleanup funcs if there are any assigned when saving scene
+	- Save case sensitive file names when scene entity entries
+	- Investigate whether toggle trigger is working properly
+	- Player/enemies getting hit by bullets
 	- Remove excessive repitition in scene and editor code that handles multiple entity types
 	- Allow switching to editor mode when game is in pause mode
 	- Rendering Additions:
 		- Color grading
 		- Shadow mapping
 		- Cube mapping for sky dome etc
-	- Add event sender along with events
 	- Implement flag for ignoring collisions with certain entities
 	- Implement game gui either with a separate nuklear context or as part of existing context
 	- Fix rotate gizmo's origin not being set to the selected entity