assets_test.c

@@ -43,8 +43,8 @@ int main(void)
             DrawTextEx(*fnt, "Press C to play a sound", (Vector2){64, 64}, 24, 1, RED);
 
             // Draw the static Sprite and animated Sprite
-            draw_sprite(spr, (Vector2){64,128}, 0.0f, false);
+            draw_sprite(spr, (Vector2){64,128}, false);
-            draw_sprite(spr2, (Vector2){64,180}, 0.0f, true);
+            draw_sprite(spr2, (Vector2){64,180}, true);
         EndDrawing();
 
         // Update the animated Sprite

engine/EC.h

@@ -183,7 +183,6 @@ typedef struct Sprite {
     Texture2D* texture;
     Vector2 frame_size;
     Vector2 origin;
-    Vector2 anchor;
     int frame_count;
     int current_frame;
     int elapsed;

engine/assets.c

@@ -8,7 +8,7 @@
 #include "zstd.h"
 #include <stdio.h>
 
-uint8_t n_loaded[6] = {0};
+uint8_t n_loaded[5] = {0};
 
 // Hard limit number of 
 typedef struct TextureData
@@ -36,18 +36,12 @@ typedef struct LevelPackData
     LevelPack_t pack;
     char name[MAX_NAME_LEN];
 }LevelPackData_t;
-typedef struct EmitterConfData
-{
-    EmitterConfig_t conf;
-    char name[MAX_NAME_LEN];
-}EmitterConfData_t;
 
 static TextureData_t textures[MAX_TEXTURES];
 static FontData_t fonts[MAX_FONTS];
 static SoundData_t sfx[MAX_SOUNDS];
 static SpriteData_t sprites[MAX_SPRITES];
 static LevelPackData_t levelpacks[MAX_LEVEL_PACK];
-static EmitterConfData_t emitter_confs[MAX_EMITTER_CONF];
 
 #define DECOMPRESSOR_INBUF_LEN 4096
 #define DECOMPRESSOR_OUTBUF_LEN 4096
@@ -112,7 +106,7 @@ Sprite_t* add_sprite(Assets_t* assets, const char* name, Texture2D* texture)
 {
     uint8_t spr_idx = n_loaded[1];
     assert(spr_idx < MAX_SPRITES);
-    memset(sprites + spr_idx, 0, sizeof(SpriteData_t));
+    memset(sprites + spr_idx, 0, sizeof(Sprite_t));
     sprites[spr_idx].sprite.texture = texture;
     strncpy(sprites[spr_idx].name, name, MAX_NAME_LEN);
     sc_map_put_s64(&assets->m_sprites, sprites[spr_idx].name, spr_idx);
@@ -142,18 +136,6 @@ Font* add_font(Assets_t* assets, const char* name, const char* path)
     return &fonts[fnt_idx].font;
 }
 
-EmitterConfig_t* add_emitter_conf(Assets_t* assets, const char* name, Sprite_t* sprite)
-{
-    uint8_t emitter_idx = n_loaded[5];
-    assert(emitter_idx < MAX_EMITTER_CONF);
-    memset(emitter_confs + emitter_idx, 0, sizeof(EmitterConfData_t));
-    emitter_confs[emitter_idx].conf.spr = sprite;
-    strncpy(emitter_confs[emitter_idx].name, name, MAX_NAME_LEN);
-    sc_map_put_s64(&assets->m_emitter_confs, emitter_confs[emitter_idx].name, emitter_idx);
-    n_loaded[5]++;
-    return &emitter_confs[emitter_idx].conf;
-}
-
 LevelPack_t* add_level_pack(Assets_t* assets, const char* name, const char* path)
 {
     FILE* file = fopen(path, "rb");
@@ -183,7 +165,6 @@ LevelPack_t* add_level_pack(Assets_t* assets, const char* name, const char* path
     return &levelpacks[pack_idx].pack;
 }
 
-
 static LevelPack_t* add_level_pack_zst(Assets_t* assets, const char* name, FILE* file)
 {
     LevelPackData_t* pack_info = levelpacks + n_loaded[4];
@@ -357,7 +338,6 @@ void init_assets(Assets_t* assets)
     sc_map_init_s64(&assets->m_textures, MAX_TEXTURES, 0);
     sc_map_init_s64(&assets->m_sounds, MAX_SOUNDS, 0);
     sc_map_init_s64(&assets->m_levelpacks, MAX_LEVEL_PACK, 0);
-    sc_map_init_s64(&assets->m_emitter_confs, MAX_EMITTER_CONF, 0);
     level_decompressor.ctx = ZSTD_createDCtx();
 }
 
@@ -385,7 +365,6 @@ void free_all_assets(Assets_t* assets)
     sc_map_clear_s64(&assets->m_sounds);
     sc_map_clear_s64(&assets->m_sprites);
     sc_map_clear_s64(&assets->m_levelpacks);
-    sc_map_clear_s64(&assets->m_emitter_confs);
     memset(n_loaded, 0, sizeof(n_loaded));
 }
 
