Add toggle to activate crates on spawn

Add tile rotation. This is kind of a temp solution, since any sprite
could use rotation. So, may need to extend this for general sprite

scene_test.c

@@ -34,6 +34,10 @@ int main(void)
     init_sandbox_scene(&scene);
     scene.data.tile_sprites[ONEWAY_TILE] = get_sprite(&engine.assets, "tl_owp");
     scene.data.tile_sprites[LADDER] = get_sprite(&engine.assets, "tl_ldr");
+    scene.data.tile_sprites[SPIKES] = get_sprite(&engine.assets, "d_spikes");
+    scene.data.tile_sprites[SPIKES + TILE_90CWROT] = get_sprite(&engine.assets, "l_spikes");
+    scene.data.tile_sprites[SPIKES + TILE_90CCWROT] = get_sprite(&engine.assets, "r_spikes");
+    scene.data.tile_sprites[SPIKES + TILE_180ROT] = get_sprite(&engine.assets, "u_spikes");
     scenes[0] = &scene.scene;
     change_scene(&engine, 0);
 

scenes/editor_scene.c

@@ -30,6 +30,7 @@ enum EntitySpawnSelection {
 #define MAX_SPAWN_TYPE 14
 static unsigned int current_spawn_selection = 0;
 static bool metal_toggle = false;
+static bool crate_activation = false;
 
 #define SELECTION_TILE_SIZE 32
 #define SELECTION_TILE_HALFSIZE (SELECTION_TILE_SIZE >> 1)
@@ -37,6 +38,29 @@ static bool metal_toggle = false;
 #define SELECTION_REGION_WIDTH (SELECTION_TILE_SIZE * MAX_SPAWN_TYPE)
 #define SELECTION_REGION_HEIGHT SELECTION_TILE_SIZE
 
+static char* get_spawn_selection_string(enum EntitySpawnSelection sel)
+{
+    switch(sel)
+    {
+        case TOGGLE_TILE: return "solid tile";
+        case TOGGLE_ONEWAY: return "wooden tile";
+        case TOGGLE_LADDER: return "ladder";
+        case TOGGLE_SPIKE: return "spike";
+        case TOGGLE_WATER: return "water";
+        case TOGGLE_AIR_POCKET: return "air pocket";
+        case SPAWN_CRATE: return (metal_toggle) ? "metal crate" : "wooden crate";
+        case SPAWN_CRATE_ARROW_D: return (metal_toggle) ? "metal down arrow crate" : "wooden down arrow crate";
+        case SPAWN_CRATE_ARROW_U: return (metal_toggle) ? "metal up arrow crate" : "wooden up arrow crate";
+        case SPAWN_CRATE_ARROW_L: return (metal_toggle) ? "metal left arrow crate" : "wooden left arrow crate";
+        case SPAWN_CRATE_ARROW_R: return (metal_toggle) ? "metal right arrow crate" : "wooden right arrow crate";
+        case SPAWN_CRATE_BOMB: return (metal_toggle) ? "metal bomb crate" : "wooden bomb crate";
+        case SPAWN_BOULDER: return "boulder";
+        case SPAWN_WATER_RUNNER: return "water runner";
+        default: return "unknown";
+    }
+}
+
+
 
 static inline unsigned int get_tile_idx(int x, int y, const TileGrid_t* tilemap)
 {
@@ -75,9 +99,10 @@ static void level_scene_render_func(Scene_t* scene)
                 DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, water_colour);
             }
 
-            if (data->tile_sprites[tilemap.tiles[i].tile_type] != NULL)
+            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[tilemap.tiles[i].tile_type], (Vector2){x,y}, false);
+                draw_sprite(data->tile_sprites[tile_sprite_idx], (Vector2){x,y}, false);
             }
             else if (tilemap.tiles[i].tile_type == SOLID_TILE)
             {
@@ -453,6 +478,16 @@ static void level_scene_render_func(Scene_t* scene)
             break;
         }
 
