Conversation code cleaned up a lot.

include/dawn/dawn.h

@@ -8,6 +8,7 @@
 
 // Display / Rendering
 #include "display/animation/easing.h"
+#include "display/animation/queue.h"
 #include "display/animation/timeline.h"
 #include "display/debug/grid.h"
 

include/dawn/display/animation/queue.h

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../../libs.h"
+
+#define ANIMATION_QUEUE_ITEM_MAX 128
+#define ANIMATION_QUEUE_START 0xFF
+
+typedef struct _queueaction_t queueaction_t;
+typedef struct _queue_t queue_t;
+
+/**
+ * Callback for queue events.
+ * @param conversation Conversation this text is attached to.
+ * @param text Text item that is being used in the callback
+ * @param i Index of the item in the queue.
+ */
+typedef void queuecallback_t(queue_t *queue, queueaction_t *action, uint8_t i);
+
+typedef struct _queueaction_t {
+  /** Index that the action is within the queue */
+  uint8_t index;
+
+  /** Pointer to any custom user data */
+  void *data;
+
+  /** Callback to fire the moment the action is active in the queue */
+  queuecallback_t *onStart;
+
+  /** Callback to fire when this action has ended */
+  queuecallback_t *onEnd;
+
+  /** Callback to fire every update of this queue while action is active. */
+  queuecallback_t *onUpdate;
+} queueaction_t;
+
+typedef struct _queue_t {
+  /** Array of items within the queue. */
+  queueaction_t items[ANIMATION_QUEUE_ITEM_MAX];
+  uint8_t count;
+
+  /** Current index within the array of actions that is currently processing */
+  uint8_t current;
+  
+  /** Internal timeline tracking */
+  float timeline;
+
+  /** Time that the current aciton started */
+  float actionStarted;
+
+  /** Delay Queue Item Storage */
+  float delays[ANIMATION_QUEUE_ITEM_MAX];
+} queue_t;

include/dawn/display/animation/timeline.h

@@ -26,6 +26,9 @@ typedef void timelinecallback_t(timeline_t *timeline, timelineaction_t *action,
 );
 
 typedef struct _timelineaction_t {
+  /** Pointer to any custom user data the timeline action wants to use. */
+  void *data;
+
   /**
    * The time that this action should occur within the timeline
    * set to 0 or less to start immediately.
@@ -50,7 +53,9 @@ typedef struct _timelineaction_t {
   bool loop;
 
   timelinecallback_t *onStart;
+  
   timelinecallback_t *onDuration;
+
   timelinecallback_t *onEnd;
 } timelineaction_t;
 

include/dawn/vn/vnconversation.h

@@ -7,62 +7,30 @@
 
 #pragma once
 #include "../libs.h"
+#include "../display/animation/queue.h"
 #include "vntextbox.h"
 
-#define VN_CONVERSATION_TEXT_COUNT_MAX 32
-
-// Type Forwarders
-
-typedef struct _vnconversationtext_t vnconversationtext_t;
 typedef struct _vnconversation_t vnconversation_t;
 
-/**
+typedef struct {
- * Callback for conversation text events.
+  /** Pointer to the original conversation */
- * @param conversation Conversation this text is attached to.
+  vnconversation_t *conversation;
- * @param text Text item that is being used in the callback
- */
-typedef void vnconversationcallback_t(vnconversation_t *conversation,
-  vnconversationtext_t *text
-);
 
-typedef struct _vnconversationtext_t {
+  /** Storage for pointer to text for text conversation elements */
-  /** Pointer to any custom user data for this text action. */
-  void *data;
-
-  /** Conversation Type to decide what this data is used for */
-  uint8_t type;
-
-  /** Pointer to the string for text to display */
   char *text;
 
-  /** Time in seconds to delay if type is delay */
+  /** Character this conversation piece belongs to */
-  float delay;
+  vncharacter_t *character;
-
+} vnconversationitemdata_t;
-  /** Callback to fire the moment the text is active in the conversation */
-  vnconversationcallback_t *onStart;
-
-  /** Callback to fire every update tick of this conversation element */
-  vnconversationcallback_t *onUpdate;
-
-  /** Callback to fire when this conversation element is ended */
-  vnconversationcallback_t *onEnd;
-} vnconversationtext_t;
 
 /** Representation of a conversation, laid out similarly to a timeline. */
 typedef struct _vnconversation_t {
   /** Internal Textbox for text elements */
   vntextbox_t textbox;
 
-  /** Array of text elements */
+  /** Data Storage for items' data */
-  vnconversationtext_t texts[VN_CONVERSATION_TEXT_COUNT_MAX];
+  vnconversationitemdata_t itemData[ANIMATION_QUEUE_ITEM_MAX];
-  uint8_t textCount;
 
-  /** Internal timeline tracking */
+  /** Internal Queue for queueing the conversation */
-  float timeline;
+  queue_t actionQueue;
-
-  /** When the current text was first attached */
-  float delayStart;
-
-  /** Current index within the array of texts that is currently processing */
-  uint8_t textCurrent;
 } vnconversation_t;

