diff --git a/scenes/editor_scene.c b/scenes/editor_scene.c
index faaf961..c4cc90c 100644
--- a/scenes/editor_scene.c
+++ b/scenes/editor_scene.c
@@ -717,7 +717,6 @@ void init_level_scene(LevelScene_t* scene)
 
     scene->data.tilemap.width = DEFAULT_MAP_WIDTH;
     scene->data.tilemap.height = DEFAULT_MAP_HEIGHT;
-    scene->data.tilemap.max_water_level = MAX_WATER_LEVEL;
     scene->data.tilemap.tile_size = TILE_SIZE;
     scene->data.tilemap.n_tiles = scene->data.tilemap.width * scene->data.tilemap.height;
     assert(scene->data.tilemap.n_tiles <= MAX_N_TILES);
@@ -728,6 +727,7 @@ void init_level_scene(LevelScene_t* scene)
         all_tiles[i].solid = NOT_SOLID;
         all_tiles[i].tile_type = EMPTY_TILE;
         all_tiles[i].moveable = true;
+        all_tiles[i].max_water_level = 4;
         sc_map_init_64v(&all_tiles[i].entities_set, 16, 0);
         all_tiles[i].size = (Vector2){TILE_SIZE, TILE_SIZE};
     }
diff --git a/scenes/engine/collisions.h b/scenes/engine/collisions.h
index 7d03577..7a1dc72 100644
--- a/scenes/engine/collisions.h
+++ b/scenes/engine/collisions.h
@@ -14,7 +14,8 @@ typedef struct Tile {
     unsigned int tile_type;
     SolidType_t solid;
     uint8_t def;
-    unsigned int water_level;
+    uint8_t water_level;
+    uint8_t max_water_level;
     struct sc_map_64v entities_set;
     Vector2 offset;
     Vector2 size;
@@ -27,7 +28,7 @@ typedef struct TileGrid
     unsigned int height;
     unsigned int n_tiles;
     unsigned int tile_size;
-    unsigned int max_water_level;
+    //unsigned int max_water_level;
     Tile_t* tiles;
 }TileGrid_t;
 
diff --git a/scenes/water_flow.c b/scenes/water_flow.c
index fcf9ef3..e658e7d 100644
--- a/scenes/water_flow.c
+++ b/scenes/water_flow.c
@@ -70,7 +70,7 @@ static void runner_BFS(const TileGrid_t* tilemap, CWaterRunner_t* p_crunner, int
 
         if (
             ((curr_height <= init_height && !first_reached) || curr_height > curr_low)
-            && curr_tile->water_level < tilemap->max_water_level
+            && curr_tile->water_level < curr_tile->max_water_level
         )
         {
             first_reached = true;
@@ -84,8 +84,8 @@ static void runner_BFS(const TileGrid_t* tilemap, CWaterRunner_t* p_crunner, int
 
             if (
                 next_tile->solid == SOLID
-                || next_tile->water_level == tilemap->max_water_level
-                || curr_tile->water_level == tilemap->max_water_level
+                || next_tile->water_level >= next_tile->max_water_level
+                || curr_tile->water_level >= curr_tile->max_water_level
             )
             {
                 if (curr_idx % p_crunner->bfs_tilemap.width != 0)
@@ -103,7 +103,7 @@ static void runner_BFS(const TileGrid_t* tilemap, CWaterRunner_t* p_crunner, int
             }
         }
         
-        if (curr_tile->water_level == tilemap->max_water_level)
+        if (curr_tile->water_level >= curr_tile->max_water_level)
         {
 
             next = curr_idx - p_crunner->bfs_tilemap.width;
@@ -227,7 +227,8 @@ void update_water_runner_system(Scene_t* scene)
             break;
             case REACHABILITY_SEARCH:
             {
-                if (tilemap.tiles[p_crunner->current_tile].water_level == tilemap.max_water_level)
+                Tile_t* curr_tile = tilemap.tiles + p_crunner->current_tile;
+                if (curr_tile->water_level >= curr_tile->max_water_level)
                 {
                     p_crunner->state = BFS_RESET;
                     break;
@@ -282,11 +283,11 @@ void update_water_runner_system(Scene_t* scene)
                         p_crunner->bfs_tilemap.tilemap[curr_idx].reachable
                     )
                     {
-                        if (curr_tile->water_level < tilemap.max_water_level)
+                        if (curr_tile->water_level < curr_tile->max_water_level)
                         {
                             curr_tile->water_level++;
                         }
-                        if (curr_tile->water_level != tilemap.max_water_level)
+                        if (curr_tile->water_level < curr_tile->max_water_level)
                         {
                             p_crunner->counter++;
                         }
diff --git a/water_test.c b/water_test.c
index a89ab91..35bd3b2 100644
--- a/water_test.c
+++ b/water_test.c
@@ -55,19 +55,16 @@ static void level_scene_render_func(Scene_t* scene)
                 DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, BLACK);
             }
 
-            //if (tilemap.tiles[i].water_level > 0)
-            {
-                float water_height = tilemap.tiles[i].water_level * 1.0f / tilemap.max_water_level;
-                // Draw water tile
-                Color water_colour = ColorAlpha(BLUE, 0.5);
-                DrawRectangle(
-                    x,
-                    y + (1.0f - water_height) * TILE_SIZE,
-                    TILE_SIZE,
-                    water_height * TILE_SIZE,
-                    water_colour
-                );
-            }
+            uint32_t water_height = tilemap.tiles[i].water_level * WATER_BBOX_STEP;
+            // Draw water tile
+            Color water_colour = ColorAlpha(BLUE, 0.5);
+            DrawRectangle(
+                x,
+                y + (TILE_SIZE - water_height),
+                TILE_SIZE,
+                water_height,
+                water_colour
+            );
         }
 
         sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
@@ -237,7 +234,7 @@ static void toggle_block_system(Scene_t* scene)
                     }
                     else
                     {
-                        tilemap.tiles[tile_idx].water_level = tilemap.max_water_level;
+                        tilemap.tiles[tile_idx].water_level = tilemap.tiles[tile_idx].max_water_level;
                     }
                 }
             
@@ -362,7 +359,6 @@ int main(void)
     scene.data.tilemap.width = DEFAULT_MAP_WIDTH;
     scene.data.tilemap.height = DEFAULT_MAP_HEIGHT;
     scene.data.tilemap.tile_size = TILE_SIZE;
-    scene.data.tilemap.max_water_level = 4;
     scene.data.tilemap.n_tiles = scene.data.tilemap.width * scene.data.tilemap.height;
     assert(scene.data.tilemap.n_tiles <= MAX_N_TILES);
     scene.data.tilemap.tiles = all_tiles;
@@ -372,6 +368,7 @@ int main(void)
         all_tiles[i].solid = NOT_SOLID;
         all_tiles[i].tile_type = EMPTY_TILE;
         all_tiles[i].moveable = true;
+        all_tiles[i].max_water_level = 3;
         sc_map_init_64v(&all_tiles[i].entities_set, 16, 0);
         all_tiles[i].size = (Vector2){TILE_SIZE, TILE_SIZE};
     }