+        draw_pos.x = data->game_rec.x + (MAX_SPAWN_TYPE + 1) * SELECTION_TILE_SIZE;
+        sprintf(buffer, "Crate %s on spawn", crate_activation? "active" : "inactive");
+        DrawText(buffer, draw_pos.x, draw_pos.y, 20, BLACK);
+        draw_pos.x = data->game_rec.x;
+        draw_pos.y += SELECTION_TILE_SIZE + 5;
+        sprintf(buffer, "Selection: %s", get_spawn_selection_string(current_spawn_selection));
+        DrawText(buffer, draw_pos.x, draw_pos.y, 20, BLACK);
+        draw_pos.x = data->game_rec.x + (MAX_SPAWN_TYPE + 1) * SELECTION_TILE_SIZE;
+        DrawText("Press R to reset the map\nO,P to cycle the selection, T to toggle crate spawn behaviour", draw_pos.x, draw_pos.y, 16, BLACK);
+
         // For DEBUG
         const int gui_x = data->game_rec.x + data->game_rec.width + 10;
         sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_ent)
@@ -489,7 +524,7 @@ static void level_scene_render_func(Scene_t* scene)
     EndDrawing();
 }
 
-static void spawn_crate(Scene_t* scene, unsigned int tile_idx, bool metal, ContainerItem_t item)
+static void spawn_crate(Scene_t* scene, unsigned int tile_idx, bool metal, ContainerItem_t item, bool active)
 {
     LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     Entity_t* p_crate = create_crate(&scene->ent_manager, &scene->engine->assets, metal, item);
@@ -497,6 +532,7 @@ static void spawn_crate(Scene_t* scene, unsigned int tile_idx, bool metal, Conta
     CTransform_t* p_ctransform = get_component(p_crate, CTRANSFORM_COMP_T);
     p_ctransform->position.x = (tile_idx % data->tilemap.width) * TILE_SIZE;
     p_ctransform->position.y = (tile_idx / data->tilemap.width) * TILE_SIZE;
+    p_ctransform->active = active;
 }
 
 static void spawn_boulder(Scene_t* scene, unsigned int tile_idx)
@@ -577,25 +613,27 @@ static void toggle_block_system(Scene_t* scene)
                     }
                 break;
                 case SPAWN_CRATE:
-                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_EMPTY);
+                {
+                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_EMPTY, crate_activation);
+                }
                 break;
                 case SPAWN_BOULDER:
                     spawn_boulder(scene, tile_idx);
                 break;
                 case SPAWN_CRATE_ARROW_L:
-                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_LEFT_ARROW);
+                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_LEFT_ARROW, crate_activation);
                 break;
                 case SPAWN_CRATE_ARROW_R:
-                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_RIGHT_ARROW);
+                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_RIGHT_ARROW, crate_activation);
                 break;
                 case SPAWN_CRATE_ARROW_U:
-                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_UP_ARROW);
+                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_UP_ARROW, crate_activation);
                 break;
                 case SPAWN_CRATE_ARROW_D:
-                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_DOWN_ARROW);
+                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_DOWN_ARROW, crate_activation);
                 break;
                 case SPAWN_CRATE_BOMB:
