Work on cutscene engine

Author: lambertjamesd

assets/dialog/mentor/intro.script

@@ -0,0 +1,13 @@
+
+global player_name: string[8]
+global intro_played: bool
+
+if intro_played then
+    exit
+end
+
+intro_played = true
+
+say "Good morining {player_name}! Today is the day you start your training. Meet me in the training area. Be quick!"
+
+walk_to mentor, exit

scripting_brainstorm.md

@@ -0,0 +1,73 @@
+# features
+the ablity to embed variables into text
+global variables/local variables
+simple computations
+conditional branching/loops
+show dialog
+run arbitrary cutscene steps
+animation
+
+## the ablity to embed variables into text
+
+```
+dialog "A text block with a {variable} embedded"
+```
+
+## global variables
+
+```
+global variable: bool
+global variable: i32
+```
+
+## local varaibles
+
+```
+local variable: bool
+```
+
+## setting variables
+
+```
+variable = expression
+```
+
+# simple computations
+
+operators and, or, not, +, -, *, /, ==, !=, >, <, <=, >=
+
+lisp? (and a b (or c d))
+infix? a and b and (c or d)
+
+# conditional
+
+```
+if condition then
+    actions
+end
+```
+
+# dialog
+
+```
+say "A message of text"
+dialog "A message of text"
+
+dialog """
+    This is a how dialog that has mulitple lines will look
+
+    This should show up after pressing a
+"""
+
+```
+
+# cutscene steps
+
+steps will look like function calls with comma separated values
+
+```
+look_at player, active_npc
+run_animation intro
+walk_to active_npc, exit
+
+```

src/cutscene/evaluation_context.c

@@ -0,0 +1,39 @@
+#include "evaluation_context.h"
+
+#include <assert.h>
+
+void evaluation_context_init(struct evaluation_context* context) {
+    context->current_stack = 0;
+}
+
+void evaluation_context_push(struct evaluation_context* context, int value) {
+    assert(context->current_stack < MAX_STACK_SIZE);
+    context->stack[context->current_stack] = value;
+    ++context->current_stack;
+}
+
+int evaluation_context_pop(struct evaluation_context* context) {
+    assert(context->current_stack > 0);
+    --context->current_stack;
+    return context->stack[context->current_stack];
+}
+
+int evaluation_context_load(void* data, enum data_type data_type, int word_offset) {
+    switch (data_type) {
+        case DATA_TYPE_NULL:
+            return 0;
+        case DATA_TYPE_S8:
+            return ((int8_t*)data)[word_offset];
+        case DATA_TYPE_S16:
+            return ((int16_t*)data)[word_offset];
+        case DATA_TYPE_S32:
+        case DATA_TYPE_F32:
+            return ((int32_t*)data)[word_offset];
+        case DATA_TYPE_BOOL: {
+            uint32_t word = ((uint32_t*)data)[word_offset >> 5];
+            return ((uint32_t)0x80000000 >> (word_offset & 0x1F)) != 0;
+        }
+        default:
+            return 0;
+    }
+}

src/cutscene/evaluation_context.h

@@ -0,0 +1,33 @@
+#ifndef __CUTSCENE_EVALUATION_CONTEXT_H__
+#define __CUTSCENE_EVALUATION_CONTEXT_H__
+
+#define MAX_STACK_SIZE  128
+
+#include <stdint.h>
+
+enum data_type {
+    DATA_TYPE_NULL,
+    DATA_TYPE_S8,
+    DATA_TYPE_S16,
+    DATA_TYPE_S32,
+
+    DATA_TYPE_BOOL,
+
+    DATA_TYPE_F32,
+};
+
+struct evaluation_context {
+    int stack[MAX_STACK_SIZE];
+    uint16_t current_stack;
+    void* local_varaibles;
+    void* global_variables;
+};
+
+void evaluation_context_init(struct evaluation_context* context);
+
+void evaluation_context_push(struct evaluation_context* context, int value);
+int evaluation_context_pop(struct evaluation_context* context);
+
+int evaluation_context_load(void* data, enum data_type data_type, int word_offset);
+
+#endif

src/cutscene/expression.c

@@ -0,0 +1 @@
+#include "expression.h"

src/cutscene/expression.h

@@ -0,0 +1,30 @@
+#ifndef __CUTSCENE_EXPRESSION_H__
+#define __CUTSCENE_EXPRESSION_H__
+
+#include <stdint.h>
+
+enum expression_type {
+    EXPRESSION_TYPE_END,
+    EXPRESSION_TYPE_LOAD_LOCAL,
+    EXPRESSION_TYPE_LOAD_GLOBAL,
+    EXPRESSION_TYPE_LOAD_LITERAL,
+    EXPRESSION_TYPE_AND,
+    EXPRESSION_TYPE_OR,
+    EXPRESSION_TYPE_NOT,
+    EXPRESSION_TYPE_ADD,
+};
+
+union expression_data {
+    struct {
+        uint16_t data_type;
+        uint16_t word_offset;
+    } load_variable;
+    int literal;
+};
+
+struct expression {
+    uint8_t* steps;
+    union expression_data* step_data;
+};
+
+#endif

src/cutscene/expression_evaluate.c

@@ -0,0 +1,49 @@
+#include "expression_evaluate.h"
+
+void expression_evaluate(struct evaluation_context* context, struct expression* expression) {
+    uint8_t* current = expression->steps;
+    union expression_data* data = expression->step_data;
+
+    while (*current != EXPRESSION_TYPE_END) {
+        switch (*current) {
+            case EXPRESSION_TYPE_LOAD_LOCAL:
+                evaluation_context_push(context, evaluation_context_load(context->local_varaibles, data->load_variable.data_type, data->load_variable.word_offset));
+                ++data;
+                break;
+            case EXPRESSION_TYPE_LOAD_GLOBAL:
+                evaluation_context_push(context, evaluation_context_load(context->global_variables, data->load_variable.data_type, data->load_variable.word_offset));
+                ++data;
+                break;
+            case EXPRESSION_TYPE_LOAD_LITERAL:
+                evaluation_context_push(context, data->literal);
+                ++data;
+                break;
+            case EXPRESSION_TYPE_AND:
+                evaluation_context_push(
+                    context,
+                    evaluation_context_pop(context) && evaluation_context_pop(context)
+                );
+                break;
+            case EXPRESSION_TYPE_OR:
+                evaluation_context_push(
+                    context,
+                    evaluation_context_pop(context) || evaluation_context_pop(context)
+                );
+                break;
+            case EXPRESSION_TYPE_NOT:
+                evaluation_context_push(
+                    context,
+                    !evaluation_context_pop(context)
+                );
+                break;
+            case EXPRESSION_TYPE_ADD:
+                evaluation_context_push(
+                    context,
+                    evaluation_context_pop(context) + evaluation_context_pop(context)
+                );
+                break;
+        }
+
+        ++current;
+    }
+}

src/cutscene/expression_evaluate.h

@@ -0,0 +1,10 @@
+#ifndef __CUTSCENE_EXPRESSION_EVALUATE_H__
+#define __CUTSCENE_EXPRESSION_EVALUATE_H__
+
+#include "expression.h"
+#include "evaluation_context.h"
+
+// the evaluation result is left on the top of th context stack
+void expression_evaluate(struct evaluation_context* context, struct expression* expression);
+
+#endif