added emitter sprites

diff --git a/fishladder.c b/fishladder.c
index 015ddd8901f42b181caf158fc97cacd1d9ddb639..2bc927787b8c58973887175543ff0ca407d73f59 100644 (file)
--- a/fishladder.c
+++ b/fishladder.c
@@ -114,27 +114,28 @@ static struct cell_description
        int is_linear;
        
        v2f trigger_pos;
+   enum sprites_auto_combine_index trigger_sprite;
 }
 cell_descriptions[] =
 {
        // 0-3
        {},
-       { .start = {  1,  0 }, .end = { -1,  0 }, .trigger_pos = { 0.5f, 0.25f } },
-       { .start = {  0,  1 }, .end = {  0, -1 }, .trigger_pos = { 0.25f, 0.5f } },
-       { .start = {  0,  1 }, .end = {  1,  0 }, .trigger_pos = { 0.25f, 0.25f } },
+       { .start = {  1,  0 }, .end = { -1,  0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d },
+       { .start = {  0,  1 }, .end = {  0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
+       { .start = {  0,  1 }, .end = {  1,  0 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
        // 4-7
-       { .start = { -1,  0 }, .end = {  1,  0 }, .trigger_pos = { 0.5f, 0.25f } },
-       { .start = { -1,  0 }, .end = {  1,  0 }, .trigger_pos = { 0.5f, 0.25f }, .is_linear = 1 },
-       { .start = {  0,  1 }, .end = { -1,  0 }, .trigger_pos = { 0.5f, 0.25f } },
+       { .start = { -1,  0 }, .end = {  1,  0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d },
+       { .start = { -1,  0 }, .end = {  1,  0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d, .is_linear = 1 },
+       { .start = {  0,  1 }, .end = { -1,  0 }, .trigger_pos = { 0.5f, 0.25f }, .trigger_sprite = k_sprite_brk_d },
        { .start = {  0,  1 }, .is_special = 1 },
        // 8-11
-       { .start = {  0, -1 }, .end = {  0,  1 }, .trigger_pos = { 0.25f, 0.5f } },
-       { .start = {  1,  0 }, .end = {  0, -1 }, .trigger_pos = { 0.25f, 0.75f } },
-       { .start = {  0,  1 }, .end = {  0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .is_linear = 1 },
+       { .start = {  0, -1 }, .end = {  0,  1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
+       { .start = {  1,  0 }, .end = {  0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l },
+       { .start = {  0,  1 }, .end = {  0, -1 }, .trigger_pos = { 0.25f, 0.5f }, .trigger_sprite = k_sprite_brk_l, .is_linear = 1 },
        { },
        // 12-15
-       { .start = { -1,  0 }, .end = {  0, -1 }, .trigger_pos = { 0.75f, 0.75f } },
-       { .end = { 0, -1 }, .is_special = 1, .trigger_pos = { 0.5f, 0.75f } },
+       { .start = { -1,  0 }, .end = {  0, -1 }, .trigger_pos = { 0.5f, 0.75f }, .trigger_sprite = k_sprite_brk_u },
+       { .end = { 0, -1 }, .is_special = 1, .trigger_pos = { 0.5f, 0.75f }, .trigger_sprite = k_sprite_brk_u },
        { },
        { }
 };
@@ -208,16 +209,14 @@ static struct world
        }
        st;
 
-#pragma pack(push,1)
        struct cell
        {
                u16 state;
                u16 links[2];
                u8 config;
-               char cc;
+      i8 emit[2];
        }
        *data;
-#pragma pack(pop)
 
        struct render_cmd
        {
@@ -244,10 +243,10 @@ static struct world
        {
                struct terminal_run
                {
-                       char conditions[8];
-                       char recieved[8];
+                       i8 steps[8];
+                       i8 recieved[8];
                        
-                       int condition_count, recv_count;
+                       int step_count, recv_count;
                }
                runs[8];
                
@@ -278,7 +277,7 @@ static struct world
                v2i pos;
                v2i dir;
                enum e_fish_state state;
-               char payload;
+               i8 colour;
                int flow_reversed;
                float death_time;
                v2f physics_v;
@@ -316,7 +315,7 @@ world =
 // Utility functions
 // -----------------
 
-static void colour_code_v3( char const cc, v3f target );
+static void colour_code_v3( i8 cc, v3f target );
 static int hash21i( v2i p, u32 umod );
 
 // Mesh functions
@@ -446,19 +445,15 @@ world_themes[] =
    }
 };
 
-static void colour_code_v3( char const cc, v3f target )
+static void colour_code_v3( i8 cc, v3f target )
 {
-       if( cc >= 'a' && cc <= 'z' )
-       {
-               int id = cc - 'a';
-               
-               if( id < vg_list_size( colour_sets[0] ) )
-               {
-                       v3_copy( colour_sets[colour_set_id][ id ], target );
-                       return;
-               }
-       }
+   if( (cc >= 0) && (cc < vg_list_size( colour_sets[0] )) )
+   {
+      v3_copy( colour_sets[colour_set_id][ cc ], target );
+      return;
+   }
        
+   vg_error( "Invalid colour code used '%d'\n", (int)cc );
        v3_copy( (v3f){0.0f,0.0f,0.0f}, target );
 }
 
@@ -549,7 +544,8 @@ static void map_free(void)
        arrfree( world.io );
 
        free( world.cmd_buf_tiles );
-       
+       world.cmd_buf_tiles = NULL;
+
        world.w = 0;
        world.h = 0;
        world.data = NULL;
@@ -765,8 +761,6 @@ static void gen_level_text( struct cmp_level *pLevel )
 
 static int map_load( const char *str, const char *name )
 {
-       //TODO: It may be worthwhile, at this point, to switch to binary encoding for save data
-       
        map_free();
 
        char const *c = str;
@@ -819,8 +813,12 @@ static int map_load( const char *str, const char *name )
                                                struct terminal_run *run = &terminal->runs[ terminal->run_count-1 ];
 
                                                if( (*c >= 'a' && *c <= 'z') || *c == ' ' )
-                                               {                                                       
-                                                       run->conditions[ run->condition_count ++ ] = *c;
+                                               {
+                     i8 code = -1;
+                     if( *c != ' ' )
+                        code = *c - 'a';
+
+                                                       run->steps[ run->step_count ++ ] = code;
                                                }
                                                else
                                                {
@@ -833,7 +831,7 @@ static int map_load( const char *str, const char *name )
                                                        }
                                                        else if( *c == ':' )
                                                        {
-                                                               terminal->runs[ terminal->run_count ].condition_count = 0;
+                                                               terminal->runs[ terminal->run_count ].step_count = 0;
                                                                terminal->run_count ++;
                                                                world.max_runs = vg_max( world.max_runs, terminal->run_count );
                                                        }
@@ -939,7 +937,7 @@ static int map_load( const char *str, const char *name )
                                term->pos[1] = world.h;
                                
                                term->run_count = 1;
-                               term->runs[0].condition_count = 0;
+                               term->runs[0].step_count = 0;
                                
                                switch( *c )
                                {
@@ -974,7 +972,7 @@ static int map_load( const char *str, const char *name )
                c ++;
        }
 
-       // Fix emitter CC code
+       // Assign emitter codes
        for( int i = 0; i < arrlen( world.io ); i ++ )
        {
                struct cell_terminal *term = &world.io[i];
@@ -982,7 +980,16 @@ static int map_load( const char *str, const char *name )
 
                if( cell->state & FLAG_EMITTER )
                {
-                       cell->cc = term->runs[0].conditions[0];
+         if( (term->run_count > 0) && (term->runs[0].step_count >= 2) )
+         {
+            cell->emit[0] = term->runs[0].steps[0];
+            cell->emit[1] = term->runs[0].steps[1];
+         }
+         else
+         {
+            vg_error( "Emitter was not assigned emit values\n" );
+            goto IL_REG_ERROR;
+         }
                }
        }
                
@@ -1136,6 +1143,9 @@ static int map_load( const char *str, const char *name )
                }
        }
        
+   // ==========================================================
+   // Successful load
+
        vg_success( "Map '%s' loaded! (%u:%u)\n", name, world.w, world.h );
        
        io_reset();
@@ -1201,8 +1211,11 @@ static void map_serialize( FILE *stream )
                                        {
                                                struct terminal_run *run = &term->runs[j];
                                                
-                                               for( int k = 0; k < run->condition_count; k ++ )
-                                                       fputc( run->conditions[k], stream );
+                                               for( int k = 0; k < run->step_count; k ++ )
+                  {
+                     i8 step = run->steps[k];
+                                                       fputc( step == -1? ' ': ('a' + run->steps[k]), stream );
+                  }
                                                        
                                                if( j < term->run_count-1 )
                                                        fputc( ':', stream );
@@ -1876,12 +1889,12 @@ static void vg_update(void)
                                                                struct terminal_run *run = &term->runs[ world.sim_run ];
                                                                if( run->recv_count < vg_list_size( run->recieved ) )
                                                                {
-                                                                       if( fish->payload == run->conditions[ run->recv_count ] )
+                                                                       if( fish->colour == run->steps[ run->recv_count ] )
                                                                                success_this_frame = 1;
                                                                        else
                                                                                failure_this_frame = 1;
                                                                
-                                                                       run->recieved[ run->recv_count ++ ] = fish->payload;
+                                                                       run->recieved[ run->recv_count ++ ] = fish->colour;
                                                                }
                                                                else
                                                                        failure_this_frame = 1;
@@ -2048,7 +2061,7 @@ static void vg_update(void)
                                                        lcell( cell_current->links[trigger_id], fish->pos );
 
                                                        fish->state = k_fish_state_soon_alive;
-                                                       fish->payload = target_peice->cc;
+                                                       fish->colour = target_peice->emit[ trigger_id ];
                                                        
                                                        if( target_peice->config != k_cell_type_stub )
                                                        {
@@ -2139,17 +2152,17 @@ static void vg_update(void)
                                
                                if( is_input )
                                {
-                                       if( world.sim_frame < term->runs[ world.sim_run ].condition_count )
+                                       if( world.sim_frame < term->runs[ world.sim_run ].step_count )
                                        {
-                                               char emit = term->runs[ world.sim_run ].conditions[ world.sim_frame ];
-                                               if( emit == ' ' )
+                                               i8 emit = term->runs[ world.sim_run ].steps[ world.sim_frame ];
+                                               if( emit == -1 )
                                                        continue;
                                        
                                                struct fish *fish = &world.fishes[ world.num_fishes ];
                                                v2i_copy( term->pos, fish->pos );
                                                
                                                fish->state = k_fish_state_alive;
-                                               fish->payload = emit;
+                                               fish->colour = emit;
                                                
                                                struct cell *cell_ptr = pcell( fish->pos );
                                                
@@ -2179,11 +2192,11 @@ static void vg_update(void)
                                        {
                                                struct terminal_run *run = &term->runs[ world.sim_run ];
                                        
-                                               if( run->recv_count == run->condition_count )
+                                               if( run->recv_count == run->step_count )
                                                {
-                                                       for( int j = 0; j < run->condition_count; j ++ )
+                                                       for( int j = 0; j < run->step_count; j ++ )
                                                        {
-                                                               if( run->recieved[j] != run->conditions[j] )
+                                                               if( run->recieved[j] != run->steps[j] )
                                                                {
                                                                        world.completed = 0;
                                                                        break;
@@ -2613,7 +2626,7 @@ void vg_render(void)
                        {
                                struct render_cmd *cmd;
 
-                               if( cell->config == k_cell_type_split || (cell->state & FLAG_EMITTER ) )
+                               if( cell->config == k_cell_type_split || (cell->state & FLAG_EMITTER || cell->state & FLAG_IS_TRIGGER) )
                                        cmd = &world.cmd_buf_tiles[ world.max_commands - (++ world.tile_special_count) ];
                                else
                                        cmd = &world.cmd_buf_tiles[ world.tile_count ++ ];
@@ -2710,7 +2723,7 @@ void vg_render(void)
                        v2_copy( fish->physics_co, render_pos );
                        
                        v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
-                       colour_code_v3( fish->payload, dot_colour );
+                       colour_code_v3( fish->colour, dot_colour );
                        
                        glUniform3fv( SHADER_UNIFORM( shader_ball, "uColour" ), 1, dot_colour );
                        glUniform3fv( SHADER_UNIFORM( shader_ball, "uOffset" ), 1, render_pos );
@@ -2872,6 +2885,129 @@ void vg_render(void)
        if( vg_get_button_up( "primary" ) )
                world_button_exec( NULL, NULL, NULL, NULL );
        
+       // I/O ARRAYS
+       // ========================================================================================================
+       
+       //glEnable(GL_BLEND);
+       SHADER_USE( shader_tile_colour );
+       glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
+
+       for( int i = 0; i < arrlen( world.io ); i ++ )
+       {
+               struct cell_terminal *term = &world.io[ i ];
+               struct cell *cell = pcell(term->pos);
+
+               int is_input = cell->state & FLAG_INPUT;
+               v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
+
+      if( cell->state & FLAG_EMITTER )
+      {
+         for( int j = 0; j < 2; j ++ )
+         {
+            if( cell->emit[j] != -1 )
+            {
+               colour_code_v3( cell->emit[j], dot_colour );
+               
+               glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 
+                  term->pos[0] + 0.25f + (float)j * 0.5f, 
+                  term->pos[1] + 0.25f,
+                  0.12f
+               );
+
+               glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+               draw_mesh( filled_start, filled_count );
+            }
+         }
+         continue;
+      }
+               
+               for( int k = 0; k < term->run_count; k ++ )
+               {
+                       float arr_base   = is_input? 1.2f: -0.2f, 
+                                       run_offset = (is_input? 0.2f: -0.2f) * (float)k, 
+                                       y_position = is_input? 
+                                               (arr_base + (float)term->pos[1] + (float)(term->run_count-1)*0.2f) - run_offset:
+                                               (float)term->pos[1] + arr_base + run_offset;
+                       
+                       v4f bar_colour;
+                       int bar_draw = 0;
+                       
+                       if( is_simulation_running() )
+                       {
+                               if( k == world.sim_run )
+                               {
+                                       float a = fabsf(sinf( vg_time * 2.0f )) * 0.075f + 0.075f;
+                                       
+                                       v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, a }, bar_colour );
+                               }
+                               else
+                                       v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );
+                               
+                               bar_draw = 1;
+                       }
+                       else if( 1 || k & 0x1 )
+                       {
+                               if( k & 0x1 )
+                                       v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, 0.07f }, bar_colour );
+                               else
+                                       v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );                        
+                                                       
+                               bar_draw = 1;
+                       }
+                       
+                       if( bar_draw )
+                       {
+                               glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, bar_colour );
+                               glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 
+               (float)term->pos[0], y_position - 0.1f, 1.0f );
+
+                               draw_mesh( 2, 2 );
+                       }
+                       
+                       for( int j = 0; j < term->runs[k].step_count; j ++ )
+                       {
+                               glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 
+                                       (float)term->pos[0] + 0.2f + 0.2f * (float)j, 
+                                       y_position, 
+                                       0.1f 
+                               );
+                       
+                               if( is_input )
+                               {
+                                       i8 colour = term->runs[k].steps[j];
+                                       if( colour != -1 )
+                                       {                                       
+                                               colour_code_v3( colour, dot_colour );
+                                               glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+                                       
+                                               // Draw filled if tick not passed, draw empty if empty
+                                               if( (world.sim_frame > j && world.sim_run >= k) || world.sim_run > k )
+                                                       draw_mesh( empty_start, empty_count );
+                                               else
+                                                       draw_mesh( filled_start, filled_count );
+                                       }
+                               }
+                               else
+                               {
+                               
+                                       if( term->runs[k].recv_count > j )
+                                       {
+                                               colour_code_v3( term->runs[k].recieved[j], dot_colour );
+                                               v3_muls( dot_colour, 0.8f, dot_colour );
+                                               glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+                                               
+                                               draw_mesh( filled_start, filled_count );
+                                       }
+                                       
+                                       colour_code_v3( term->runs[k].steps[j], dot_colour );
+                                       glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
+                                       
+                                       draw_mesh( empty_start, empty_count );
+                               }
+                       }
+               }
+       }
+
        // SPRITES
        // ========================================================================================================
        SHADER_USE( shader_sprite );
@@ -2885,7 +3021,7 @@ void vg_render(void)
                struct render_cmd *cmd = &world.cmd_buf_specials[i];
                struct cell *cell = cmd->ptr;
 
-               if( cell->config == k_cell_type_split )
+               if( (cell->config == k_cell_type_split) || (cell->state & FLAG_EMITTER) )
                {
                        v2f center = { cmd->pos[0] + 0.5f, cmd->pos[1] + 0.5f };
 
@@ -2898,6 +3034,15 @@ void vg_render(void)
                        render_sprite( k_sprite_jack_1, p0 );
                        render_sprite( k_sprite_jack_2, p1 );
                }
+      else if( cell->state & FLAG_IS_TRIGGER )
+      {
+         v3f p0 = { 0.0f, 0.0f, 4.0f };
+         
+         struct cell_description *desc = &cell_descriptions[ cell->config ];
+
+         v2_add( (v2f){ cmd->pos[0], cmd->pos[1] }, desc->trigger_pos, p0 );
+         render_sprite( desc->trigger_sprite, p0 );
+      }
        }
 
        // TEXT ELEMENTS
@@ -2978,7 +3123,7 @@ void vg_render(void)
                                if( cmd->ptr->state & FLAG_EMITTER )
                                {
                                        v4f wire_colour;
-                                       colour_code_v3( other_cell->cc, wire_colour );
+                                       colour_code_v3( cmd->ptr->emit[j], wire_colour );
                                        wire_colour[3] = 1.0f;
 
                                        glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, wire_colour );
@@ -2999,7 +3144,6 @@ void vg_render(void)
        // ========================================================================================================
        
        SHADER_USE( shader_tile_colour );
-       glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
        use_mesh( &world.shapes );
        
        for( int i = 0; i < world.tile_special_count; i ++ )
@@ -3015,7 +3159,6 @@ void vg_render(void)
                                        continue;
 
                                struct cell *other_cell = &world.data[ cell->links[ j ]];
-                               
                                struct cell_description *desc = &cell_descriptions[ other_cell->config ];
                                
                                int x2 = cell->links[j] % world.w;
@@ -3031,10 +3174,10 @@ void vg_render(void)
                                
                                v2_add( desc->trigger_pos, pts[1], pts[1] );
                                
-                               if( other_cell->state & FLAG_EMITTER )
+                               if( cell->state & FLAG_EMITTER )
                                {
                                        v4f wire_colour;
-                                       colour_code_v3( other_cell->cc, wire_colour );
+                                       colour_code_v3( cell->emit[j], wire_colour );
 
                                        v3_muls( wire_colour, 0.8f, wire_colour );
                                        wire_colour[3] = 1.0f;
@@ -3042,9 +3185,7 @@ void vg_render(void)
                                        glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, wire_colour );
                                }
                                else
-                               {
-                                       glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, j? wire_right_colour: wire_left_colour );
-                               }
+                                       glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1,j?wire_right_colour: wire_left_colour );
                                
                                for( int i = 0; i < 2; i ++ )
                                {
@@ -3113,107 +3254,6 @@ void vg_render(void)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glBlendEquation(GL_FUNC_ADD);
 
-       // I/O ARRAYS
-       // ========================================================================================================
-       
-       //glEnable(GL_BLEND);
-       SHADER_USE( shader_tile_colour );
-
-       for( int i = 0; i < arrlen( world.io ); i ++ )
-       {
-               struct cell_terminal *term = &world.io[ i ];
-               
-               if( pcell(term->pos)->state & FLAG_EMITTER )
-                       continue;
-
-               int is_input = pcell(term->pos)->state & FLAG_INPUT;
-
-               v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
-               
-               for( int k = 0; k < term->run_count; k ++ )
-               {
-                       float arr_base   = is_input? 1.2f: -0.2f, 
-                                       run_offset = (is_input? 0.2f: -0.2f) * (float)k, 
-                                       y_position = is_input? 
-                                               (arr_base + (float)term->pos[1] + (float)(term->run_count-1)*0.2f) - run_offset:
-                                               (float)term->pos[1] + arr_base + run_offset;
-                       
-                       v4f bar_colour;
-                       int bar_draw = 0;
-                       
-                       if( is_simulation_running() )
-                       {
-                               if( k == world.sim_run )
-                               {
-                                       float a = fabsf(sinf( vg_time * 2.0f )) * 0.075f + 0.075f;
-                                       
-                                       v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, a }, bar_colour );
-                               }
-                               else
-                                       v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );
-                               
-                               bar_draw = 1;
-                       }
-                       else if( 1 || k & 0x1 )
-                       {
-                               if( k & 0x1 )
-                                       v4_copy( (v4f){ 1.0f, 1.0f, 1.0f, 0.07f }, bar_colour );
-                               else
-                                       v4_copy( (v4f){ 0.0f, 0.0f, 0.0f, 0.13f }, bar_colour );                        
-                                                       
-                               bar_draw = 1;
-                       }
-                       
-                       if( bar_draw )
-                       {
-                               glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, bar_colour );
-                               glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)term->pos[0], y_position - 0.1f, 1.0f );
-                               draw_mesh( 2, 2 );
-                       }
-                       
-                       for( int j = 0; j < term->runs[k].condition_count; j ++ )
-                       {
-                               glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 
-                                       (float)term->pos[0] + 0.2f + 0.2f * (float)j, 
-                                       y_position, 
-                                       0.1f 
-                               );
-                       
-                               if( is_input )
-                               {
-                                       char cc = term->runs[k].conditions[j];
-                                       if( cc != ' ' )
-                                       {                                       
-                                               colour_code_v3( cc, dot_colour );
-                                               glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
-                                       
-                                               // Draw filled if tick not passed, draw empty if empty
-                                               if( (world.sim_frame > j && world.sim_run >= k) || world.sim_run > k )
-                                                       draw_mesh( empty_start, empty_count );
-                                               else
-                                                       draw_mesh( filled_start, filled_count );
-                                       }
-                               }
-                               else
-                               {
-                               
-                                       if( term->runs[k].recv_count > j )
-                                       {
-                                               colour_code_v3( term->runs[k].recieved[j], dot_colour );
-                                               v3_muls( dot_colour, 0.8f, dot_colour );
-                                               glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
-                                               
-                                               draw_mesh( filled_start, filled_count );
-                                       }
-                                       
-                                       colour_code_v3( term->runs[k].conditions[j], dot_colour );
-                                       glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
-                                       
-                                       draw_mesh( empty_start, empty_count );
-                               }
-                       }
-               }
-       }
        
        glDisable(GL_BLEND);
        