-                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_BOMB);
+                    spawn_crate(scene, tile_idx, metal_toggle, CONTAINER_BOMB, crate_activation);
                 break;
                 case SPAWN_WATER_RUNNER:
                 {
@@ -761,6 +799,9 @@ static void level_do_action(Scene_t* scene, ActionType_t action, bool pressed)
             case ACTION_METAL_TOGGLE:
                 if (!pressed) metal_toggle = !metal_toggle;
             break;
+            case ACTION_CRATE_ACTIVATION:
+                if (!pressed) crate_activation = !crate_activation;
+            break;
             case ACTION_EXIT:
                 if(scene->engine != NULL)
                 {
@@ -834,6 +875,7 @@ void init_sandbox_scene(LevelScene_t* scene)
     sc_map_put_64(&scene->scene.action_map, KEY_O, ACTION_PREV_SPAWN);
     sc_map_put_64(&scene->scene.action_map, KEY_P, ACTION_NEXT_SPAWN);
     sc_map_put_64(&scene->scene.action_map, KEY_M, ACTION_METAL_TOGGLE);
+    sc_map_put_64(&scene->scene.action_map, KEY_T, ACTION_CRATE_ACTIVATION);
     sc_map_put_64(&scene->scene.action_map, KEY_Q, ACTION_EXIT);
     sc_map_put_64(&scene->scene.action_map, KEY_R, ACTION_RESTART);
 

scenes/engine/actions.h

@@ -10,6 +10,7 @@ typedef enum ActionType
     ACTION_NEXT_SPAWN,
     ACTION_PREV_SPAWN,
     ACTION_METAL_TOGGLE,
+    ACTION_CRATE_ACTIVATION,
     ACTION_CONFIRM,
     ACTION_EXIT,
     ACTION_RESTART,

scenes/engine/collisions.h

@@ -10,9 +10,18 @@ typedef enum SolidType
     ONE_WAY,
 }SolidType_t;
 
+typedef enum TileRotation
+{
+    TILE_NOROTATE = 0,
+    TILE_90CWROT,
+    TILE_90CCWROT,
+    TILE_180ROT
+}TileRotation_t;
+
 typedef struct Tile {
     unsigned int tile_type;
     SolidType_t solid;
+    TileRotation_t rotation;
     uint8_t def;
     uint8_t water_level;
     uint8_t max_water_level;

scenes/items_ent.c

@@ -2,7 +2,7 @@
 #include "constants.h"
 #include "raymath.h"
 
-static SpriteRenderInfo_t item_sprite_map[17] = {0};
+static SpriteRenderInfo_t item_sprite_map[18] = {0};
 
 bool init_item_creation(Assets_t* assets)
 {
@@ -25,6 +25,8 @@ bool init_item_creation(Assets_t* assets)
     item_sprite_map[14].sprite = get_sprite(assets, "m_da_crate");
     item_sprite_map[15].sprite = get_sprite(assets, "w_b_crate");
     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};
     return true;
 }
 
@@ -184,6 +186,10 @@ Entity_t* create_explosion(EntityManager_t* ent_manager, Assets_t* assets)
     p_ctransform->position.y -= 24;
     p_hitbox->boxes[0] = (Rectangle){0, 0, TILE_SIZE + 48, TILE_SIZE + 48};
 
+    CSprite_t* p_cspr = add_component(p_explosion, CSPRITE_T);
+    p_cspr->sprites = item_sprite_map;
+    p_cspr->current_idx = 17;
+
     CLifeTimer_t* p_clifetimer = add_component(p_explosion, CLIFETIMER_T);
     p_clifetimer->life_time = 3;
     return p_explosion;

scenes/scene_impl.h

@@ -19,12 +19,14 @@ typedef enum TileType {
     SPIKES,
 } TileType_t;
 
+#define MAX_TILE_SPRITES 32
+
 typedef struct LevelSceneData {
     TileGrid_t tilemap;
     RenderTexture2D game_viewport;
     Rectangle game_rec;
     Camera2D cam;
-    Sprite_t* tile_sprites[MAX_TILE_TYPES];
+    Sprite_t* tile_sprites[MAX_TILE_SPRITES];
     LevelPack_t* level_pack;
     unsigned int current_level;
 }LevelSceneData_t;

scenes/scene_systems.c

@@ -32,6 +32,7 @@ void init_level_scene_data(LevelSceneData_t* data, uint32_t max_tiles, Tile_t* t
     {
         data->tilemap.tiles[i].solid = NOT_SOLID;
         data->tilemap.tiles[i].tile_type = EMPTY_TILE;
+        data->tilemap.tiles[i].rotation = TILE_NOROTATE;
         data->tilemap.tiles[i].moveable = true;
         data->tilemap.tiles[i].max_water_level = 4;
         sc_map_init_64v(&data->tilemap.tiles[i].entities_set, 16, 0);
@@ -171,6 +172,7 @@ void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_ty
 
     }
 
+    tilemap->tiles[tile_idx].rotation = TILE_NOROTATE;
     if (new_type == SPIKES)
     {
         // Priority: Down, Up, Left, Right
@@ -183,16 +185,19 @@ void change_a_tile(TileGrid_t* tilemap, unsigned int tile_idx, TileType_t new_ty
         {
             tilemap->tiles[tile_idx].offset = (Vector2){0,0};
             tilemap->tiles[tile_idx].size = (Vector2){32,16};
+            tilemap->tiles[tile_idx].rotation = TILE_180ROT;
         }
         else if (tile_idx % tilemap->width != 0 && tilemap->tiles[tile_idx - 1].tile_type == SOLID_TILE)
         {
             tilemap->tiles[tile_idx].offset = (Vector2){0,0};
             tilemap->tiles[tile_idx].size = (Vector2){16,32};
+            tilemap->tiles[tile_idx].rotation = TILE_90CWROT;
         }
         else if ((tile_idx + 1) % tilemap->width != 0 && tilemap->tiles[tile_idx + 1].tile_type == SOLID_TILE)
         {
             tilemap->tiles[tile_idx].offset = (Vector2){16,0};
             tilemap->tiles[tile_idx].size = (Vector2){16,32};
+            tilemap->tiles[tile_idx].rotation = TILE_90CCWROT;
         }
         else
         {