Remove Lt from LevelEditor

src/config.h

@@ -35,4 +35,6 @@
 
 #define EDIT_FIELD_CAPACITY 256
 
+#define TMPMEM_CAPACITY (640 * KILO)
+
 #endif  // CONFIG_H_

src/game.c

@@ -19,14 +19,14 @@
 #include "game/settings.h"
 #include "game/credits.h"
 
-
 typedef struct Game {
     Lt *lt;
 
     Game_state state;
     Sprite_font font;
+    Memory tmpmem;
     LevelPicker level_picker;
-    LevelEditor *level_editor;
+    LevelEditor level_editor;
     Credits *credits;
     Level *level;
     Settings settings;
@@ -67,6 +67,10 @@ Game *create_game(const char *level_folder,
         renderer,
         "./assets/images/charmap-oldschool.bmp");
 
+    game->tmpmem.capacity = TMPMEM_CAPACITY;
+    game->tmpmem.buffer = malloc(TMPMEM_CAPACITY);
+    trace_assert(game->tmpmem.buffer);
+
     level_picker_populate(&game->level_picker, level_folder);
 
     game->credits = PUSH_LT(
@@ -111,6 +115,7 @@ Game *create_game(const char *level_folder,
         }
     }
 
+    create_level_editor(&game->level_editor, &game->cursor);
 
     game->console = PUSH_LT(
         lt,
@@ -130,6 +135,7 @@ void destroy_game(Game *game)
 {
     trace_assert(game);
     destroy_level_picker(game->level_picker);
+    free(game->tmpmem.buffer);
     RETURN_LT0(game->lt);
 }
 
@@ -151,7 +157,7 @@ int game_render(const Game *game)
     } break;
 
     case GAME_STATE_LEVEL_EDITOR: {
-        if (level_editor_render(game->level_editor, &game->camera) < 0) {
+        if (level_editor_render(&game->level_editor, &game->camera) < 0) {
             return -1;
         }
     } break;
@@ -188,7 +194,7 @@ int game_sound(Game *game)
     case GAME_STATE_LEVEL:
         return level_sound(game->level, game->sound_samples);
     case GAME_STATE_LEVEL_EDITOR:
-        level_editor_sound(game->level_editor, game->sound_samples);
+        level_editor_sound(&game->level_editor, game->sound_samples);
         return 0;
     case GAME_STATE_LEVEL_PICKER:
     case GAME_STATE_CREDITS:
@@ -248,12 +254,12 @@ int game_update(Game *game, float delta_time)
 
     case GAME_STATE_LEVEL_EDITOR: {
         if (level_editor_focus_camera(
-                game->level_editor,
+                &game->level_editor,
                 &game->camera) < 0) {
             return -1;
         }
 
-        level_editor_update(game->level_editor, delta_time);
+        level_editor_update(&game->level_editor, delta_time);
     } break;
 
     case GAME_STATE_CREDITS: {
@@ -290,7 +296,7 @@ static int game_event_running(Game *game, const SDL_Event *event)
                     game->lt,
                     game->level,
                     create_level_from_level_editor(
-                        game->level_editor));
+                        &game->level_editor));
                 if (game->level == NULL) {
                     game_switch_state(game, GAME_STATE_QUIT);
                     return -1;
@@ -323,34 +329,20 @@ static int game_event_level_picker(Game *game, const SDL_Event *event)
     case SDL_KEYDOWN: {
         switch(event->key.keysym.sym) {
         case SDLK_n: {
-            if (game->level_editor == NULL) {
+            level_editor_clean(&game->level_editor);
-                game->level_editor = PUSH_LT(
-                    game->lt,
-                    create_level_editor(&game->cursor),
-                    destroy_level_editor);
-            } else {
-                game->level_editor = RESET_LT(
-                    game->lt,
-                    game->level_editor,
-                    create_level_editor(&game->cursor));
-            }
-
-            if (game->level_editor == NULL) {
-                return -1;
-            }
 
             if (game->level == NULL) {
                 game->level = PUSH_LT(
                     game->lt,
                     create_level_from_level_editor(
-                        game->level_editor),
+                        &game->level_editor),
                     destroy_level);
             } else {
                 game->level = RESET_LT(
                     game->lt,
                     game->level,
                     create_level_from_level_editor(
-                        game->level_editor));
+                        &game->level_editor));
             }
 
             if (game->level == NULL) {
@@ -387,7 +379,7 @@ static int game_event_level_editor(Game *game, const SDL_Event *event)
                 game->lt,
                 game->level,
                 create_level_from_level_editor(
-                    game->level_editor));
+                    &game->level_editor));
             if (game->level == NULL) {
                 return -1;
             }
