map loader

diff --git a/fishladder.c b/fishladder.c
index 5006fd11f37140c29f801d56455481625eca9236..38361e6bdf06942b550948b3548eb4320d916e71 100644 (file)
--- a/fishladder.c
+++ b/fishladder.c
@@ -31,6 +31,11 @@ m3x3f m_projection;
 m3x3f m_view;
 m3x3f m_mdl;
 
+#define FLAG_INPUT 0x1
+#define FLAG_OUTPUT 0x2
+#define FLAG_CANAL 0x4
+#define FLAG_WALL 0x8
+
 struct world
 {
        struct cell
@@ -39,11 +44,154 @@ struct world
        } 
        *data;
        
+       struct cell_terminal
+       {
+               char *conditions;
+               int id;
+       }
+       *io;
+       
        u32 w, h;
        
        GLuint tile_vao;
        GLuint tile_vbo;
-} world = { .w = 4, .h = 4 };
+       
+       int selected;
+} world = {};
+
+static void map_free(void)
+{
+       for( int i = 0; i < arrlen( world.io ); i ++ )
+               arrfree( world.io[ i ].conditions );
+       
+       arrfree( world.data );
+       arrfree( world.io );
+       
+       world.w = 0;
+       world.h = 0;
+       world.data = NULL;
+       world.io = NULL;
+}
+
+static int map_load( const char *str )
+{
+       map_free();
+
+       char const *c = str;
+       
+       // Scan for width
+       for(;; world.w ++)
+       {
+               if( str[world.w] == ';' )
+                       break;
+               else if( !str[world.w] )
+               {
+                       vg_error( "Unexpected EOF when parsing level\n" );
+                       return 0;
+               }
+       }
+       
+       struct cell *row = arraddnptr( world.data, world.w );
+       int cx = 0;
+       int reg_start = 0, reg_end = 0;
+       
+       for(;;)
+       {
+               if( !*c )
+                       break;
+       
+               if( *c == ';' )
+               {
+                       c ++;
+
+                       // Parse attribs
+                       if( *c != '\n' )
+                       {
+                               while( *c )
+                               {
+                                       if( reg_start < reg_end )
+                                       {
+                                               if( *c >= 'a' && *c <= 'z' )
+                                               {
+                                                       arrpush( world.io[ reg_start ].conditions, *c );
+                                               }
+                                               else
+                                               {
+                                                       if( *c == ',' || *c == '\n' )
+                                                       {
+                                                               reg_start ++;
+                                                               
+                                                               if( *c == '\n' )
+                                                                       break;
+                                                       }
+                                                       else
+                                                       {
+                                                               vg_error( "Unkown attribute '%c' (row: %u)\n", *c, world.h );
+                                                               return 0;
+                                                       }
+                                               }
+                                       }
+                                       else
+                                       {
+                                               vg_error( "Too many values to assign (row: %u)\n", world.h );
+                                               return 0;
+                                       }
+                                       
+                                       c ++;
+                               }
+                       }
+                       
+                       if( reg_start != reg_end )
+                       {
+                               vg_error( "Not enough values assigned (row: %u, %u of %u)\n", world.h, reg_start, reg_end );
+                               return 0;
+                       }
+                       
+                       if( cx != world.w )
+                       {
+                               vg_error( "Not enough cells to match previous row definition (row: %u, %u<%u)\n", world.h, cx, world.w );
+                               return 0;
+                       }
+                       
+                       row = arraddnptr( world.data, world.w );
+                       cx = 0;
+                       world.h ++;
+                       reg_end = reg_start = arrlen( world.io );
+               }
+               else
+               {
+                       if( cx == world.w )
+                       {
+                               vg_error( "Too many cells to match previous row definition (row: %u, %u>%u)\n", world.h, cx, world.w );
+                               return 0;
+                       }
+                       
+                       // Tile initialization
+                       // row[ cx ] .. etc
+                       
+                       if( *c == '+' || *c == '-' )
+                       {
+                               struct cell_terminal term = { .id = cx + world.h*world.w };
+                               arrpush( world.io, term );
+                               row[ cx ++ ].state = *c == '+'? FLAG_INPUT: FLAG_OUTPUT;
+                               reg_end ++;
+                       }
+                       else if( *c == '#' )
+                       {
+                               row[ cx ++ ].state = FLAG_WALL;
+                       }
+                       else
+                       {
+                               row[ cx ++ ].state = 0x00;
+                       }
+               }
+       
+               c ++;
+       }
+       
+       vg_success( "Map loaded! (%u:%u)\n", world.w, world.h );
+       return 1;
+}
 
 int main( int argc, char *argv[] )
 {
@@ -80,24 +228,56 @@ void vg_start(void)
        glEnableVertexAttribArray( 0 );
        
        VG_CHECK_GL();  
+       
+       map_load
+       ( 
+               "#############;\n"
+               "###-#####-###;aaa,aa\n"
+               "##         ##;\n"
+               "##         ##;\n"
+               "##         ##;\n"
+               "##         ##;\n"
+               "##         ##;\n"
+               "##         ##;\n"
+               "###+#####+###;aa,aaa\n"
+               "#############;\n"
+       );
 }
 
 void vg_free(void)
 {
        glDeleteVertexArrays( 1, &world.tile_vao );
        glDeleteBuffers( 1, &world.tile_vbo );
+       
+       map_free();
 }
 
 void vg_update(void)
 {
        float ratio = (float)vg_window_y / (float)vg_window_x;
-       float const size = 7.5f;
+       float const size = 9.5f;
+       
+       v3f origin;
+       origin[0] = -0.5f * world.w;
+       origin[1] = -0.5f * world.h;
+       origin[2] = 0.0f;
        
        m3x3_projection( m_projection, -size, size, size*ratio, -size*ratio );
        m3x3_identity( m_view );
-       m3x3_translate( m_view, (v3f){ -0.5f * world.w, -0.5f * world.h } );
+       m3x3_translate( m_view, origin );
        m3x3_mul( m_projection, m_view, vg_pv );
        vg_projection_update();
+       
+       v2f tile_pos;
+       v2_copy( vg_mouse_ws, tile_pos );
+       
+       int tile_x = floorf( tile_pos[0] );
+       int tile_y = floorf( tile_pos[1] );
+       
+       if( tile_x >= 0 && tile_x < world.w && tile_y >= 0 && tile_y <= world.h )
+               world.selected = tile_y * world.h + tile_x;
+       else
+               world.selected = -1;
 }
 
 void vg_render(void)