src/display/animation/queue.c

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "queue.h"
+
+void queueInit(queue_t *queue) {
+  queue->timeline = 0;
+  queue->count = 0;
+  queue->current = ANIMATION_QUEUE_START;
+}
+
+queueaction_t * queueNext(queue_t *queue) {
+  queueaction_t *action;
+
+  // Is there a currently running action? If so, end it.
+  if(queue->current != ANIMATION_QUEUE_START) {
+    action = queue->items + queue->current;
+    if(action->onEnd != NULL) action->onEnd(queue, action, queue->current);
+  }
+
+  // Prepare to go to next action if there is a next action.
+  queue->current++;
+  queue->actionStarted = queue->timeline;
+  if(queue->current >= queue->count) return NULL;
+
+  // Go to next action, start it.
+  action = queue->items + queue->current;
+  if(action->onStart != NULL) action->onStart(queue, action, queue->current);
+  return action;
+}
+
+queueaction_t * queueAdd(queue_t *queue) {
+  queueaction_t *action;
+  action = queue->items + queue->count;
+  
+  action->index = queue->count;
+  action->data = NULL;
+  action->onStart = NULL;
+  action->onUpdate = NULL;
+  action->onEnd = NULL;
+
+  queue->count++;
+  return action;
+}
+
+void queueUpdate(queue_t *queue, engine_t *engine) {
+  queueaction_t *action;
+  queue->timeline += engine->time.delta;
+  if(queue->current >= queue->count) return;
+
+  action = queue->items + queue->current;
+  if(action->onUpdate != NULL) {
+    action->onUpdate(queue, action, queue->current);
+  }
+}
+
+void queueDispose(queue_t *queue) {
+  queueaction_t *action;
+  if(queue->current >= queue->count) return;
+  action = queue->items + queue->current;
+  if(action->onEnd != NULL) action->onEnd(queue, action, queue->current);
+}
+
+
+void _queueDelayUpdate(queue_t *queue, queueaction_t *action, uint8_t i) {
+  float n = queue->timeline - queue->actionStarted;
+  if(n < queue->delays[i]) return;
+  queueNext(queue);
+}
+
+queueaction_t * queueDelay(queue_t *queue, float delay) {
+  queueaction_t *action = queueAdd(queue);
+  queue->delays[action->index] = delay;
+  action->onUpdate = &_queueDelayUpdate;
+  return action;
+}

src/display/animation/queue.h

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+
+/**
+ * Initialize the queue set.
+ * @param queue Queue to initialize.
+ */
+void queueInit(queue_t *queue);
+
+/**
+ * Goes to the next action, or start the queue  if this is the first action.
+ * @param queue Queue to skip to the next action.
+ * @returns Action that was just started.
+ */
+queueaction_t * queueNext(queue_t *queue);
+
+/**
+ * Add a queue action to the queue.
+ * @param convo Queue to add to.
+ * @return Pointer to the queue action that was added.
+ */
+queueaction_t * queueAdd(queue_t *queue);
+
+/**
+ * Updates the queue logic.
+ * @param convo Queue to update.
+ * @param engine Engine used to update.
+ */
+void queueUpdate(queue_t *queue, engine_t *engine);
+
+/**
+ * Dispose the queue when finished.
+ * @param queue Queue to dispose.
+ */
+void queueDispose(queue_t *queue);
+
+
+/** Callbacks for Queue Delay Action */
+void _queueDelayUpdate(queue_t *queue, queueaction_t *action, uint8_t i);
+
+/**
+ * Adds a delay action to a queue.
+ * @param queue Queue to add to.
+ * @param delay Delay time (in seconds) to have.
+ * @return Pointer to the action added to the queue.
+ */
+queueaction_t * queueDelay(queue_t *queue, float delay);