@@ -397,7 +389,7 @@ static int game_event_level_editor(Game *game, const SDL_Event *event)
     } break;
     }
 
-    return level_editor_event(game->level_editor, event, &game->camera);
+    return level_editor_event(&game->level_editor, event, &game->camera);
 }
 
 int game_event(Game *game, const SDL_Event *event)
@@ -540,34 +532,21 @@ int game_load_level(Game *game, const char *level_filename)
     trace_assert(game);
     trace_assert(level_filename);
 
-    if (game->level_editor == NULL) {
+    memory_clean(&game->tmpmem);
-        game->level_editor = PUSH_LT(
+    level_editor_load_from_file(&game->level_editor, &game->tmpmem, level_filename);
-            game->lt,
-            create_level_editor_from_file(level_filename, &game->cursor),
-            destroy_level_editor);
-    } else {
-        game->level_editor = RESET_LT(
-            game->lt,
-            game->level_editor,
-            create_level_editor_from_file(level_filename, &game->cursor));
-    }
-
-    if (game->level_editor == NULL) {
-        return -1;
-    }
 
     if (game->level == NULL) {
         game->level = PUSH_LT(
             game->lt,
             create_level_from_level_editor(
-                game->level_editor),
+                &game->level_editor),
             destroy_level);
     } else {
         game->level = RESET_LT(
             game->lt,
             game->level,
             create_level_from_level_editor(
-                game->level_editor));
+                &game->level_editor));
     }
 
     if (game->level == NULL) {

src/game/level/level_editor.c

@@ -12,8 +12,6 @@
 #include "ui/edit_field.h"
 #include "system/stacktrace.h"
 #include "system/nth_alloc.h"
-#include "system/lt.h"
-#include "system/lt_adapters.h"
 #include "system/log.h"
 #include "system/str.h"
 #include "config.h"
@@ -35,17 +33,9 @@ static int level_editor_dump(LevelEditor *level_editor);
 
 // TODO(#994): too much duplicate code between create_level_editor and create_level_editor_from_file
 
-LevelEditor *create_level_editor(Cursor *cursor)
+void create_level_editor(LevelEditor *level_editor, Cursor *cursor)
 {
-    Lt *lt = create_lt();
+    memset(level_editor, 0, sizeof(*level_editor));
-    LevelEditor *level_editor = PUSH_LT(
-        lt,
-        nth_calloc(1, sizeof(LevelEditor)),
-        free);
-    if (level_editor == NULL) {
-        RETURN_LT(lt, NULL);
-    }
-    level_editor->lt = lt;
 
     level_editor->edit_field_filename.font_size = LEVEL_EDITOR_EDIT_FIELD_SIZE;
     level_editor->edit_field_filename.font_color = LEVEL_EDITOR_EDIT_FIELD_COLOR;
@@ -73,49 +63,24 @@ LevelEditor *create_level_editor(Cursor *cursor)
     level_editor->notice = (FadingWigglyText) {
         .wiggly_text = {
             .text = "Level saved",
-            .color = COLOR_BLACK,
+            .color = rgba(0.0f, 0.0f, 0.0f, 0.0f),
             .scale = LEVEL_EDITOR_NOTICE_SCALE
         },
         .duration = LEVEL_EDITOR_NOTICE_DURATION,
     };
 
     level_editor->camera_scale = 1.0f;
-
     level_editor->undo_history = create_undo_history();
-
-    return level_editor;
 }
 
-LevelEditor *create_level_editor_from_file(const char *file_name, Cursor *cursor)
+void level_editor_load_from_file(LevelEditor *level_editor, Memory *tmpmem, const char *file_name)
 {
     trace_assert(file_name);
 
-    Lt *lt = create_lt();
+    if (level_editor->file_name) free(level_editor->file_name);
-    LevelEditor *level_editor = PUSH_LT(
+    level_editor->file_name = string_duplicate(file_name, NULL);
-        lt,
-        nth_calloc(1, sizeof(LevelEditor)),
-        free);
-    if (level_editor == NULL) {
-        RETURN_LT(lt, NULL);
-    }
-    level_editor->lt = lt;
 
-    level_editor->edit_field_filename.font_size = LEVEL_EDITOR_EDIT_FIELD_SIZE;
+    String input = read_whole_file(tmpmem, file_name);
-    level_editor->edit_field_filename.font_color = LEVEL_EDITOR_EDIT_FIELD_COLOR;
-
-    level_editor->file_name =
-        PUSH_LT(
-            lt,
-            string_duplicate(file_name, NULL),
-            free);
-
-    Memory tmpmem = {
-        .capacity = LEVEL_EDITOR_TMPMEM_CAPACITY,
-        .buffer = malloc(LEVEL_EDITOR_TMPMEM_CAPACITY),
-    };
-    trace_assert(tmpmem.buffer);
-
-    String input = read_whole_file(&tmpmem, file_name);
     trace_assert(input.data);
 
     String version = trim(chop_by_delim(&input, '\n'));
@@ -126,49 +91,41 @@ LevelEditor *create_level_editor_from_file(const char *file_name, Cursor *cursor
         // Nothing
     } else {
         log_fail("Version `%s` is not supported. Expected version `%s`.\n",
-                 string_to_cstr(&tmpmem, version),
+                 string_to_cstr(tmpmem, version),
                  VERSION);
-        RETURN_LT(lt, NULL);
+        return;
     }
 
     level_editor->background_layer = chop_background_layer(&input);
-    level_editor->player_layer = chop_player_layer(&tmpmem, &input);
+    level_editor->player_layer = chop_player_layer(tmpmem, &input);
-    level_editor->platforms_layer = chop_rect_layer(&tmpmem, &input, "platform", cursor);
+    rect_layer_reload(&level_editor->platforms_layer, tmpmem, &input);
-    level_editor->goals_layer = chop_point_layer(&tmpmem, &input, "goal");
+    point_layer_reload(&level_editor->goals_layer, tmpmem, &input);
-    level_editor->lava_layer = chop_rect_layer(&tmpmem, &input, "lava", cursor);
+    rect_layer_reload(&level_editor->lava_layer, tmpmem, &input);
-    level_editor->back_platforms_layer = chop_rect_layer(&tmpmem, &input, "back_platform", cursor);
+    rect_layer_reload(&level_editor->back_platforms_layer, tmpmem, &input);
-    level_editor->boxes_layer = chop_rect_layer(&tmpmem, &input, "box", cursor);
+    rect_layer_reload(&level_editor->boxes_layer, tmpmem, &input);
-    level_editor->label_layer = chop_label_layer(&tmpmem, &input, "label");
+    label_layer_reload(&level_editor->label_layer, tmpmem, &input);
-    level_editor->regions_layer = chop_rect_layer(&tmpmem, &input, "region", cursor),
+    rect_layer_reload(&level_editor->regions_layer, tmpmem, &input);
-
+    undo_history_clean(&level_editor->undo_history);
-    level_editor->layers[LAYER_PICKER_BOXES] = rect_layer_as_layer(&level_editor->boxes_layer);
+}
-    level_editor->layers[LAYER_PICKER_PLATFORMS] = rect_layer_as_layer(&level_editor->platforms_layer);
-    level_editor->layers[LAYER_PICKER_BACK_PLATFORMS] = rect_layer_as_layer(&level_editor->back_platforms_layer);
-    level_editor->layers[LAYER_PICKER_GOALS] = point_layer_as_layer(&level_editor->goals_layer);
-    level_editor->layers[LAYER_PICKER_PLAYER] = player_layer_as_layer(&level_editor->player_layer);
-    level_editor->layers[LAYER_PICKER_LAVA] = rect_layer_as_layer(&level_editor->lava_layer);
-    level_editor->layers[LAYER_PICKER_REGIONS] = rect_layer_as_layer(&level_editor->regions_layer);
-    level_editor->layers[LAYER_PICKER_BACKGROUND] = background_layer_as_layer(&level_editor->background_layer);
-    level_editor->layers[LAYER_PICKER_LABELS] = label_layer_as_layer(&level_editor->label_layer);
-
-    level_editor->drag = false;
-
-    level_editor->notice = (FadingWigglyText) {
-        .wiggly_text = {
-            .text = "Level saved",
-            .color = COLOR_BLACK,
-            .scale = LEVEL_EDITOR_NOTICE_SCALE
-        },
-        .duration = LEVEL_EDITOR_NOTICE_DURATION,
-    };
 
+void level_editor_clean(LevelEditor *level_editor)
+{
     level_editor->camera_scale = 1.0f;
-
+    level_editor->camera_position = vec(0.0f, 0.0f);
-    level_editor->undo_history = create_undo_history();
+    if (level_editor->file_name) {
-
+        free(level_editor->file_name);
-    free(tmpmem.buffer);
+        level_editor->file_name = NULL;
-
+    }
-    return level_editor;
+    level_editor->background_layer = create_background_layer(hexstr("fffda5"));
+    level_editor->player_layer = create_player_layer(vec(0.0f, 0.0f), hexstr("ff8080"));
+    rect_layer_clean(&level_editor->platforms_layer);
+    point_layer_clean(&level_editor->goals_layer);
+    rect_layer_clean(&level_editor->lava_layer);
+    rect_layer_clean(&level_editor->back_platforms_layer);
+    rect_layer_clean(&level_editor->boxes_layer);
+    label_layer_clean(&level_editor->label_layer);
+    rect_layer_clean(&level_editor->regions_layer);
+    undo_history_clean(&level_editor->undo_history);
 }
 
 void destroy_level_editor(LevelEditor *level_editor)
@@ -182,6 +139,10 @@ void destroy_level_editor(LevelEditor *level_editor)
     destroy_rect_layer(level_editor->lava_layer);
     destroy_rect_layer(level_editor->regions_layer);
     destroy_label_layer(level_editor->label_layer);
+
+    if (level_editor->file_name) {
+        free(level_editor->file_name);
+    }
 }
 
 int level_editor_render(const LevelEditor *level_editor,
@@ -274,10 +235,7 @@ int level_editor_saveas_event(LevelEditor *level_editor,
                 LEVEL_FOLDER_MAX_LENGTH,
                 "./assets/levels/%s.txt",
                 edit_field_as_text(&level_editor->edit_field_filename));
-            level_editor->file_name = PUSH_LT(
+            level_editor->file_name = string_duplicate(path, NULL);
-                level_editor->lt,
-                string_duplicate(path, NULL),
-                free);
             level_editor_dump(level_editor);
             SDL_StopTextInput();
             level_editor->state = LEVEL_EDITOR_IDLE;
@@ -440,10 +398,8 @@ static int level_editor_dump(LevelEditor *level_editor)
 {
     trace_assert(level_editor);
 
-    FILE *filedump = PUSH_LT(
+    FILE *filedump = fopen(level_editor->file_name, "w");
-        level_editor->lt,
+    trace_assert(filedump);
-        fopen(level_editor->file_name, "w"),
-        fclose_lt);
 
     if (fprintf(filedump, "%s\n", VERSION) < 0) {
         return -1;
@@ -457,7 +413,7 @@ static int level_editor_dump(LevelEditor *level_editor)
         }
     }
 
-    fclose(RELEASE_LT(level_editor->lt, filedump));
+    fclose(filedump);
 
     fading_wiggly_text_reset(&level_editor->notice);
     level_editor->save = 1;

src/game/level/level_editor.h

@@ -20,7 +20,6 @@ typedef enum {
 
 struct LevelEditor
 {
-    Lt *lt;
     LevelEditorState state;
     Vec2f camera_position;
     float camera_scale;
@@ -47,11 +46,12 @@ struct LevelEditor
     int click;
     int save;
 
-    const char *file_name;
+    char *file_name;
 };
 
-LevelEditor *create_level_editor(Cursor *cursor);
+void create_level_editor(LevelEditor *level_editor, Cursor *cursor);
-LevelEditor *create_level_editor_from_file(const char *file_name, Cursor *cursor);
+void level_editor_load_from_file(LevelEditor *level_editor, Memory *tmpmem, const char *file_name);
+void level_editor_clean(LevelEditor *level_editor);
 void destroy_level_editor(LevelEditor *level_editor);
 
 int level_editor_render(const LevelEditor *level_editor,

src/game/level/level_editor/label_layer.c

@@ -4,7 +4,6 @@
 
 #include "system/stacktrace.h"
 #include "system/nth_alloc.h"
-#include "system/lt.h"
 #include "system/str.h"
 #include "system/log.h"
 #include "math/vec.h"
@@ -157,15 +156,15 @@ LabelLayer create_label_layer(const char *id_name_prefix)
     return result;
 }
 
-LabelLayer chop_label_layer(Memory *memory,
+void label_layer_reload(LabelLayer *label_layer,
-                            String *input,
+                        Memory *memory,
-                            const char *id_name_prefix)
+                        String *input)
 {
+    trace_assert(label_layer);
     trace_assert(memory);
     trace_assert(input);
-    trace_assert(id_name_prefix);
 
-    LabelLayer result = create_label_layer(id_name_prefix);
+    label_layer_clean(label_layer);
 
     int n = atoi(string_to_cstr(memory, trim(chop_by_delim(input, '\n'))));
     char id[LABEL_LAYER_ID_MAX_SIZE];
@@ -194,13 +193,20 @@ LabelLayer chop_label_layer(Memory *memory,
             min_size_t(LABEL_LAYER_TEXT_MAX_SIZE - 1,
                        label_text_string.count));
 
-        dynarray_push(&result.ids, id);
+        dynarray_push(&label_layer->ids, id);
-        dynarray_push(&result.positions, &position);
+        dynarray_push(&label_layer->positions, &position);
-        dynarray_push(&result.colors, &color);
+        dynarray_push(&label_layer->colors, &color);
-        dynarray_push(&result.texts, label_text);
+        dynarray_push(&label_layer->texts, label_text);
     }
+}
 
-    return result;
+void label_layer_clean(LabelLayer *label_layer)
+{
+    trace_assert(label_layer);
+    dynarray_clear(&label_layer->ids);
+    dynarray_clear(&label_layer->positions);
+    dynarray_clear(&label_layer->colors);
+    dynarray_clear(&label_layer->texts);
 }
 
 static inline

src/game/level/level_editor/label_layer.h

@@ -38,9 +38,11 @@ LayerPtr label_layer_as_layer(LabelLayer *label_layer);
 // NOTE: create_label_layer and create_label_layer_from_line_stream do
 // not own id_name_prefix
 LabelLayer create_label_layer(const char *id_name_prefix);
-LabelLayer chop_label_layer(Memory *memory,
+void label_layer_reload(LabelLayer *label_layer,
-                            String *input,
+                        Memory *memory,
-                            const char *id_name_prefix);
+                        String *input);
+void label_layer_clean(LabelLayer *label_layer);
+
 static inline
 void destroy_label_layer(LabelLayer label_layer)
 {

src/game/level/level_editor/player_layer.h

@@ -3,7 +3,6 @@
 
 #include "color_picker.h"
 #include "layer.h"
-#include "system/lt.h"
 #include "system/memory.h"
 #include "system/s.h"
 

src/game/level/level_editor/point_layer.c

@@ -5,7 +5,6 @@
 #include "dynarray.h"
 #include "game/camera.h"
 #include "system/log.h"
-#include "system/lt.h"
 #include "system/nth_alloc.h"
 #include "system/stacktrace.h"
 #include "system/str.h"
@@ -153,15 +152,15 @@ PointLayer create_point_layer(const char *id_name_prefix)
     return result;
 }
 
-PointLayer chop_point_layer(Memory *memory,
+void point_layer_reload(PointLayer *point_layer,
-                            String *input,
+                        Memory *memory,
-                            const char *id_name_prefix)
+                        String *input)
 {
+    trace_assert(point_layer);
     trace_assert(memory);
     trace_assert(input);
-    trace_assert(id_name_prefix);
 
-    PointLayer result = create_point_layer(id_name_prefix);
+    point_layer_clean(point_layer);
 
     int n = atoi(string_to_cstr(memory, trim(chop_by_delim(input, '\n'))));
     char id[ENTITY_MAX_ID_SIZE];
@@ -176,15 +175,18 @@ PointLayer chop_point_layer(Memory *memory,
         memset(id, 0, ENTITY_MAX_ID_SIZE);
         memcpy(id, string_id.data, min_size_t(ENTITY_MAX_ID_SIZE - 1, string_id.count));
 
-        dynarray_push(&result.positions, &point);
+        dynarray_push(&point_layer->positions, &point);
-        dynarray_push(&result.colors, &color);
+        dynarray_push(&point_layer->colors, &color);
-        dynarray_push(&result.ids, id);
+        dynarray_push(&point_layer->ids, id);
     }
+}
 
-    result.selection = -1;
+void point_layer_clean(PointLayer *point_layer)
-    result.color_picker = create_color_picker_from_rgba(COLOR_RED);
+{
-
+    trace_assert(point_layer);
-    return result;
+    dynarray_clear(&point_layer->positions);
+    dynarray_clear(&point_layer->colors);
+    dynarray_clear(&point_layer->ids);
 }
 
 static inline

src/game/level/level_editor/point_layer.h

@@ -35,9 +35,11 @@ LayerPtr point_layer_as_layer(PointLayer *point_layer);
 // NOTE: create_point_layer and create_point_layer_from_line_stream do
 // not own id_name_prefix
 PointLayer create_point_layer(const char *id_name_prefix);
-PointLayer chop_point_layer(Memory *memory,
+void point_layer_reload(PointLayer *point_layer,
-                             String *input,
+                        Memory *memory,
-                             const char *id_name_prefix);
+                        String *input);
+void point_layer_clean(PointLayer *point_layer);
+
 
 static inline
 void destroy_point_layer(PointLayer point_layer)

src/game/level/level_editor/rect_layer.c

@@ -2,7 +2,6 @@
 #include <errno.h>
 
 #include "game/camera.h"
-#include "system/lt.h"
 #include "system/stacktrace.h"
 #include "system/nth_alloc.h"
 #include "system/log.h"
@@ -817,15 +816,13 @@ RectLayer create_rect_layer(const char *id_name_prefix, Cursor *cursor)
     return result;
 }
 