@@ -397,7 +376,6 @@ void term_assets(Assets_t* assets)
     sc_map_term_s64(&assets->m_sounds);
     sc_map_term_s64(&assets->m_sprites);
     sc_map_term_s64(&assets->m_levelpacks);
-    sc_map_term_s64(&assets->m_emitter_confs);
     ZSTD_freeDCtx(level_decompressor.ctx);
 }
 
@@ -421,17 +399,6 @@ Sprite_t* get_sprite(Assets_t* assets, const char* name)
     return NULL;
 }
 
-EmitterConfig_t* get_emitter_conf(Assets_t* assets, const char* name)
-{
-    uint8_t emitter_idx = sc_map_get_s64(&assets->m_emitter_confs, name);
-    if (sc_map_found(&assets->m_emitter_confs))
-    {
-        return &emitter_confs[emitter_idx].conf;
-    }
-    return NULL;
-}
-
-
 Sound* get_sound(Assets_t* assets, const char* name)
 {
     uint8_t snd_idx = sc_map_get_s64(&assets->m_sounds, name);
@@ -462,7 +429,7 @@ LevelPack_t* get_level_pack(Assets_t* assets, const char* name)
     return NULL;
 }
 
-void draw_sprite(Sprite_t* spr, Vector2 pos, float rotation, bool flip_x)
+void draw_sprite(Sprite_t* spr, Vector2 pos, bool flip_x)
 {
     Rectangle rec = {
         spr->origin.x + spr->frame_size.x * spr->current_frame,
@@ -470,18 +437,5 @@ void draw_sprite(Sprite_t* spr, Vector2 pos, float rotation, bool flip_x)
         spr->frame_size.x * (flip_x ? -1:1),
         spr->frame_size.y
     };
-    //DrawTextureRec(*spr->texture, rec, pos, WHITE);
+    DrawTextureRec(*spr->texture, rec, pos, WHITE);
-    Rectangle dest = {
-        .x = pos.x - spr->anchor.x,
-        .y = pos.y - spr->anchor.y,
-        .width = spr->frame_size.x,
-        .height = spr->frame_size.y
-    };
-    DrawTexturePro(
-        *spr->texture,
-        rec,
-        dest,
-        spr->anchor,
-        rotation, WHITE
-    );
 }

engine/assets.h

@@ -4,7 +4,6 @@
 #include "EC.h"
 #include "raylib.h"
 #include "rres.h"
-#include "particle_sys.h"
 
 typedef struct Assets
 {
@@ -13,7 +12,6 @@ typedef struct Assets
     struct sc_map_s64 m_fonts;
     struct sc_map_s64 m_sprites;
     struct sc_map_s64 m_levelpacks;
-    struct sc_map_s64 m_emitter_confs;
 }Assets_t;
 
 typedef struct LevelTileInfo