src/platform/glfw/glwfwplatform.c

@@ -40,6 +40,8 @@ int32_t main() {
   game_t *game = malloc(sizeof(game_t));
   GAME_STATE = game;
   input_t *input = &game->engine.input;
+
+  printf("Game is %zu bytes.\n", sizeof(game_t));
   
   // Init the render resolution
   renderSetResolution(&game->engine.render,

src/test/testscene.c

@@ -8,32 +8,17 @@
 #include "testscene.h"
 
 void testSceneInit(testscene_t *scene, game_t *game) {
-  vnconversationtext_t *text;
-  
   assetFontLoad(&scene->font, "fonts/opensans/OpenSans-Bold.ttf");
   assetShaderLoad(&scene->shader,
     "shaders/textured.vert", "shaders/textured.frag"
   );
 
+  // Init Conversation
   vnConversationInit(&scene->conversation, &scene->font);
   scene->conversation.textbox.linesMax = 3;
   scene->conversation.textbox.widthMax = game->engine.render.width;
 
-  text = vnCharacterConversationSetTalking(
+  // Load characters
-    &scene->character1, &scene->conversation, true
-  );
-
-  text = vnConversationAdd(&scene->conversation);
-  text->text = "Hello World";
-
-  // text = vnConversationAdd(&scene->conversation);
-  // text->text = "How are you today?";
-
-  text = vnCharacterConversationSetTalking(
-    &scene->character1, &scene->conversation, false
-  );
-
-
   assetTextureLoad(&scene->pennyEyes, "characters/penny/textures/eyes_sm.png");
   assetTextureLoad(&scene->pennyBody, "characters/penny/textures/body_sm.png");
   assetTextureLoad(&scene->pennyMouth,"characters/penny/textures/mouth_sm.png");
@@ -58,7 +43,11 @@ void testSceneInit(testscene_t *scene, game_t *game) {
   scene->character1.y = 0;
   scene->character2.y = 0;
 
-  vnConversationNext(&scene->conversation);
+  // Add some conversation peices.
+  vnConversationTalk(&scene->conversation, "Hello World", &scene->character1);
+  queueDelay(&scene->conversation.actionQueue, 3);
+  vnConversationTalk(&scene->conversation, "What?", &scene->character1);
+  queueNext(&scene->conversation.actionQueue);
 }
 
 void testSceneRender(testscene_t *scene, game_t *game) {

src/test/testscene.h

@@ -15,8 +15,8 @@
 #include "../display/gui/font.h"
 #include "../display/texture.h"
 #include "../vn/vncharacter.h"
-#include "../vn/vnconversation.h"
+#include "../vn/conversation/vnconversation.h"
-#include "../vn/vncharacterconversation.h"
+#include "../vn/conversation/talk.h"
 
 typedef struct {
   shader_t shader;

src/vn/conversation/talk.c

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "talk.h"
+
+void _vnConversationTalkStart(queue_t *queue,queueaction_t *action,uint8_t i) {
+  vnconversationitemdata_t *data;
+  data = (vnconversationitemdata_t *)action->data;
+  vnTextBoxSetText(&data->conversation->textbox, data->text);
+  if(data->character != NULL) data->character->talking = true;
+}
+
+void _vnConversationTalkUpdate(queue_t *queue,queueaction_t *action,uint8_t i) {
+  vnconversationitemdata_t *data;
+  data = (vnconversationitemdata_t *)action->data;
+  if(data->conversation->textbox.state & VN_TEXTBOX_STATE_CLOSED) {
+    if(data->character != NULL) data->character->talking = false;
+    queueNext(queue);
+  }
+}
+
+queueaction_t * vnConversationTalk(
+  vnconversation_t *conversation,
+  char *text,
+  vncharacter_t *character
+) {
+  queueaction_t *action;
+  vnconversationitemdata_t *data;
+
+  action = vnConversationAdd(conversation);
+  action->onStart = &_vnConversationTalkStart;
+  action->onUpdate = &_vnConversationTalkUpdate;
+
+  data = (vnconversationitemdata_t *)action->data;
+  data->text = text;
+  data->character = character;
+
+  return action;
+}

src/vn/conversation/talk.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "vnconversation.h"
+#include "../../display/animation/queue.h"
+
+/** Event Callback for when the talk action starts */
+void _vnConversationTalkStart(queue_t *q, queueaction_t *a, uint8_t i);
+
+/** Event Callback for when the talk action updates */
+void _vnConversationTalkUpdate(queue_t *q, queueaction_t *a, uint8_t i);
+
+/**
+ * Adds text to the conversation queue.
+ * 
+ * @param conversation Conversation to add the text to.
+ * @param text Text to add.
+ * @param character Character that is talking, or NULL.
+ * @return Pointer to the queue item that was added for this text.
+ */
+queueaction_t * vnConversationTalk(
+  vnconversation_t *conversation,
+  char *text,
+  vncharacter_t *character
+);

src/vn/conversation/vnconversation.c

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "vnconversation.h"
+
+void vnConversationInit(vnconversation_t *convo, font_t *font) {
+  vnTextBoxInit(&convo->textbox, font);
+  queueInit(&convo->actionQueue);
+}
+
+queueaction_t * vnConversationAdd(vnconversation_t *conversation) {
+  queueaction_t *action;
+  vnconversationitemdata_t *data;
+
+  // Update action queue data item.
+  data = conversation->itemData + conversation->actionQueue.count;
+  data->conversation = conversation;
+
+  // Add to queue
+  action = queueAdd(&conversation->actionQueue);
+  action->data = data;
+
+  return action;
+}
+
+void vnConversationUpdate(vnconversation_t *convo, engine_t *engine) {
+  queueUpdate(&convo->actionQueue, engine);
+  vnTextBoxUpdate(&convo->textbox, engine);
+}
+
+void vnConversationRender(vnconversation_t *convo, shader_t *shader) {
+  vnTextBoxRender(&convo->textbox, shader);
+}
+
+void vnConversationDispose(vnconversation_t *convo) {
+  queueDispose(&convo->actionQueue);
+  vnTextBoxDispose(&convo->textbox);
+}

src/vn/conversation/vnconversation.h

@@ -7,9 +7,10 @@
 
 #pragma once
 #include <dawn/dawn.h>
-#include  "vntextbox.h"
+#include  "../gui/vntextbox.h"
-#include "../util/array.h"
+#include "../../util/array.h"
-#include "../display/animation/timeline.h"
+#include "../../display/animation/timeline.h"
+#include "../../display/animation/queue.h"
 
 /**
  * Initialize the conversation set. After adding your first conversation element
@@ -19,20 +20,12 @@
  */
 void vnConversationInit(vnconversation_t *convo, font_t *font);
 
-/**
- * Goes to the next conversation element, or start the conversation if this is
- * the first element.
- * @param convo Conversation to skip to the next text of.
- */
-void vnConversationNext(vnconversation_t *convo);
-
 /**
  * Add a text element to the conversation.
  * @param convo Conversation to add to.
- * @return The pointer to the text element.
+ * @return The pointer to the queue element.
  */
-vnconversationtext_t * vnConversationAdd(vnconversation_t *convo);
+queueaction_t * vnConversationAdd(vnconversation_t *convo);
-
 
 /**
  * Updates the conversation logic and the wrapped textbox.

src/vn/gui/vntextbox.h

@@ -7,12 +7,12 @@
 
 #pragma once
 #include <dawn/dawn.h>
-#include "../display/primitive.h"
+#include "../../display/primitive.h"
-#include "../display/shader.h"
+#include "../../display/shader.h"
-#include "../display/animation/timeline.h"
+#include "../../display/animation/timeline.h"
-#include "../display/gui/font.h"
+#include "../../display/gui/font.h"
-#include "../display/primitives/quad.h"
+#include "../../display/primitives/quad.h"
-#include "../input/input.h"
+#include "../../input/input.h"
 
 /**
  * Initializes the Visual Novel Text Box to its initial state.

src/vn/vncharacter.h

@@ -12,7 +12,6 @@
 #include "../display/primitive.h"
 #include "../display/shader.h"
 #include "../display/primitives/quad.h"
-#include "vnconversation.h"
 
 void vnCharacterInit(vncharacter_t *character,
   texture_t *textureEyes,

src/vn/vncharacterconversation.c

@@ -1,35 +0,0 @@
-/**
- * Copyright (c) 2021 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "vncharacterconversation.h"
-
-void _vnCharacterConversationTalkingOn(
-  vnconversation_t *convo, vnconversationtext_t *text
-) {
-  vncharacter_t *character = (vncharacter_t *)text->data;
-  character->talking = true;
-  vnConversationNext(convo);
-}
-void _vnCharacterConversationTalkingOff(
-  vnconversation_t *convo, vnconversationtext_t *text
-) {
-  vncharacter_t *character = (vncharacter_t *)text->data;
-  character->talking = false;
-  vnConversationNext(convo);
-}
-
-vnconversationtext_t * vnCharacterConversationSetTalking(
-  vncharacter_t *character, vnconversation_t *conversation, bool talking
-) {
-  vnconversationtext_t *text;
-  text = vnConversationAdd(conversation);
-  text->data = character;
-  text->onStart = talking ? (
-    &_vnCharacterConversationTalkingOn 
-  ) : &_vnCharacterConversationTalkingOff;
-  return text;
-}

src/vn/vncharacterconversation.h

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) 2021 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include <dawn/dawn.h>
-#include "vncharacter.h"
-#include "vnconversation.h"
-
-vnconversationtext_t * vnCharacterConversationSetTalking(
-  vncharacter_t *character, vnconversation_t *conversation, bool talking
-);

src/vn/vnconversation.c

@@ -1,80 +0,0 @@
-/**
- * Copyright (c) 2021 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "vnconversation.h"
-
-void vnConversationInit(vnconversation_t *convo, font_t *font) {
-  convo->textCount = 0x00;
-  convo->textCurrent = 0xFF;
-  convo->timeline = 0;
-  convo->delayStart = 0;
-  vnTextBoxInit(&convo->textbox, font);
-}
-
-void vnConversationNext(vnconversation_t *convo) {
-  vnconversationtext_t *text;
-
-  // Fire onend for current text
-  if(convo->textCurrent != 0xFF) {
-    text = convo->texts + convo->textCurrent;
-    if(text->onEnd != NULL) text->onEnd(convo, text);
-  }
-
-  // Next Text
-  convo->textCurrent++;
-  if(convo->textCurrent >= convo->textCount) return;
-  convo->delayStart = convo->timeline;
-  text = convo->texts + convo->textCurrent;
-
-  
-  if(text->text != NULL) vnTextBoxSetText(&convo->textbox, text->text);
-  if(text->onStart != NULL) text->onStart(convo, text);
-}
-
-vnconversationtext_t * vnConversationAdd(vnconversation_t *conversation) {
-  vnconversationtext_t *text = conversation->texts + conversation->textCount;
-  conversation->textCount++;
-  text->data = NULL;
-  text->onStart = NULL;
-  text->onUpdate = NULL;
-  text->onEnd = NULL;
-  text->text = NULL;
-  return text;
-}
-
-void vnConversationUpdate(vnconversation_t *convo, engine_t *engine) {
-  vnconversationtext_t *text;
-
-  // Get the current text
-  convo->timeline += engine->time.delta;
-  if(convo->textCurrent >= convo->textCount) return;
-
-  text = convo->texts + convo->textCurrent;
-  if(text->onUpdate) text->onUpdate(convo, text);
-
-  if(text->text != NULL) {
-    vnTextBoxUpdate(&convo->textbox, engine);
-    if(convo->textbox.state & VN_TEXTBOX_STATE_CLOSED) {
-      vnConversationNext(convo);
-    }
-  } else if(text->delay > 0) {
-    if(convo->delayStart + text->delay <= convo->timeline) {
-      vnConversationNext(convo);
-    }
-  }
-}
-
-void vnConversationRender(vnconversation_t *convo, shader_t *shader) {
-  vnTextBoxRender(&convo->textbox, shader);
-}
-
-void vnConversationDispose(vnconversation_t *convo) {
-  vnconversationtext_t *text;
-  text = convo->texts + convo->textCurrent;
-  if(text->onEnd != NULL) text->onEnd(convo, text);
-  vnTextBoxDispose(&convo->textbox);
-}