-RectLayer chop_rect_layer(Memory *memory,
+void rect_layer_reload(RectLayer *layer, Memory *memory, String *input)
-                          String *input,
-                          const char *id_name_prefix,
-                          Cursor *cursor)
 {
+    trace_assert(layer);
     trace_assert(memory);
     trace_assert(input);
 
-    RectLayer layer = create_rect_layer(id_name_prefix, cursor);
+    rect_layer_clean(layer);
 
     int n = atoi(string_to_cstr(memory, trim(chop_by_delim(input, '\n'))));
     char id[ENTITY_MAX_ID_SIZE];
@@ -845,9 +842,9 @@ RectLayer chop_rect_layer(Memory *memory,
             string_id.data,
             min_size_t(ENTITY_MAX_ID_SIZE - 1, string_id.count));
 
-        dynarray_push(&layer.rects, &rect);
+        dynarray_push(&layer->rects, &rect);
-        dynarray_push(&layer.colors, &color);
+        dynarray_push(&layer->colors, &color);
-        dynarray_push(&layer.ids, id);
+        dynarray_push(&layer->ids, id);
 
         Action action = {
             .type = ACTION_NONE,
@@ -875,10 +872,17 @@ RectLayer chop_rect_layer(Memory *memory,
             }
         }
 
-        dynarray_push(&layer.actions, &action);
+        dynarray_push(&layer->actions, &action);
     }
