splitter

diff --git a/fishladder.c b/fishladder.c
index e8f801489ec3b89ec31664f9f8249530899e9eb4..27bea90b33cd203526803093f5c7b51d482293fa 100644 (file)
--- a/fishladder.c
+++ b/fishladder.c
@@ -35,6 +35,8 @@ m3x3f m_mdl;
 #define FLAG_OUTPUT 0x2
 #define FLAG_CANAL 0x4
 #define FLAG_WALL 0x8
+#define FLAG_DROP 0x10
+#define FLAG_SPLIT 0x20
 
 struct world
 {
@@ -42,6 +44,7 @@ struct world
        {
                u32 state;
                u8 water[2];
+               u8 config;
        }
        *data;
        
@@ -364,7 +367,7 @@ void vg_update(void)
        int tile_x = floorf( tile_pos[0] );
        int tile_y = floorf( tile_pos[1] );
        
-       if( cell_interactive( (v2i){ tile_x, tile_y } ))// tile_x >= 2 && tile_x < world.w-2 && tile_y >= 2 && tile_y <= world.h-2 )
+       if( cell_interactive( (v2i){ tile_x, tile_y } ))
        {
                world.selected = tile_y * world.w + tile_x;
                
@@ -376,6 +379,112 @@ void vg_update(void)
        else
                world.selected = -1;
        
+       // Reclassify world. TODO: Move into own function
+       for( int y = 2; y < world.h-2; y ++ )
+       {
+               for( int x = 2; x < world.w-2; x ++ )
+               {
+                       v2i dirs[] = {{1,0},{0,1},{-1,0},{0,-1}};
+                       
+                       u8 config = 0x00;
+                       
+                       if( world.data[y*world.w+x].state & FLAG_CANAL )
+                       {
+                               for( int i = 0; i < vg_list_size( dirs ); i ++ )
+                               {
+                                       struct cell *neighbour = &world.data[(y+dirs[i][1])*world.w+x+dirs[i][0]];
+                                       if( neighbour->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
+                                               config |= 0x1 << i;
+                               }
+                       } else config = 0xF;
+                       
+                       world.data[ y*world.w+x ].config = config;
+                       world.data[ y*world.w+x ].state &= ~(FLAG_DROP|FLAG_SPLIT);
+               }
+       }
+       
+       for( int y = 2; y < world.h-2; y ++ )
+               for( int x = 2; x < world.w-2; x ++ )
+               {
+                       // R,D,L,-   1110 (splitter, 1 drop created)
+                       
+                       // R,-,L,U - 1011 (merger, 2 drop created)
+                       
+                       u8 config = world.data[y*world.w+x].config;
+                       
+                       if( config == 0x7 )
+                       {
+                               world.data[y*world.w+x ].state |= (FLAG_SPLIT | FLAG_DROP);
+                       }
+                       else if( config == 0xD )
+                       {
+                               world.data[y*world.w+x-1].state |= FLAG_DROP;
+                               world.data[y*world.w+x+1].state |= FLAG_DROP;
+                       }
+               }
+       
+       /*
+          canals
+            x
+          xxxxx
+          x   x
+          x  xxx
+               x  x x
+               x  xxx
+               x   x
+               xxxxx
+                  x
+             x
+          
+          configs (Downlevels marked)
+            x
+          xDxDx   
+          x   x
+          x  DxD
+               x  x x
+               x  xDx
+               x   x
+               xxxDx
+                  x
+             x
+
+               Path tracing with min function
+            0
+          11011
+          1   .
+          1  D.D
+               1  . .
+               1  .D.
+               1   .
+               1112.
+                  2
+             2
+
+               Path tracing with min function
+            0
+          11011
+          1   1
+          1  212
+               1  2 2
+               1  232
+               1   3
+               11143
+                  4
+             4
+          
+          L to R fill
+          0000000
+          1101111
+          1111111
+          1112122
+               1112222
+               1112322
+               1111333
+               1114333
+               4444444
+          4444444
+       */
+       
        // Simulate world
        static int update_tick = 0;
        update_tick ++;
@@ -393,12 +502,12 @@ void vg_update(void)
                        {
                                struct cell *cell = &world.data[y*world.w+x];
 
-                               if( cell->state & FLAG_INPUT )
+                               if( cell->state & (FLAG_OUTPUT|FLAG_DROP) )
                                        cell->water[ buffer_next ] = 16;
                                else
                                {
                                        int has_source = 0;
-                                       cell->water[ buffer_next ] = 0; 
+                                       cell->water[ buffer_next ] = 0;
                                        
                                        if( cell->state & FLAG_CANAL )
                                        {
@@ -460,6 +569,9 @@ void vg_render(void)
                        if( world.selected == y*world.w + x )
                                v3_muls( colour, sinf( vg_time )*0.25f + 0.5f, colour );
                        
+                       if( cell->state & (FLAG_DROP|FLAG_SPLIT) )
+                               v4_copy( (v4f){ 0.75f, 0.75f, 0.02f, 1.0f }, colour );
+                       
                        glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, colour );
                        
                        glDrawArrays( GL_TRIANGLES, 0, 6 );