Add cutscene change event

scripts/Cutscene/CutsceneEvent.gd

@@ -6,7 +6,7 @@ func _init() -> void:
 	pass
 
 func start() -> void:
-	pass
+	started = true
 
 func update(delta:float) -> void:
 	pass
@@ -16,3 +16,6 @@ func isDone() -> bool:
 
 func end() -> void:
 	pass
+
+func reset() -> void:
+	started = false

scripts/Cutscene/Event/CutsceneChangeEvent.gd

@@ -0,0 +1,18 @@
+class_name CutsceneChangeEvent extends "res://scripts/Cutscene/CutsceneEvent.gd"
+
+var getCutscene:Callable
+var cutsceneNext:Cutscene
+
+func _init(getCutscene:Callable) -> void:
+	super._init();
+	self.getCutscene = getCutscene;
+
+func start() -> void:
+	super.start();
+	self.cutsceneNext = self.getCutscene.call(self);
+
+func end() -> void:
+	self.cutsceneNext.setupCutscene();
+	self.cutsceneNext.start();
+	var systems = get_tree().current_scene.get_node("Systems") as Systems;
+	systems.CUTSCENE.setCurrentCutscene(self.cutsceneNext);

scripts/Cutscene/Event/CutsceneConcurrentEvent.gd

@@ -34,12 +34,11 @@ func update(delta:float) -> void:
 				event.start()
 				event.started = true
 
-			if !event.isDone():
+			event.update(delta)
-				event.update(delta)
 
-				if event.isDone():
+			if event.isDone():
-					event.end()
+				event.end()
-					break
+				break
 
 	elif self.type == ConcurrentType.SEQUENTIAL:
 		if self.current >= self.events.size():
@@ -50,12 +49,11 @@ func update(delta:float) -> void:
 			evt.start()
 			evt.started = true
 
-		if !evt.isDone():
+		evt.update(delta)
-			evt.update(delta)
 
-			if evt.isDone():
+		if evt.isDone():
-				evt.end()
+			evt.end()
-				self.current += 1
+			self.current += 1
 
 func isDone() -> bool:
 	if self.type == ConcurrentType.SEQUENTIAL:
@@ -72,4 +70,4 @@ func isDone() -> bool:
 		return false;
 
 	printerr("Invalid ConcurrentType")
-	return false;
+	return false;

scripts/Cutscene/Event/CutsceneIfEvent.gd

@@ -0,0 +1,32 @@
+class_name CutsceneIfEvent extends "res://scripts/Cutscene/CutsceneEvent.gd"
+
+var eventTrue:CutsceneEvent
+var eventFalse:CutsceneEvent
+var condition:Callable
+var result:bool = false
+
+func _init(cond:Callable, evtTrue:CutsceneEvent, evtFalse:CutsceneEvent) -> void:
+	super._init();
+	condition = cond;
+	eventTrue = evtTrue;
+	eventFalse = evtFalse;
+
+func start() -> void:
+	super.start();
+	result = self.condition.call(self);
+
+	if result:
+		eventTrue.start();
+	else:
+		eventFalse.start();
+
+func getEvent() -> CutsceneEvent:
+	if result:
+		return eventTrue;
+	return eventFalse;
+
+func update(delta:float) -> void:
+	getEvent().update(delta);
+
+func isDone() -> bool:
+	return getEvent().isDone();

scripts/Cutscene/Event/CutsceneWaitEvent.gd

@@ -10,4 +10,4 @@ func update(delta:float) -> void:
 	self.wait -= delta
 
 func isDone() -> bool:
-	return self.wait <= 0.0
+	return self.wait <= 0.0

scripts/Cutscene/Event/CutsceneWhileEvent.gd

@@ -0,0 +1,43 @@
+class_name CutsceneWhileEvent extends "res://scripts/Cutscene/CutsceneEvent.gd"
+
+var events:Array[CutsceneEvent] = []
+var callback:Callable
+var current:int = 0
+
+func _init(callback:Callable, evt:Array[CutsceneEvent]) -> void:
+	super._init();
+	self.events = evt;
+	self.callback = callback;
+
+func shouldLoop() -> bool:
+	return self.callback.call(self)
+
+func update(delta:float) -> void:
+	if self.current >= self.events.size():
+		return;
+	
+	var evt = self.events[self.current]
+	if !evt.started:
+		evt.start()
+		evt.started = true
+
+	evt.update(delta)
+
+	if evt.isDone():
+		evt.end()
+		self.current += 1
+
+	if self.current < self.events.size():
+		return
+	
+	if !self.shouldLoop():
+		return
+	
+	self.current = 0
+	for event in self.events:
+		event.reset()
+
+func isDone() -> bool:
+	if self.shouldLoop():
+		return false;
+	return self.current >= self.events.size();

scripts/Cutscene/TestCutscene.gd

@@ -2,12 +2,17 @@ class_name TestCutscene extends "res://scripts/Cutscene/Cutscene.gd"
 const CutscenePrintEvent = preload("res://scripts/Cutscene/Event/CutscenePrintEvent.gd");
 const CutsceneWaitEvent = preload("res://scripts/Cutscene/Event/CutsceneWaitEvent.gd");
 const CutsceneConcurrentEvent = preload("res://scripts/Cutscene/Event/CutsceneConcurrentEvent.gd");
+const CutsceneIfEvent = preload("res://scripts/Cutscene/Event/CutsceneIfEvent.gd");
+const CutsceneWhileEvent = preload("res://scripts/Cutscene/Event/CutsceneWhileEvent.gd");
+
+func testIf() -> bool:
+	print("Test if");
+	return true;
 
 func setupCutscene() -> void:
 	add([
-		CutsceneConcurrentEvent.new(CutsceneConcurrentEvent.ConcurrentType.PARALLEL, [
+		CutsceneWhileEvent.new(testIf,[
-			CutscenePrintEvent.new("Hello, World1"),
+			CutscenePrintEvent.new("While")
-			CutscenePrintEvent.new("Hello, World2")
+		]),
-		])
 	]);
-	pass
+	pass