+}
 
-    return layer;
+void rect_layer_clean(RectLayer *rect_layer)
+{
+    trace_assert(rect_layer);
+    dynarray_clear(&rect_layer->ids);
+    dynarray_clear(&rect_layer->rects);
+    dynarray_clear(&rect_layer->colors);
+    dynarray_clear(&rect_layer->actions);
 }
 
 int rect_layer_render(const RectLayer *layer, const Camera *camera, int active)

src/game/level/level_editor/rect_layer.h

@@ -47,10 +47,8 @@ LayerPtr rect_layer_as_layer(RectLayer *layer);
 // not own id_name_prefix
 RectLayer create_rect_layer(const char *id_name_prefix,
                             Cursor *cursor);
-RectLayer chop_rect_layer(Memory *memory,
+void rect_layer_reload(RectLayer *rect_layer, Memory *memory, String *input);
-                          String *input,
+void rect_layer_clean(RectLayer *rect_layer);
-                          const char *id_name_prefix,
-                          Cursor *cursor);
 
 static inline
 void destroy_rect_layer(RectLayer layer)

src/game/level/level_editor/undo_history.c

@@ -4,7 +4,6 @@
 #include <SDL.h>
 
 #include "system/nth_alloc.h"
-#include "system/lt.h"
 #include "system/stacktrace.h"
 #include "undo_history.h"
 #include "config.h"
@@ -59,3 +58,12 @@ void undo_history_pop(UndoHistory *undo_history)
         ring_buffer_pop(&undo_history->actions);
     }
 }
+
+void undo_history_clean(UndoHistory *undo_history)
+{
+    trace_assert(undo_history);
+
+    while (undo_history->actions.count) {
+        ring_buffer_pop(&undo_history->actions);
+    }
+}

src/game/level/level_editor/undo_history.h

@@ -23,6 +23,8 @@ void undo_history_push(UndoHistory *undo_history,
                        size_t context_data_size);
 void undo_history_pop(UndoHistory *undo_history);
 
+void undo_history_clean(UndoHistory *undo_history);
+
 static inline
 int undo_history_empty(UndoHistory *undo_history)
 {