Destroy level editor layers in destroy_level_editor

[nothing.git] / src / game / level / lava.c

diff --git a/src/game/level/lava.c b/src/game/level/lava.c
index 04c48a25498a6f09080eb099180bf9f961b97f2c..ec580d4c075fe526ffac321a4f0ba7d5ee13990e 100644 (file)
--- a/src/game/level/lava.c
+++ b/src/game/level/lava.c
@@ -1,72 +1,64 @@
-#include <SDL2/SDL.h>
-#include <assert.h>
+#include <SDL.h>
+#include "system/stacktrace.h"
 #include <stdio.h>
 
 #include "color.h"
 #include "game/level/lava/wavy_rect.h"
-#include "game/level/player/rigid_rect.h"
 #include "lava.h"
 #include "math/rect.h"
-#include "system/error.h"
 #include "system/lt.h"
+#include "system/nth_alloc.h"
+#include "system/log.h"
+#include "game/level/level_editor/rect_layer.h"
 
 #define LAVA_BOINGNESS 2500.0f
 
-struct lava_t {
-    lt_t *lt;
+struct Lava {
+    Lt *lt;
     size_t rects_count;
-    wavy_rect_t **rects;
+    Wavy_rect **rects;
 };
 
-lava_t *create_lava_from_stream(FILE *stream)
+Lava *create_lava_from_rect_layer(const RectLayer *rect_layer)
 {
-    assert(stream);
+    Lt *lt = create_lt();
 
-    lt_t *lt = create_lt();
-    if (lt == NULL) {
-        return NULL;
-    }
-
-    lava_t *lava = PUSH_LT(lt, malloc(sizeof(lava_t)), free);
+    Lava *lava = PUSH_LT(lt, nth_calloc(1, sizeof(Lava)), free);
     if (lava == NULL) {
-        throw_error(ERROR_TYPE_LIBC);
-        RETURN_LT(lt, NULL);
-    }
-
-    if (fscanf(stream, "%lu", &lava->rects_count) < 0) {
-        throw_error(ERROR_TYPE_LIBC);
         RETURN_LT(lt, NULL);
     }
+    lava->lt = lt;
 
-    lava->rects = PUSH_LT(lt, malloc(sizeof(wavy_rect_t*) * lava->rects_count), free);
+    lava->rects_count = rect_layer_count(rect_layer);
+    lava->rects = PUSH_LT(lt, nth_calloc(lava->rects_count, sizeof(Wavy_rect*)), free);
     if (lava->rects == NULL) {
-        throw_error(ERROR_TYPE_LIBC);
         RETURN_LT(lt, NULL);
     }
 
+    const Rect *rects = rect_layer_rects(rect_layer);
+    const Color *colors = rect_layer_colors(rect_layer);
     for (size_t i = 0; i < lava->rects_count; ++i) {
-        lava->rects[i] = PUSH_LT(lt, create_wavy_rect_from_stream(stream), destroy_wavy_rect);
+        lava->rects[i] = PUSH_LT(lt, create_wavy_rect(rects[i], colors[i]), destroy_wavy_rect);
         if (lava->rects[i] == NULL) {
             RETURN_LT(lt, NULL);
         }
     }
 
-    lava->lt = lt;
-
     return lava;
 }
 
-void destroy_lava(lava_t *lava)
+void destroy_lava(Lava *lava)
 {
-    assert(lava);
+    trace_assert(lava);
     RETURN_LT0(lava->lt);
 }
 
-int lava_render(const lava_t *lava,
-                camera_t *camera)
+/* TODO(#449): lava does not render its id in debug mode */
+int lava_render(const Lava *lava,
+                const Camera *camera)
 {
-    assert(lava);
-    assert(camera);
+    trace_assert(lava);
+    trace_assert(camera);
 
     for (size_t i = 0; i < lava->rects_count; ++i) {
         if (wavy_rect_render(lava->rects[i], camera) < 0) {
@@ -77,9 +69,9 @@ int lava_render(const lava_t *lava,
     return 0;
 }
 
-int lava_update(lava_t *lava, float delta_time)
+int lava_update(Lava *lava, float delta_time)
 {
-    assert(lava);
+    trace_assert(lava);
 
     for (size_t i = 0; i < lava->rects_count; ++i) {
         if (wavy_rect_update(lava->rects[i], delta_time) < 0) {
@@ -90,10 +82,10 @@ int lava_update(lava_t *lava, float delta_time)
     return 0;
 }
 
-bool lava_overlaps_rect(const lava_t *lava,
-                        rect_t rect)
+bool lava_overlaps_rect(const Lava *lava,
+                        Rect rect)
 {
-    assert(lava);
+    trace_assert(lava);
 
     for (size_t i = 0; i < lava->rects_count; ++i) {
         if (rects_overlap(wavy_rect_hitbox(lava->rects[i]), rect)) {
@@ -104,20 +96,21 @@ bool lava_overlaps_rect(const lava_t *lava,
     return 0;
 }
 
-void lava_float_rigid_rect(lava_t *lava, rigid_rect_t *object)
+void lava_float_rigid_body(Lava *lava, RigidBodies *rigid_bodies, RigidBodyId id)
 {
-    assert(lava);
+    trace_assert(lava);
 
-    const rect_t object_hitbox = rigid_rect_hitbox(object);
+    const Rect object_hitbox = rigid_bodies_hitbox(rigid_bodies, id);
     for (size_t i = 0; i < lava->rects_count; ++i) {
-        const rect_t lava_hitbox = wavy_rect_hitbox(lava->rects[i]);
+        const Rect lava_hitbox = wavy_rect_hitbox(lava->rects[i]);
         if (rects_overlap(object_hitbox, lava_hitbox)) {
-            const rect_t overlap_area = rects_overlap_area(object_hitbox, lava_hitbox);
+            const Rect overlap_area = rects_overlap_area(object_hitbox, lava_hitbox);
             const float k = overlap_area.w * overlap_area.h / (object_hitbox.w * object_hitbox.h);
-            rigid_rect_apply_force(
-                object,
+            rigid_bodies_apply_force(
+                rigid_bodies,
+                id,
                 vec(0.0f, -k * LAVA_BOINGNESS));
-            rigid_rect_damper(object, vec(0.0f, -0.9f));
+            rigid_bodies_damper(rigid_bodies, id, vec(0.0f, -0.9f));
         }
     }
 }