@@ -117,7 +297,22 @@ void vg_render(void)
                for( int x = 0; x < world.w; x ++ )
                {
                        glUniform2f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)x, (float)y );
-                       glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1.0f, 1.0f, 1.0f, 1.0f );
+                       
+                       v4f colour;
+                       
+                       struct cell *cell = &world.data[y*world.h+x];
+                       
+                       if( cell->state & FLAG_WALL ) { v4_copy( (v4f){ 0.4f, 0.4f, 0.4f, 1.0f }, colour ); }
+                       else if( cell->state & FLAG_CANAL ) { v4_copy( (v4f){ 0.6f, 0.6f, 0.6f, 1.0f }, colour ); }
+                       else if( cell->state & FLAG_INPUT ) { v4_copy( (v4f){ 0.2f, 0.3f, 0.7f, 1.0f }, colour ); }
+                       else if( cell->state & FLAG_OUTPUT ) { v4_copy( (v4f){ 0.2f, 0.7f, 0.3f, 1.0f }, colour ); }
+                       else v4_copy( (v4f){ 1.0f, 0.0f, 0.0f, 1.0f }, colour );
+                       
+                       if( world.selected == y*world.h + x )
+                               v3_muls( colour, sinf( vg_time )*0.25f + 0.5f, colour );
+                               
+                       glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, colour );
+                       
                        glDrawArrays( GL_TRIANGLES, 0, 6 );
                }
        }