@@ -59,16 +57,14 @@ Texture2D* add_texture_rres(Assets_t* assets, const char* name, const char* file
 LevelPack_t* add_level_pack_rres(Assets_t* assets, const char* name, const char* filename, const RresFileInfo_t* rres_file);
 
 Sprite_t* add_sprite(Assets_t* assets, const char* name, Texture2D* texture);
-EmitterConfig_t* add_emitter_conf(Assets_t* assets, const char* name, Sprite_t* sprite);
 
 Texture2D* get_texture(Assets_t* assets, const char* name);
 Sprite_t* get_sprite(Assets_t* assets, const char* name);
-EmitterConfig_t* get_emitter_conf(Assets_t* assets, const char* name);
 Sound* get_sound(Assets_t* assets, const char* name);
 Font* get_font(Assets_t* assets, const char* name);
 LevelPack_t* get_level_pack(Assets_t* assets, const char* name);
 
-void draw_sprite(Sprite_t* spr, Vector2 pos, float rotation, bool flip_x);
+void draw_sprite(Sprite_t* spr, Vector2 pos, bool flip_x);
 
 typedef struct SFX
 {

engine/engine.c

@@ -94,7 +94,6 @@ void init_scene(Scene_t* scene, system_func_t render_func, action_func_t action_
     sc_map_init_64(&scene->action_map, 32, 0);
     sc_array_init(&scene->systems);
     init_entity_manager(&scene->ent_manager);
-    init_particle_system(&scene->part_sys);
 
     //scene->scene_type = scene_type;
     scene->render_function = render_func;
@@ -107,7 +106,6 @@ void free_scene(Scene_t* scene)
     sc_map_term_64(&scene->action_map);
     sc_array_term(&scene->systems);
     free_entity_manager(&scene->ent_manager);
-    deinit_particle_system(&scene->part_sys);
 }
 
 inline void update_scene(Scene_t* scene)
@@ -117,7 +115,6 @@ inline void update_scene(Scene_t* scene)
     {
         sys(scene);
     }
-    update_particle_system(&scene->part_sys);
 }
 
 inline void render_scene(Scene_t* scene)

engine/engine.h

@@ -22,6 +22,7 @@ typedef struct GameEngine {
     unsigned int curr_scene;
     Assets_t assets;
     SFXList_t sfx_list;
+    ParticleSystem_t part_sys;
     // Maintain own queue to handle key presses
     struct sc_queue_32 key_buffer;
 } GameEngine_t;
@@ -49,7 +50,6 @@ struct Scene {
     EntityManager_t ent_manager;
     //SceneType_t scene_type;
     SceneState_t state;
-    ParticleSystem_t part_sys;
     GameEngine_t *engine;
 };
 

engine/engine_conf.h

@@ -9,9 +9,8 @@
 #define MAX_NAME_LEN 32
 #define MAX_LEVEL_PACK 4
 #define N_SFX 18
-#define MAX_EMITTER_CONF 8
+#define MAX_PARTICLE_CONF 8
-//#define MAX_PARTICLE_EMITTER 8
+#define MAX_PARTICLE_EMITTER 16
-#define MAX_ACTIVE_PARTICLE_EMITTER 32
 #define MAX_PARTICLES 10
 
 #define MAX_TILE_TYPES 16

engine/particle_sys.c

@@ -1,5 +1,4 @@
 #include "particle_sys.h"
-#include "assets.h"
 #include <string.h>
 #include <stdlib.h>
 #include <math.h>
@@ -11,16 +10,14 @@ void init_particle_system(ParticleSystem_t* system)
 {
     memset(system, 0, sizeof(ParticleSystem_t));
     sc_queue_init(&system->free_list);
-    for ( uint32_t i = 1; i <= MAX_ACTIVE_PARTICLE_EMITTER; ++i)
+    for ( uint32_t i = 1; i <= MAX_PARTICLE_EMITTER; ++i)
     {
         sc_queue_add_last(&system->free_list, i);
     }
     system->tail_idx = 0;
 }
-void play_particle_emitter(ParticleSystem_t* system, const ParticleEmitter_t* in_emitter)
+void add_particle_emitter(ParticleSystem_t* system, const ParticleEmitter_t* in_emitter)
 {
-    if (in_emitter == NULL) return;
-
     if (sc_queue_empty(&system->free_list)) return;
     uint32_t idx = sc_queue_del_first(&system->free_list);
     system->emitter_list[system->tail_idx].next = idx;
@@ -36,23 +33,24 @@ void play_particle_emitter(ParticleSystem_t* system, const ParticleEmitter_t* in
     // Generate particles based on type
     for (uint32_t i = 0; i < emitter->n_particles; ++i)
     {
-        uint32_t lifetime = (emitter->config->particle_lifetime[1] - emitter->config->particle_lifetime[0]);
+        uint32_t lifetime = (emitter->config.particle_lifetime[1] - emitter->config.particle_lifetime[0]);
-        emitter->particles[i].timer = emitter->config->particle_lifetime[0];
+        emitter->particles[i].timer = emitter->config.particle_lifetime[0];
         emitter->particles[i].timer += rand() % lifetime;
         emitter->particles[i].alive = true;
 
-        float angle = emitter->config->launch_range[1] - emitter->config->launch_range[0];
+        float angle = emitter->config.launch_range[1] - emitter->config.launch_range[0];
         angle *= (float)rand() / (float)RAND_MAX;
-        angle += emitter->config->launch_range[0];
+        angle += emitter->config.launch_range[0];
         if(angle > 360) angle -= 360;
         if(angle < -360) angle += 360;
+        angle *= PI / 180;
 
-        float speed = emitter->config->speed_range[1] - emitter->config->speed_range[0];
+        float speed = emitter->config.speed_range[1] - emitter->config.speed_range[0];
         speed *= (float)rand() / (float)RAND_MAX;
-        speed += emitter->config->speed_range[0];
+        speed += emitter->config.speed_range[0];
 
-        emitter->particles[i].velocity.x = speed * cos(angle * PI / 180);
+        emitter->particles[i].velocity.x = speed * cos(angle);
-        emitter->particles[i].velocity.y = speed * sin(angle * PI / 180);
+        emitter->particles[i].velocity.y = speed * sin(angle);
         emitter->particles[i].position = emitter->position;
         emitter->particles[i].rotation = angle;
         emitter->particles[i].angular_vel = -10 + 20 * (float)rand() / (float)RAND_MAX;
@@ -74,9 +72,9 @@ void update_particle_system(ParticleSystem_t* system)
         {
             if (emitter->particles[i].alive)
             {
-                if (emitter->update_func != NULL)
+                if (emitter->config.update_func != NULL)
                 {
-                    emitter->update_func(emitter->particles + i, emitter->user_data);
+                    emitter->config.update_func(emitter->particles + i, emitter->config.user_data);
                 }
 
                 // Lifetime update
@@ -121,7 +119,7 @@ void draw_particle_system(ParticleSystem_t* system)
         {
             if (part->alive)
             {
-                if (emitter->config->spr == NULL)
+                if (emitter->tex == NULL || emitter->tex->width == 0)
                 {
                     Rectangle rect = {
                         .x = part->position.x,
@@ -137,7 +135,21 @@ void draw_particle_system(ParticleSystem_t* system)
                 }
                 else
                 {
-                    draw_sprite(emitter->config->spr, part->position, part->rotation, false);
+                    Rectangle source = {
+                        0.0f, 0.0f,
+                        (float)emitter->tex->width, (float)emitter->tex->height
+                    };
+                    
+                    Rectangle dest = {
+                        part->position.x, part->position.y,
+                        (float)emitter->tex->width, (float)emitter->tex->height
+                    };
+                    Vector2 origin = { (float)emitter->tex->width / 2, (float)emitter->tex->height / 2 };
+                    DrawTexturePro(
+                        *emitter->tex,
+                        source, dest, origin,
+                        part->rotation, WHITE
+                    );
                 }
             }
         }

engine/particle_sys.h

@@ -3,7 +3,6 @@
 #include "raylib.h"
 #include "engine_conf.h"
 #include "sc_queue.h"
-#include "EC.h"
 #include <stdint.h>
 #include <stdbool.h>
 
@@ -32,21 +31,21 @@ typedef struct EmitterConfig
     float speed_range[2];
     uint32_t particle_lifetime[2];
     PartEmitterType_t type;
-    Sprite_t* spr;
+    void* user_data;
-    bool one_shot;
+    particle_update_func_t update_func;
 }EmitterConfig_t;
 
 typedef struct ParticleEmitter
 {
-    const EmitterConfig_t* config;
+    EmitterConfig_t config;
     Vector2 position;
     Particle_t particles[MAX_PARTICLES];
     uint32_t n_particles;
+    Texture2D* tex;
     uint32_t timer;
+    bool one_shot;
     bool finished;
     bool active;
-    void* user_data;
-    particle_update_func_t update_func;
 }ParticleEmitter_t;
 
 typedef struct IndexList
@@ -56,8 +55,8 @@ typedef struct IndexList
 
 typedef struct ParticleSystem
 {
-    ParticleEmitter_t emitters[MAX_ACTIVE_PARTICLE_EMITTER + 1];
+    ParticleEmitter_t emitters[MAX_PARTICLE_EMITTER + 1];
-    IndexList_t emitter_list[MAX_ACTIVE_PARTICLE_EMITTER + 1];
+    IndexList_t emitter_list[MAX_PARTICLE_EMITTER + 1];
     struct sc_queue_64 free_list;
     uint32_t tail_idx;
     uint32_t n_configs;
@@ -65,7 +64,7 @@ typedef struct ParticleSystem
 }ParticleSystem_t;
 
 void init_particle_system(ParticleSystem_t* system);
-void play_particle_emitter(ParticleSystem_t* system, const ParticleEmitter_t* in_emitter);
+void add_particle_emitter(ParticleSystem_t* system, const ParticleEmitter_t* in_emitter);
 void update_particle_system(ParticleSystem_t* system);
 void draw_particle_system(ParticleSystem_t* system);
 void deinit_particle_system(ParticleSystem_t* system);

particle_test.c

@@ -52,30 +52,19 @@ int main(void)
 
     init_particle_system(&part_sys);
     Texture2D tex = LoadTexture("res/bomb.png");
-    Sprite_t spr = {
-        .texture = &tex,
-        .frame_size = (Vector2){tex.width, tex.height},
-        .origin = (Vector2){0, 0},
-        .anchor = (Vector2){tex.width / 2, tex.height / 2},
-        .frame_count = 0,
-        .current_frame = 0,
-        .elapsed = 0,
-        .speed = 0,
-        .name = "test_spr"
-    };
 
     EmitterConfig_t conf ={
-        .one_shot = true,
         .launch_range = {0, 360},
         .speed_range = {400, 2000},
         .particle_lifetime = {30, 110},
-        .spr = (tex.width == 0) ? NULL : &spr,
+        .update_func = &simple_particle_system_update
     };
 
     ParticleEmitter_t emitter = {
-        .config = &conf,
+        .config = conf,
         .n_particles = MAX_PARTICLES,
-        .update_func = &simple_particle_system_update
+        .one_shot = true,
+        .tex = &tex,
     };
 
     bool key_press = false;
@@ -88,7 +77,7 @@ int main(void)
         else if (key_press && IsMouseButtonReleased(MOUSE_BUTTON_LEFT))
         {
             emitter.position = GetMousePosition();
-            play_particle_emitter(&part_sys, &emitter);
+            add_particle_emitter(&part_sys, &emitter);
             key_press = false;
         }
         update_particle_system(&part_sys);

scene_test.c

@@ -14,7 +14,7 @@ static GameEngine_t engine =
     .max_scenes = 1,
     .curr_scene = 0,
     .assets = {0},
-    .sfx_list = {0},
+    .sfx_list = {0}
 };
 
 void update_loop(void)
@@ -35,6 +35,7 @@ int main(void)
     InitAudioDevice();
     init_engine(&engine);
 
+
 #ifndef NDEBUG
     load_from_infofile("res/assets.info.raw", &engine.assets);
     init_player_creation("res/player_spr.info", &engine.assets);
@@ -55,7 +56,6 @@ int main(void)
     load_sfx(&engine, "snd_bland", BOULDER_LAND_SFX);
     load_sfx(&engine, "snd_bubble", BUBBLE_SFX);
 
-
     LevelScene_t scene;
     scene.scene.engine = &engine;
     init_sandbox_scene(&scene);
@@ -68,15 +68,6 @@ int main(void)
     scenes[0] = &scene.scene;
     change_scene(&engine, 0);
 
-    EmitterConfig_t* conf = add_emitter_conf(&engine.assets, "pe_wood", get_sprite(&engine.assets, "bomb"));
-    conf->launch_range[0] = 240;
-    conf->launch_range[1] = 300;
-    conf->one_shot = true;
-    conf->speed_range[0] = 200;
-    conf->speed_range[1] = 300;
-    conf->particle_lifetime[0] = 30;
-    conf->particle_lifetime[1] = 110;
-
     #if defined(PLATFORM_WEB)
         puts("Setting emscripten main loop");
         emscripten_set_main_loop(update_loop, 0, 1);

scenes/editor_scene.c

@@ -225,7 +225,7 @@ static void render_editor_game_scene(Scene_t* scene)
                 uint8_t tile_sprite_idx = tilemap.tiles[i].tile_type + tilemap.tiles[i].rotation;
                 if (data->tile_sprites[tile_sprite_idx] != NULL)
                 {
-                    draw_sprite(data->tile_sprites[tile_sprite_idx], (Vector2){x,y}, 0.0f, false);
+                    draw_sprite(data->tile_sprites[tile_sprite_idx], (Vector2){x,y}, false);
                 }
                 else if (tilemap.tiles[i].tile_type == SOLID_TILE)
                 {
@@ -429,7 +429,7 @@ static void render_editor_game_scene(Scene_t* scene)
                 if (spr.sprite != NULL)
                 {
                     Vector2 pos = Vector2Add(p_ct->position, spr.offset);
-                    draw_sprite(spr.sprite, pos, 0.0f, p_cspr->flip_x);
+                    draw_sprite(spr.sprite, pos, p_cspr->flip_x);
                 }
             }
         }
@@ -448,9 +448,6 @@ static void render_editor_game_scene(Scene_t* scene)
             unsigned int y = ((p_runner->current_tile) / tilemap.width) * tilemap.tile_size;
             DrawCircle(x+16, y+16, 8, ColorAlpha(BLUE, 0.6));
         }
-
-        draw_particle_system(&scene->part_sys);
-
         for (int tile_y = min.y; tile_y < max.y; tile_y++)
         {
             for (int tile_x = min.x; tile_x < max.x; tile_x++)

scenes/game_scene.c

@@ -131,7 +131,7 @@ static void render_regular_game_scene(Scene_t* scene)
 
                 if (data->tile_sprites[tilemap.tiles[i].tile_type] != NULL)
                 {
-                    draw_sprite(data->tile_sprites[tilemap.tiles[i].tile_type], (Vector2){x,y}, 0.0f, false);
+                    draw_sprite(data->tile_sprites[tilemap.tiles[i].tile_type], (Vector2){x,y}, false);
                 }
                 else if (tilemap.tiles[i].tile_type == SOLID_TILE)
                 {
@@ -223,7 +223,7 @@ static void render_regular_game_scene(Scene_t* scene)
                 if (spr.sprite != NULL)
                 {
                     Vector2 pos = Vector2Add(p_ct->position, spr.offset);
-                    draw_sprite(spr.sprite, pos, 0.0f, p_cspr->flip_x);
+                    draw_sprite(spr.sprite, pos, p_cspr->flip_x);
                 }
                 continue;
             }
@@ -319,7 +319,6 @@ static void render_regular_game_scene(Scene_t* scene)
             unsigned int y = ((p_runner->current_tile) / tilemap.width) * tilemap.tile_size;
             DrawCircle(x+16, y+16, 8, ColorAlpha(BLUE, 0.6));
         }
-        draw_particle_system(&scene->part_sys);
 
         // Draw Border
         DrawLine(0, 0, 0, tilemap.height * tilemap.tile_size, BLACK);

scenes/game_systems.c

@@ -1,13 +1,10 @@
 #include "game_systems.h"
-#include "particle_sys.h"
 #include "ent_impl.h"
 #include "AABB.h"
 #include "EC.h"
 #include "constants.h"
 #include <stdio.h>
 
-void simple_particle_system_update(Particle_t* part, void* user_data);
-
 static const Vector2 GRAVITY = {0, GRAV_ACCEL};
 static const Vector2 UPTHRUST = {0, -GRAV_ACCEL * 1.1};
 typedef enum AnchorPoint {
@@ -1630,19 +1627,6 @@ void container_destroy_system(Scene_t* scene)
         Entity_t* p_ent =  get_entity(&scene->ent_manager, ent_idx);
         if (!p_ent->m_alive)
         {
-            if (p_ent->m_tag == CRATES_ENT_TAG)
-            {
-                const CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
-                //const CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
-                ParticleEmitter_t emitter = {
-                    .config = get_emitter_conf(&scene->engine->assets, "pe_wood"),
-                    .position = p_ctransform->position,
-                    .n_particles = 3,
-                    .user_data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data),
-                    .update_func = &simple_particle_system_update,
-                };
-                play_particle_emitter(&scene->part_sys, &emitter);
-            }
 
             Entity_t* dmg_src = NULL;
             CHurtbox_t* p_hurtbox = get_component(p_ent, CHURTBOX_T);
@@ -1943,45 +1927,3 @@ void level_end_detection_system(Scene_t* scene)
 
     }
 }
-
-void simple_particle_system_update(Particle_t* part, void* user_data)
-{
-    LevelSceneData_t* lvl_data = (LevelSceneData_t*)user_data;
-    TileGrid_t tilemap = lvl_data->tilemap;
-
-    float delta_time = DELTA_T; // TODO: Will need to think about delta time handling
-    part->velocity =
-        Vector2Add(
-            part->velocity,
-            Vector2Scale(GRAVITY, delta_time)
-        );
-
-    float mag = Vector2Length(part->velocity);
-    part->velocity = Vector2Scale(
-        Vector2Normalize(part->velocity),
-        (mag > PLAYER_MAX_SPEED)? PLAYER_MAX_SPEED:mag
-    );
-    // 3 dp precision
-    if (fabs(part->velocity.x) < 1e-3) part->velocity.x = 0;
-    if (fabs(part->velocity.y) < 1e-3) part->velocity.y = 0;
-
-    part->position = Vector2Add(
-        part->position,
-        Vector2Scale(part->velocity, delta_time)
-    );
-
-    // Level boundary collision
-    unsigned int level_width = tilemap.width * TILE_SIZE;
-    unsigned int level_height = tilemap.height * TILE_SIZE;
-    {
-
-        if(
-            part->position.x < 0 || part->position.x + part->size > level_width
-            || part->position.y < 0 || part->position.y + part->size > level_height
-        )
-        {
-            part->timer = 0;
-        }
-    }
-}
-

scenes/items_ent.c

@@ -2,7 +2,7 @@
 #include "constants.h"
 #include "raymath.h"
 
-static SpriteRenderInfo_t item_sprite_map[19] = {0};
+static SpriteRenderInfo_t item_sprite_map[18] = {0};
 
 bool init_item_creation(Assets_t* assets)
 {
@@ -27,7 +27,6 @@ bool init_item_creation(Assets_t* assets)
     item_sprite_map[16].sprite = get_sprite(assets, "m_b_crate");
     item_sprite_map[17].sprite = get_sprite(assets, "explode");
     item_sprite_map[17].offset = (Vector2){-12, -12};
-    item_sprite_map[18].sprite = get_sprite(assets, "chest");
     return true;
 }
 
@@ -224,11 +223,6 @@ Entity_t* create_chest(EntityManager_t* ent_manager, Assets_t* assets)
     p_hurtbox->def = 4;
     p_hurtbox->damage_src = -1;
 
-    CSprite_t* p_cspr = add_component(p_chest, CSPRITE_T);
-    p_cspr->sprites = item_sprite_map;
-    p_cspr->current_idx = 18;
-
-
     return p_chest;
 }
 

water_test.c

@@ -109,7 +109,7 @@ static void level_scene_render_func(Scene_t* scene)
                 if (spr.sprite != NULL)
                 {
                     Vector2 pos = Vector2Add(p_ct->position, spr.offset);
-                    draw_sprite(spr.sprite, pos, 0.0f, p_cspr->flip_x);
+                    draw_sprite(spr.sprite, pos, p_cspr->flip_x);
                 }
             }
         }