diff --git a/maps/emit_test.map b/maps/emit_test.map
index b1c1728c589370a04b3b0aedd539ff3fddd4c8e7..8a769fedbc7a25f5daa46f20894d9fc95c246992 100644 (file)
--- a/maps/emit_test.map
+++ b/maps/emit_test.map
@@ -8,5 +8,5 @@
 ##            ##;
 ##            ##;
 ##            ##;
-###+###*########;a,b
+###+###*########;a,bb
 ################;

diff --git a/sprites_autocombine.h b/sprites_autocombine.h
index aa9e326705a9508c82e0ccbf58a1b0ccd67be250..809278815583b9d9d4cc8ed785feff5431797291 100644 (file)
--- a/sprites_autocombine.h
+++ b/sprites_autocombine.h
@@ -1,6 +1,9 @@
 enum sprites_auto_combine_index
 {
-       k_sprite_donut,
+       k_sprite_brk_d,
+       k_sprite_brk_l,
+       k_sprite_brk_r,
+       k_sprite_brk_u,
        k_sprite_flare_b,
        k_sprite_flare_y,
        k_sprite_jack_1,
@@ -10,10 +13,13 @@ enum sprites_auto_combine_index
 
 static struct vg_sprite sprites_auto_combine[] = 
 {
-       {{ 0.000000, 0.000000, 0.125000, 0.125000 }},
-       {{ 0.125000, 0.000000, 0.125000, 0.125000 }},
-       {{ 0.250000, 0.000000, 0.125000, 0.125000 }},
-       {{ 0.375000, 0.000000, 0.062500, 0.062500 }},
-       {{ 0.437500, 0.000000, 0.062500, 0.062500 }},
-       {{ 0.500000, 0.000000, 0.062500, 0.062500 }}
+       {{ 0.000000, 0.000000, 0.156250, 0.156250 }},
+       {{ 0.156250, 0.000000, 0.156250, 0.156250 }},
+       {{ 0.312500, 0.000000, 0.156250, 0.156250 }},
+       {{ 0.468750, 0.000000, 0.156250, 0.156250 }},
+       {{ 0.625000, 0.000000, 0.125000, 0.125000 }},
+       {{ 0.750000, 0.000000, 0.125000, 0.125000 }},
+       {{ 0.875000, 0.000000, 0.062500, 0.062500 }},
+       {{ 0.937500, 0.000000, 0.062500, 0.062500 }},
+       {{ 0.875000, 0.062500, 0.062500, 0.062500 }}
 };
\ No newline at end of file

diff --git a/textures_combine/brk_d.png b/textures_combine/brk_d.png
new file mode 100644 (file)
index 0000000..6df7aca
Binary files /dev/null and b/textures_combine/brk_d.png differ

diff --git a/textures_combine/brk_l.png b/textures_combine/brk_l.png
new file mode 100644 (file)
index 0000000..142fc92
Binary files /dev/null and b/textures_combine/brk_l.png differ

diff --git a/textures_combine/brk_r.png b/textures_combine/brk_r.png
new file mode 100644 (file)
index 0000000..aa1df34
Binary files /dev/null and b/textures_combine/brk_r.png differ

diff --git a/textures_combine/brk_u.png b/textures_combine/brk_u.png
new file mode 100644 (file)
index 0000000..170208c
Binary files /dev/null and b/textures_combine/brk_u.png differ

diff --git a/textures_combine/donut.png b/textures_combine/donut.png
deleted file mode 100644 (file)
index a585c5e..0000000
Binary files a/textures_combine/donut.png and /dev/null differ

diff --git a/textures_combine/jack-1.png b/textures_combine/jack-1.png
index e6f94c3d27a8958c577907d71e310939e848f715..cca2b5bff796981bfa80fcf1f2b2ae9d3455b245 100644 (file)
Binary files a/textures_combine/jack-1.png and b/textures_combine/jack-1.png differ

diff --git a/textures_combine/jack-2.png b/textures_combine/jack-2.png
index 9c862ac010cd236fda65e4c1b90231d8ccfd2ba7..6ca3d9999692f26bb376cd8b42dd19f2023ec2ca 100644 (file)
Binary files a/textures_combine/jack-2.png and b/textures_combine/jack-2.png differ

diff --git a/textures_combine/peg.png b/textures_combine/peg.png
index d541803fe723d9e848482b08d8775e7c789c6b90..1b016fca0417925c7e00396d65e219b6ead7d647 100644 (file)
Binary files a/textures_combine/peg.png and b/textures_combine/peg.png differ

diff --git a/vg/vg_console.h b/vg/vg_console.h
index 8ab3256b4e86ccba1d0b550b692529a8d49e025d..76d38007241ef256112d1440159b7dcccc38331c 100644 (file)
--- a/vg/vg_console.h
+++ b/vg/vg_console.h
@@ -109,7 +109,7 @@ static void vg_console_draw( void )
        ui_fill_x( &ui_global_ctx );
        
        ui_new_node( &ui_global_ctx );
-       {               
+       {
                ui_fill_rect( &ui_global_ctx, ui_global_ctx.cursor, 0x77333333 );
        
                ui_global_ctx.cursor[3] = 8*vg_console.scale;