allowed background travel
authorhgn <hgodden00@gmail.com>
Wed, 1 Dec 2021 15:01:22 +0000 (15:01 +0000)
committerhgn <hgodden00@gmail.com>
Wed, 1 Dec 2021 15:01:22 +0000 (15:01 +0000)
fishladder.c

index 37d2469b2e7671cf14b490810abd28d259b52f05..8fccfb5d40583540c5e16d8e8ee57b0d18f6d898 100644 (file)
@@ -126,7 +126,11 @@ enum cell_type
        k_cell_type_ramp_right = 3,
        k_cell_type_ramp_left = 6,
        k_cell_type_split = 7,
-       k_cell_type_merge = 13
+       k_cell_type_merge = 13,
+       k_cell_type_con_r = 1,
+       k_cell_type_con_u = 2,
+       k_cell_type_con_l = 4,
+       k_cell_type_con_d = 8
 };
 
 v3f colour_sets[] =
@@ -188,6 +192,14 @@ static void use_mesh( struct mesh *m )
        glBindVertexArray( m->vao );
 }
 
+enum e_fish_state
+{
+       k_fish_state_soon_dead = -1,
+       k_fish_state_dead = 0,
+       k_fish_state_alive,
+       k_fish_state_bg
+};
+
 struct world
 {
 #pragma pack(push,1)
@@ -252,7 +264,7 @@ struct world
        {
                v2i pos;
                v2i dir;
-               int alive;
+               enum e_fish_state state;
                char payload;
                float death_time;
                v2f physics_v;
@@ -959,10 +971,15 @@ void vg_free(void)
        map_free();
 }
 
+static int world_check_pos_ok( v2i co )
+{
+       return (co[0] < 2 || co[0] >= world.w-2 || co[1] < 2 || co[1] >= world.h-2)? 0: 1;
+}
+
 static int cell_interactive( v2i co )
 {
        // Bounds check
-       if( co[0] < 2 || co[0] >= world.w-2 || co[1] < 2 || co[1] >= world.h-2 )
+       if( !world_check_pos_ok( co ) )
                return 0;
 
        // Flags check
@@ -1340,106 +1357,149 @@ void vg_update(void)
                        {
                                struct fish *fish = &world.fishes[i];
                                
-                               if( fish->alive == -1 )
-                                       fish->alive = 0;
+                               if( fish->state == k_fish_state_soon_dead )
+                                       fish->state = k_fish_state_dead;
                                
-                               if( fish->alive != 1 )
+                               if( fish->state < k_fish_state_alive )
                                        continue;
                                
                                struct cell *cell_current = pcell( fish->pos );
 
-                               // Apply to output
-                               if( cell_current->state & FLAG_OUTPUT )
+                               if( fish->state == k_fish_state_alive )
                                {
-                                       for( int j = 0; j < arrlen( world.io ); j ++ )
+                                       // Apply to output
+                                       if( cell_current->state & FLAG_OUTPUT )
+                                       {
+                                               for( int j = 0; j < arrlen( world.io ); j ++ )
+                                               {
+                                                       struct cell_terminal *term = &world.io[j];
+                                                       
+                                                       if( term->id == fish->pos[1]*world.w + fish->pos[0] )
+                                                       {
+                                                               struct terminal_run *run = &term->runs[ world.sim_run ];
+                                                               if( run->recv_count < vg_list_size( run->recieved ) )
+                                                                       run->recieved[ run->recv_count ++ ] = fish->payload;
+                                                               
+                                                               break;
+                                                       }
+                                               }
+                                               
+                                               fish->state = k_fish_state_dead;
+                                               continue;
+                                       }
+                                       
+                                       if( cell_current->config == k_cell_type_split )
                                        {
-                                               struct cell_terminal *term = &world.io[j];
+                                               // Flip flop L/R
+                                               fish->dir[0] = cell_current->state&FLAG_FLIP_FLOP?1:-1;
+                                               fish->dir[1] = 0;
                                                
-                                               if( term->id == fish->pos[1]*world.w + fish->pos[0] )
+                                               if( !(cell_current->state & FLAG_TARGETED) )
+                                                       cell_current->state ^= FLAG_FLIP_FLOP;
+                                       }
+                                       else if( cell_current->config == k_cell_type_merge )
+                                       {
+                                               // Can only move up
+                                               fish->dir[0] = 0;
+                                               fish->dir[1] = -1;
+                                       }
+                                       else
+                                       {
+                                               struct cell *cell_next = pcell( (v2i){ fish->pos[0]+fish->dir[0], fish->pos[1]+fish->dir[1] } );
+                                               if( !(cell_next->state & (FLAG_CANAL|FLAG_OUTPUT)) )
                                                {
-                                                       struct terminal_run *run = &term->runs[ world.sim_run ];
-                                                       if( run->recv_count < vg_list_size( run->recieved ) )
-                                                               run->recieved[ run->recv_count ++ ] = fish->payload;
+                                                       // Try other directions for valid, so down, left, right..
+                                                       v2i dirs[] = {{1,0},{-1,0},{0,-1}};
+                                                       //vg_info( "Trying some other directions...\n" );
                                                        
-                                                       break;
+                                                       for( int j = 0; j < vg_list_size(dirs); j ++ )
+                                                       {
+                                                               if( (dirs[j][0] == -fish->dir[0]) && (dirs[j][1] == -fish->dir[1]) )
+                                                                       continue;
+                                                       
+                                                               if( pcell( (v2i){ fish->pos[0]+dirs[j][0], fish->pos[1]+dirs[j][1] } )->state & (FLAG_CANAL|FLAG_OUTPUT) )
+                                                               {
+                                                                       fish->dir[0] = dirs[j][0];
+                                                                       fish->dir[1] = dirs[j][1];
+                                                               }
+                                                       }
                                                }
                                        }
                                        
-                                       fish->alive = 0;
-                                       continue;
-                               }
-                               
-                               if( cell_current->config == k_cell_type_split )
-                               {
-                                       // Flip flop L/R
-                                       fish->dir[0] = cell_current->state&FLAG_FLIP_FLOP?1:-1;
-                                       fish->dir[1] = 0;
+                                       fish->pos[0] += fish->dir[0];
+                                       fish->pos[1] += fish->dir[1];
                                        
-                                       if( !(cell_current->state & FLAG_TARGETED) )
-                                               cell_current->state ^= FLAG_FLIP_FLOP;
-                               }
-                               else if( cell_current->config == k_cell_type_merge )
-                               {
-                                       // Can only move up
-                                       fish->dir[0] = 0;
-                                       fish->dir[1] = -1;
-                               }
-                               else
-                               {
-                                       struct cell *cell_next = pcell( (v2i){ fish->pos[0]+fish->dir[0], fish->pos[1]+fish->dir[1] } );
-                                       if( !(cell_next->state & (FLAG_CANAL|FLAG_OUTPUT)) )
+                                       struct cell *cell_entry = pcell( fish->pos );
+                                       
+                                       if( !(cell_entry->state & (FLAG_INPUT|FLAG_CANAL|FLAG_OUTPUT) ))
                                        {
-                                               // Try other directions for valid, so down, left, right..
-                                               v2i dirs[] = {{1,0},{-1,0},{0,-1}};
-                                               //vg_info( "Trying some other directions...\n" );
-                                               
-                                               for( int j = 0; j < vg_list_size(dirs); j ++ )
+                                               if( world_check_pos_ok( fish->pos ) )
+                                                       fish->state = k_fish_state_bg;
+                                               else
+                                                       fish->state = k_fish_state_dead;
+                                       }
+                                       else
+                                       {
+                                               if( fish->dir[0] )
                                                {
-                                                       if( (dirs[j][0] == -fish->dir[0]) && (dirs[j][1] == -fish->dir[1]) )
-                                                               continue;
-                                               
-                                                       if( pcell( (v2i){ fish->pos[0]+dirs[j][0], fish->pos[1]+dirs[j][1] } )->state & (FLAG_CANAL|FLAG_OUTPUT) )
+                                                       if( cell_entry->config == k_cell_type_split ||
+                                                                cell_entry->config == k_cell_type_ramp_right ||
+                                                                cell_entry->config == k_cell_type_ramp_left )
                                                        {
-                                                               fish->dir[0] = dirs[j][0];
-                                                               fish->dir[1] = dirs[j][1];
+                                                               // Special death (FALL)
+                                                               /*
+                                                               v2_sub( fish->physics_co, fish->physics_v, fish->physics_v );
+                                                               v2_divs( fish->physics_v, vg_time_delta, fish->physics_v );
+                                                               */
+                                                               
+                                                               fish->state = k_fish_state_dead;
+                                                               vg_error( "REMOVE THIS CONDITION\n" );
+                                                               continue;
                                                        }
                                                }
+                                       
+                                               if( cell_entry->config == k_cell_type_split )
+                                               {
+                                                       sfx_set_playrnd( &audio_splitter, &audio_system_balls_important, 0, 1 );
+                                                       cell_entry->state |= FLAG_FLIP_ROTATING;
+                                               }
                                        }
                                }
-                               
-                               fish->pos[0] += fish->dir[0];
-                               fish->pos[1] += fish->dir[1];
-                               
-                               struct cell *cell_entry = pcell( fish->pos );
-                               
-                               if( !(cell_entry->state & (FLAG_INPUT|FLAG_CANAL|FLAG_OUTPUT) ))
-                                       fish->alive = 0;
-                               else
+                               else if( fish->state == k_fish_state_bg )
                                {
-                                       if( fish->dir[0] )
+                                       fish->pos[0] += fish->dir[0];
+                                       fish->pos[1] += fish->dir[1];
+                                       
+                                       if( !world_check_pos_ok( fish->pos ) )
+                                               fish->state = k_fish_state_dead;
+                                       else
                                        {
-                                               if( cell_entry->config == k_cell_type_split ||
-                                                        cell_entry->config == k_cell_type_ramp_right ||
-                                                        cell_entry->config == k_cell_type_ramp_left )
+                                               struct cell *cell_entry = pcell( fish->pos );
+                                               
+                                               if( cell_entry->state & FLAG_CANAL )
                                                {
-                                                       // Special death (FALL)                                                 
-                                                       v2_sub( fish->physics_co, fish->physics_v, fish->physics_v );
-                                                       v2_divs( fish->physics_v, vg_time_delta, fish->physics_v );
-
-                                                       fish->alive = -2;
-                                                       vg_warn( "Special death (fall)\n" );
-                                                       continue;
+                                                       if( cell_entry->config == k_cell_type_con_r || cell_entry->config == k_cell_type_con_u 
+                                                               || cell_entry->config == k_cell_type_con_l || cell_entry->config == k_cell_type_con_d )
+                                                       {
+                                                               fish->state = k_fish_state_alive;
+                                                               
+                                                               fish->dir[0] = 0;
+                                                               fish->dir[1] = 0;
+                                                               
+                                                               switch( cell_entry->config )
+                                                               {
+                                                                       case k_cell_type_con_r: fish->dir[0] =  1; break;
+                                                                       case k_cell_type_con_l: fish->dir[0] = -1; break;
+                                                                       case k_cell_type_con_u: fish->dir[1] =  1; break;
+                                                                       case k_cell_type_con_d: fish->dir[1] = -1; break;
+                                                               }
+                                                       }
                                                }
                                        }
-                               
-                                       if( cell_entry->config == k_cell_type_split )
-                                       {
-                                               sfx_set_playrnd( &audio_splitter, &audio_system_balls_important, 0, 1 );
-                                               cell_entry->state |= FLAG_FLIP_ROTATING;
-                                       }
                                }
+                               else { vg_error( "fish behaviour unimplemented for behaviour type (%d)\n" ); }
                                
-                               if( fish->alive )
+                               if( fish->state >= k_fish_state_alive )
                                        alive_count ++;
                        }
                        
@@ -1448,7 +1508,7 @@ void vg_update(void)
                        {
                                struct fish *fish = &world.fishes[i];
                                
-                               if( fish->alive == 1 )
+                               if( fish->state == k_fish_state_alive )
                                {
                                        struct cell *cell_current = pcell( fish->pos );
 
@@ -1476,16 +1536,17 @@ void vg_update(void)
                        // Third pass (collisions)
                        for( int i = 0; i < world.num_fishes; i ++ )
                        {
-                               if( world.fishes[i].alive == 1 )
+                               if( world.fishes[i].state == k_fish_state_alive )
                                {
                                        for( int j = i+1; j < world.num_fishes; j ++ )
                                        {
-                                               if( (world.fishes[j].alive == 1) && (world.fishes[i].pos[0] == world.fishes[j].pos[0]) &&
+                                               if( (world.fishes[j].state == k_fish_state_alive) && 
+                                                        (world.fishes[i].pos[0] == world.fishes[j].pos[0]) &&
                                                         (world.fishes[i].pos[1] == world.fishes[j].pos[1]) )
                                                {
                                                        // Shatter death (+0.5s)
-                                                       world.fishes[i].alive = -1;
-                                                       world.fishes[j].alive = -1;
+                                                       world.fishes[i].state = k_fish_state_soon_dead;
+                                                       world.fishes[j].state = k_fish_state_soon_dead;
                                                        world.fishes[i].death_time = 0.5f;
                                                        world.fishes[j].death_time = 0.5f;
                                                }
@@ -1508,7 +1569,7 @@ void vg_update(void)
                                                struct fish *fish = &world.fishes[world.num_fishes++];
                                                fish->pos[0] = posx;
                                                fish->pos[1] = posy;
-                                               fish->alive = 1;
+                                               fish->state = k_fish_state_alive;
                                                fish->payload = term->runs[ world.sim_run ].conditions[ world.sim_frame ];
                                                
                                                int can_spawn = 0;
@@ -1616,78 +1677,79 @@ void vg_update(void)
                {
                        struct fish *fish = &world.fishes[i];
                        
-                       if( fish->alive == 0 )
+                       if( fish->state == k_fish_state_dead )
                                continue;
                        
-                       if( fish->alive == -1 && (world.frame_lerp > fish->death_time) )
+                       if( fish->state == k_fish_state_soon_dead && (world.frame_lerp > fish->death_time) )
                                continue; // Todo: particle thing?
+                               
+                       struct cell *cell = pcell(fish->pos);
+                       v2f const *curve;
                        
-                       if( fish->alive == -2 )
+                       float t = world.frame_lerp;
+                       float ti = 1.0f-t;
+                       
+                       v2_copy( fish->physics_co, fish->physics_v );
+                       
+                       switch( cell->config )
                        {
-                               v2_muladds( fish->physics_v, (v2f){ 0.0, -9.8f }, vg_time_delta, fish->physics_v );
-                               v2_muladds( fish->physics_co, fish->physics_v, vg_time_delta, fish->physics_co );
+                               case 13:
+                                       if( fish->dir[0] == 1 )
+                                               curve = curve_12;
+                                       else
+                                               curve = curve_9;
+                               break;
+                               case k_cell_type_con_r: curve = curve_1; 
+                                       if( fish->dir[0] == 1 ) t = ti;
+                               break;
+                               case k_cell_type_con_l: curve = curve_4; 
+                                       if( fish->dir[0] == -1 ) t = ti;
+                               break;
+                               case k_cell_type_con_u: curve = curve_2; 
+                                       if( fish->dir[1] == 1 ) t = ti;
+                               break;
+                               case k_cell_type_con_d: curve = curve_8; 
+                                       if( fish->dir[1] == 1 ) t = ti;
+                               break;
+                               case 3: curve = curve_3; break;
+                               case 6: curve = curve_6; break;
+                               case 9: curve = curve_9; break;
+                               case 12: curve = curve_12; break;
+                               case 7:
+                                       if( t > curve_7_linear_section )
+                                       {
+                                               t -= curve_7_linear_section;
+                                               t *= (1.0f/(1.0f-curve_7_linear_section));
+                                               
+                                               curve = cell->state & FLAG_FLIP_FLOP? curve_7: curve_7_1;
+                                       }
+                                       else curve = NULL;
+                               break;
+                               default: curve = NULL; break;
                        }
-                       else
-                       {               
-                               struct cell *cell = pcell(fish->pos);
-                               v2f const *curve;
-                               
-                               float t = world.frame_lerp;
-                               
-                               v2_copy( fish->physics_co, fish->physics_v );
-                               
-                               switch( cell->config )
-                               {
-                                       case 13:
-                                               if( fish->dir[0] == 1 )
-                                                       curve = curve_12;
-                                               else
-                                                       curve = curve_9;
-                                       break;
-                                       case 1: curve = curve_1; break;
-                                       case 4: curve = curve_4; break;
-                                       case 2: curve = curve_2; break;
-                                       case 8: curve = curve_8; break;
-                                       case 3: curve = curve_3; break;
-                                       case 6: curve = curve_6; break;
-                                       case 9: curve = curve_9; break;
-                                       case 12: curve = curve_12; break;
-                                       case 7:
-                                               if( t > curve_7_linear_section )
-                                               {
-                                                       t -= curve_7_linear_section;
-                                                       t *= (1.0f/(1.0f-curve_7_linear_section));
-                                                       
-                                                       curve = cell->state & FLAG_FLIP_FLOP? curve_7: curve_7_1;
-                                               }
-                                               else curve = NULL;
-                                       break;
-                                       default: curve = NULL; break;
-                               }
 
-                               if( curve )
-                               {
-                                       float t2 = t * t;
-                                       float t3 = t * t * t;
+                       if( curve )
+                       {
+                               float t2 = t * t;
+                               float t3 = t * t * t;
 
-                                       float cA = 3.0f*t2 - 3.0f*t3;
-                                       float cB = 3.0f*t3 - 6.0f*t2 + 3.0f*t;
-                                       float cC = 3.0f*t2 - t3 - 3.0f*t + 1.0f;
+                               float cA = 3.0f*t2 - 3.0f*t3;
+                               float cB = 3.0f*t3 - 6.0f*t2 + 3.0f*t;
+                               float cC = 3.0f*t2 - t3 - 3.0f*t + 1.0f;
 
-                                       fish->physics_co[0] = t3*curve[3][0] + cA*curve[2][0] + cB*curve[1][0] + cC*curve[0][0];
-                                       fish->physics_co[1] = t3*curve[3][1] + cA*curve[2][1] + cB*curve[1][1] + cC*curve[0][1];
-                                       fish->physics_co[0] += (float)fish->pos[0];
-                                       fish->physics_co[1] += (float)fish->pos[1];
-                               }
-                               else
-                               {
-                                       v2f origin;
-                                       origin[0] = (float)fish->pos[0] + (float)fish->dir[0]*-0.5f + 0.5f;
-                                       origin[1] = (float)fish->pos[1] + (float)fish->dir[1]*-0.5f + 0.5f;
-                                       
-                                       fish->physics_co[0] = origin[0] + (float)fish->dir[0]*t;
-                                       fish->physics_co[1] = origin[1] + (float)fish->dir[1]*t;
-                               }
+                               fish->physics_co[0] = t3*curve[3][0] + cA*curve[2][0] + cB*curve[1][0] + cC*curve[0][0];
+                               fish->physics_co[1] = t3*curve[3][1] + cA*curve[2][1] + cB*curve[1][1] + cC*curve[0][1];
+                               fish->physics_co[0] += (float)fish->pos[0];
+                               fish->physics_co[1] += (float)fish->pos[1];
+                       }
+                       else
+                       {
+                               v2f origin;
+                               origin[0] = (float)fish->pos[0] + (float)fish->dir[0]*-0.5f + 0.5f;
+                               origin[1] = (float)fish->pos[1] + (float)fish->dir[1]*-0.5f + 0.5f;
+                               
+                               fish->physics_co[0] = origin[0] + (float)fish->dir[0]*t;
+                               fish->physics_co[1] = origin[1] + (float)fish->dir[1]*t;
                        }
                }
        }
@@ -1843,10 +1905,10 @@ void vg_render(void)
                {
                        struct fish *fish = &world.fishes[i];
                        
-                       if( fish->alive == 0 )
+                       if( fish->state == k_fish_state_dead || fish->state == k_fish_state_bg )
                                continue;
                        
-                       if( fish->alive == -1 && (world.frame_lerp > fish->death_time) )
+                       if( fish->state == k_fish_state_soon_dead && (world.frame_lerp > fish->death_time) )
                                continue;
                        
                        v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };