fishladder.c

   1 // Copyright (C) 2021 Harry Godden (hgn) - All Rights Reserved
   2
   3 //#define VG_STEAM
   4 #include "vg/vg.h"
   5 #include "fishladder_resources.h"
   6
   7 const char *level_pack[] =
   8 {
   9         // Level 0
  10         "#########;\n"
  11         "###-#####;acac\n"
  12         "##     ##;\n"
  13         "##     ##;\n"
  14         "##     ##;\n"
  15         "##     ##;\n"
  16         "#####+###;acac\n"
  17         "#########;\n",
  18
  19         // Level 1
  20         "#########;\n"
  21         "##-###-##;b,b\n"
  22         "##     ##;\n"
  23         "##     ##;\n"
  24         "##     ##;\n"
  25         "##     ##;\n"
  26         "##     ##;\n"
  27         "####+####;bb\n"
  28         "#########;\n",
  29
  30         // Level 2
  31         "###########;\n"
  32         "#####-#####;bbbbb\n"
  33         "##       ##;\n"
  34         "##      ###;\n"
  35         "##  #    ##;\n"
  36         "##       ##;\n"
  37         "###+##+####;bbb,bb\n"
  38         "###########;\n",
  39
  40         // Level 3
  41         "#############;\n"
  42         "###-#####-###;a,aaa\n"
  43         "##         ##;\n"
  44         "##         ##;\n"
  45         "##         ##;\n"
  46         "##         ##;\n"
  47         "##         ##;\n"
  48         "##         ##;\n"
  49         "######+######;aaaa\n"
  50         "#############;\n",
  51
  52         // Level 4
  53         "#############;\n"
  54         "###-#####-###;aaa,aa\n"
  55         "##         ##;\n"
  56         "##         ##;\n"
  57         "##         ##;\n"
  58         "##         ##;\n"
  59         "##         ##;\n"
  60         "##         ##;\n"
  61         "###+#####+###;aa,aaa\n"
  62         "#############;\n"
  63 };
  64
  65 m3x3f m_projection;
  66 m3x3f m_view;
  67 m3x3f m_mdl;
  68
  69 #define FLAG_INPUT 0x1
  70 #define FLAG_OUTPUT 0x2
  71 #define FLAG_CANAL 0x4
  72 #define FLAG_WALL 0x8
  73 #define FLAG_FLIP_FLOP 0x100
  74 #define FLAG_FLIP_ROTATING 0x200
  75
  76 /*
  77         0000 0   | 0001 1   | 0010 2   | 0011 3
  78                            |          |    |     |    |
  79                 X     |           X=    |    X     |    X=
  80                            |          |          |
  81         0100 4   | 0101 5   | 0110 6   | 0111 7
  82                            |          |    |     |    |
  83           =X     |   =X=    |   =X     |   =X=
  84                            |          |          |
  85         1000 8   | 1001 9   | 1010 10  | 1011 11
  86                       |          |    |     |    |
  87                 X     |    X=    |    X     |    X=
  88                 |               |    |     |    |     |    |
  89         1100 12  | 1101 13  | 1110 14  | 1111 15
  90                       |          |    |     |    |
  91           =X     |   =X=    |   =X     |   =X=
  92                 |          |    |     |    |     |    |
  93 */
  94
  95 enum cell_type
  96 {
  97         k_cell_type_split = 7,
  98         k_cell_type_merge = 13
  99 };
 100
 101 v3f colour_sets[] =
 102 { { 0.9f, 0.2f, 0.01f },
 103   { 0.2f, 0.9f, 0.14f },
 104   { 0.1f, 0.3f, 0.85f } };
 105
 106 static void colour_code_v3( char cc, v3f target )
 107 {
 108         if( cc >= 'a' && cc <= 'z' )
 109         {
 110                 int id = cc - 'a';
 111
 112                 if( id < vg_list_size( colour_sets ) )
 113                 {
 114                         v3_copy( colour_sets[ id ], target );
 115                         return;
 116                 }
 117         }
 118
 119         v3_copy( (v3f){0.0f,0.0f,0.0f}, target );
 120 }
 121
 122 struct mesh
 123 {
 124         GLuint vao, vbo;
 125         u32 elements;
 126 };
 127
 128 static void init_mesh( struct mesh *m, float *tris, u32 length )
 129 {
 130         m->elements = length/3;
 131         glGenVertexArrays( 1, &m->vao );
 132         glGenBuffers( 1, &m->vbo );
 133
 134         glBindVertexArray( m->vao );
 135         glBindBuffer( GL_ARRAY_BUFFER, m->vbo );
 136         glBufferData( GL_ARRAY_BUFFER, length*sizeof(float), tris, GL_STATIC_DRAW );
 137
 138         glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0 );
 139         glEnableVertexAttribArray( 0 );
 140
 141         VG_CHECK_GL();
 142 }
 143
 144 static void free_mesh( struct mesh *m )
 145 {
 146         glDeleteVertexArrays( 1, &m->vao );
 147         glDeleteBuffers( 1, &m->vbo );
 148 }
 149
 150 static void draw_mesh( int const start, int const count )
 151 {
 152         glDrawArrays( GL_TRIANGLES, start*3, count*3 );
 153 }
 154
 155 static void use_mesh( struct mesh *m )
 156 {
 157         glBindVertexArray( m->vao );
 158 }
 159
 160 struct world
 161 {
 162         struct cell
 163         {
 164                 u32 state;
 165                 u8 config;
 166         }
 167         *data;
 168
 169         u32 frame;
 170
 171         u32 sim_frame;
 172         float sim_start;
 173         int simulating;
 174
 175         struct cell_terminal
 176         {
 177                 // TODO: Split into input/output structures
 178                 char *conditions;
 179                 char recv[12];
 180                 int recv_count;
 181                 int id;
 182         }
 183         *io;
 184
 185         u32 w, h;
 186
 187         struct mesh tile, circle;
 188
 189         int selected, tile_x, tile_y;
 190         v2f tile_pos;
 191
 192         struct fish
 193         {
 194                 v2i pos;
 195                 v2i dir;
 196                 int alive;
 197                 char payload;
 198         }
 199         fishes[16];
 200
 201         int num_fishes;
 202 } world = {};
 203
 204 static void map_free(void)
 205 {
 206         for( int i = 0; i < arrlen( world.io ); i ++ )
 207                 arrfree( world.io[ i ].conditions );
 208
 209         arrfree( world.data );
 210         arrfree( world.io );
 211
 212         world.w = 0;
 213         world.h = 0;
 214         world.data = NULL;
 215         world.io = NULL;
 216 }
 217
 218 static void map_reclassify( v2i start, v2i end );
 219 static int map_load( const char *str )
 220 {
 221         map_free();
 222
 223         char const *c = str;
 224
 225         // Scan for width
 226         for(;; world.w ++)
 227         {
 228                 if( str[world.w] == ';' )
 229                         break;
 230                 else if( !str[world.w] )
 231                 {
 232                         vg_error( "Unexpected EOF when parsing level\n" );
 233                         return 0;
 234                 }
 235         }
 236
 237         struct cell *row = arraddnptr( world.data, world.w );
 238         int cx = 0;
 239         int reg_start = 0, reg_end = 0;
 240
 241         for(;;)
 242         {
 243                 if( !*c )
 244                         break;
 245
 246                 if( *c == ';' )
 247                 {
 248                         c ++;
 249
 250                         // Parse attribs
 251                         if( *c != '\n' )
 252                         {
 253                                 while( *c )
 254                                 {
 255                                         if( reg_start < reg_end )
 256                                         {
 257                                                 if( *c >= 'a' && *c <= 'z' )
 258                                                 {
 259                                                         arrpush( world.io[ reg_start ].conditions, *c );
 260                                                 }
 261                                                 else
 262                                                 {
 263                                                         if( *c == ',' || *c == '\n' )
 264                                                         {
 265                                                                 reg_start ++;
 266
 267                                                                 if( *c == '\n' )
 268                                                                         break;
 269                                                         }
 270                                                         else
 271                                                         {
 272                                                                 vg_error( "Unkown attribute '%c' (row: %u)\n", *c, world.h );
 273                                                                 return 0;
 274                                                         }
 275                                                 }
 276                                         }
 277                                         else
 278                                         {
 279                                                 vg_error( "Too many values to assign (row: %u)\n", world.h );
 280                                                 return 0;
 281                                         }
 282
 283                                         c ++;
 284                                 }
 285                         }
 286
 287                         if( reg_start != reg_end )
 288                         {
 289                                 vg_error( "Not enough values assigned (row: %u, %u of %u)\n", world.h, reg_start, reg_end );
 290                                 return 0;
 291                         }
 292
 293                         if( cx != world.w )
 294                         {
 295                                 vg_error( "Not enough cells to match previous row definition (row: %u, %u<%u)\n", world.h, cx, world.w );
 296                                 return 0;
 297                         }
 298
 299                         row = arraddnptr( world.data, world.w );
 300                         cx = 0;
 301                         world.h ++;
 302                         reg_end = reg_start = arrlen( world.io );
 303                 }
 304                 else
 305                 {
 306                         if( cx == world.w )
 307                         {
 308                                 vg_error( "Too many cells to match previous row definition (row: %u, %u>%u)\n", world.h, cx, world.w );
 309                                 return 0;
 310                         }
 311
 312                         // Tile initialization
 313                         // row[ cx ] .. etc
 314
 315                         if( *c == '+' || *c == '-' )
 316                         {
 317                                 struct cell_terminal term = { .id = cx + world.h*world.w };
 318                                 arrpush( world.io, term );
 319                                 row[ cx ++ ].state = *c == '+'? FLAG_INPUT: FLAG_OUTPUT;
 320                                 reg_end ++;
 321                         }
 322                         else if( *c == '#' )
 323                         {
 324                                 row[ cx ++ ].state = FLAG_WALL;
 325                         }
 326                         else
 327                         {
 328                                 row[ cx ++ ].state = 0x00;
 329                         }
 330                 }
 331
 332                 c ++;
 333         }
 334
 335         map_reclassify( NULL, NULL );
 336         vg_success( "Map loaded! (%u:%u)\n", world.w, world.h );
 337         return 1;
 338 }
 339
 340 static struct cell *pcell( v2i pos )
 341 {
 342         return &world.data[ pos[1]*world.w + pos[0] ];
 343 }
 344
 345 int main( int argc, char *argv[] )
 346 {
 347         vg_init( argc, argv, "Fish (Marbles Computer) Ladder Simulator 2022 | N,M: change level | SPACE: Test | LeftClick: Toggle tile" );
 348 }
 349
 350 void vg_start(void)
 351 {
 352         // Quad mesh
 353         {
 354                 float quad_mesh[] =
 355                 {
 356                         0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
 357                         0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f,
 358
 359                         0.48f, 0.48f, 0.5f, 0.52f, 0.52f, 0.52f, // Static dot
 360                         0.375f, 0.25f, 0.5f, 0.75f, 0.625f, 0.25f, // Downwards pointing arrow
 361                         0.25f, 0.625f, 0.75f, 0.5f, 0.25f, 0.375f, // Left
 362                         0.625f, 0.75f, 0.5f, 0.25f, 0.375f, 0.75f, // up
 363                         0.75f, 0.375f, 0.25f, 0.5f, 0.75f, 0.625f
 364                 };
 365
 366                 init_mesh( &world.tile, quad_mesh, vg_list_size(quad_mesh) );
 367         }
 368
 369         // Circle mesh
 370         {
 371                 float circle_mesh[32*6*3];
 372                 int res = vg_list_size( circle_mesh ) / (6*3);
 373
 374                 for( int i = 0; i < res; i ++ )
 375                 {
 376                         v2f v0 = { sinf( ((float)i/(float)res)*VG_TAUf ), cosf( ((float)i/(float)res)*VG_TAUf ) };
 377                         v2f v1 = { sinf( ((float)(i+1)/(float)res)*VG_TAUf ), cosf( ((float)(i+1)/(float)res)*VG_TAUf ) };
 378
 379                         circle_mesh[ i*6+0 ] = 0.0f;
 380                         circle_mesh[ i*6+1 ] = 0.0f;
 381
 382                         v2_copy( v0, circle_mesh + 32*6 + i*12 );
 383                         v2_muls( v0, 0.8f, circle_mesh + 32*6 + i*12+2 );
 384                         v2_copy( v1, circle_mesh + 32*6 + i*12+4 );
 385
 386                         v2_copy( v1, circle_mesh + 32*6 + i*12+6 );
 387                         v2_muls( v1, 0.8f, circle_mesh + 32*6 + i*12+8 );
 388                         v2_muls( v0, 0.8f, circle_mesh + 32*6 + i*12+10 );
 389
 390                         v2_copy( v0, circle_mesh + i*6+4 );
 391                         v2_copy( v1, circle_mesh + i*6+2 );
 392                         v2_copy( v0, circle_mesh+i*6+4 );
 393                         v2_copy( v1, circle_mesh+i*6+2 );
 394                 }
 395
 396                 init_mesh( &world.circle, circle_mesh, vg_list_size( circle_mesh ) );
 397         }
 398
 399         resource_load_main();
 400
 401         map_load( level_pack[ 0 ] );
 402 }
 403
 404 void vg_free(void)
 405 {
 406         resource_free_main();
 407
 408         free_mesh( &world.tile );
 409         free_mesh( &world.circle );
 410
 411         map_free();
 412 }
 413
 414 static int cell_interactive( v2i co )
 415 {
 416         // Bounds check
 417         if( co[0] < 2 || co[0] >= world.w-2 || co[1] < 2 || co[1] >= world.h-2 )
 418                 return 0;
 419
 420         // Flags check
 421         if( world.data[ world.w*co[1] + co[0] ].state & (FLAG_WALL|FLAG_INPUT|FLAG_OUTPUT) )
 422                 return 0;
 423
 424         // List of 3x3 configurations that we do not allow
 425         static u32 invalid_src[][9] =
 426         {
 427                 { 0,1,0,
 428                   1,1,1,
 429                   0,1,0
 430                 },
 431                 { 0,0,0,
 432                   0,1,1,
 433                   0,1,1
 434                 },
 435                 { 0,0,0,
 436                   1,1,0,
 437                   1,1,0
 438                 },
 439                 { 0,1,1,
 440                   0,1,1,
 441                   0,0,0
 442                 },
 443                 { 1,1,0,
 444                   1,1,0,
 445                   0,0,0
 446                 },
 447                 { 0,1,0,
 448                   0,1,1,
 449                   0,1,0
 450                 },
 451                 { 0,1,0,
 452                   1,1,0,
 453                   0,1,0
 454                 }
 455         };
 456
 457         // Statically compile invalid configurations into bitmasks
 458         static u32 invalid[ vg_list_size(invalid_src) ];
 459
 460         for( int i = 0; i < vg_list_size(invalid_src); i ++ )
 461         {
 462                 u32 comped = 0x00;
 463
 464                 for( int j = 0; j < 3; j ++ )
 465                         for( int k = 0; k < 3; k ++ )
 466                                 comped |= invalid_src[i][ j*3+k ] << ((j*5)+k);
 467
 468                 invalid[i] = comped;
 469         }
 470
 471         // Extract 5x5 grid surrounding tile
 472         u32 blob = 0x1000;
 473         for( int y = co[1]-2; y < co[1]+3; y ++ )
 474                 for( int x = co[0]-2; x < co[0]+3; x ++ )
 475                 {
 476                         struct cell *cell = pcell((v2i){x,y});
 477
 478                         if( cell && (cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT)) )
 479                                 blob |= 0x1 << ((y-(co[1]-2))*5 + x-(co[0]-2));
 480                 }
 481
 482         // Run filter over center 3x3 grid to check for invalid configurations
 483         int kernel[] = { 0, 1, 2, 5, 6, 7, 10, 11, 12 };
 484         for( int i = 0; i < vg_list_size(kernel); i ++ )
 485         {
 486                 if( blob & (0x1 << (6+kernel[i])) )
 487                 {
 488                         u32 window = blob >> kernel[i];
 489
 490                         for( int j = 0; j < vg_list_size(invalid); j ++ )
 491                                 if((window & invalid[j]) == invalid[j])
 492                         return 0;
 493                 }
 494         }
 495
 496         return 1;
 497 }
 498
 499 static void map_reclassify( v2i start, v2i end )
 500 {
 501         v2i full_start = { 2,2 };
 502         v2i full_end = { world.w-2, world.h-2 };
 503
 504         if( !start || !end )
 505         {
 506                 start = full_start;
 507                 end = full_end;
 508         }
 509
 510         for( int y = vg_max( start[1], full_start[1] ); y < vg_min( end[1], full_end[1] ); y ++ )
 511         {
 512                 for( int x = vg_max( start[0], full_start[0] ); x < vg_min( end[0], full_end[0] ); x ++ )
 513                 {
 514                         v2i dirs[] = {{1,0},{0,1},{-1,0},{0,-1}};
 515
 516                         u8 config = 0x00;
 517
 518                         if( pcell((v2i){x,y})->state & FLAG_CANAL )
 519                         {
 520                                 for( int i = 0; i < vg_list_size( dirs ); i ++ )
 521                                 {
 522                                         struct cell *neighbour = pcell((v2i){x+dirs[i][0], y+dirs[i][1]});
 523                                         if( neighbour->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
 524                                                 config |= 0x1 << i;
 525                                 }
 526                         }
 527                         else config = 0xF;
 528
 529                         pcell((v2i){x,y})->config = config;
 530                 }
 531         }
 532 }
 533
 534 void vg_update(void)
 535 {
 536         static int curlevel = 0;
 537         int changelvl = curlevel;
 538         if( vg_get_button_down( "prev" ) ) { if( curlevel > 0 ) changelvl --; }
 539         else if( vg_get_button_down( "next" ) ) { if( curlevel < vg_list_size( level_pack )-1 ) changelvl ++; }
 540
 541         if( changelvl != curlevel )
 542         {
 543                 map_load( level_pack[ changelvl ] );
 544                 curlevel = changelvl;
 545
 546                 // TEMP!!! code dupe
 547                 world.simulating = 0;
 548                 world.num_fishes = 0;
 549                 world.sim_frame = 0;
 550
 551                 for( int i = 0; i < arrlen( world.io ); i ++ )
 552                         world.io[i].recv_count = 0;
 553
 554                 vg_info( "Stopping simulation!\n" );
 555         }
 556
 557         float ratio = (float)vg_window_y / (float)vg_window_x;
 558         float const size = 9.5f;
 559
 560         v3f origin;
 561         origin[0] = -0.5f * world.w;
 562         origin[1] = -0.5f * world.h;
 563         origin[2] = 0.0f;
 564
 565         m3x3_projection( m_projection, -size, size, -size*ratio, size*ratio );
 566         m3x3_identity( m_view );
 567         m3x3_translate( m_view, origin );
 568         m3x3_mul( m_projection, m_view, vg_pv );
 569         vg_projection_update();
 570
 571         // Input stuff
 572         v2_copy( vg_mouse_ws, world.tile_pos );
 573
 574         world.tile_x = floorf( world.tile_pos[0] );
 575         world.tile_y = floorf( world.tile_pos[1] );
 576
 577         // Tilemap editing
 578         if( !world.simulating )
 579         {
 580                 if( cell_interactive( (v2i){ world.tile_x, world.tile_y } ))
 581                 {
 582                         world.selected = world.tile_y * world.w + world.tile_x;
 583
 584                         if( vg_get_button_down("primary") )
 585                         {
 586                                 world.data[ world.selected ].state ^= FLAG_CANAL;
 587
 588                                 if( world.data[ world.selected ].state & FLAG_CANAL )
 589                                         sfx_set_playrnd( &audio_tile_mod, &audio_system_sfx, 3, 6 );
 590                                 else
 591                                         sfx_set_playrnd( &audio_tile_mod, &audio_system_sfx, 0, 3 );
 592
 593                                 map_reclassify(         (v2i){ world.tile_x -2, world.tile_y -2 },
 594                                                                                 (v2i){ world.tile_x +2, world.tile_y +2 } );
 595                         }
 596                 }
 597                 else
 598                         world.selected = -1;
 599         }
 600         else world.selected = -1;
 601
 602         // Simulation stop/start
 603         if( vg_get_button_down("go") )
 604         {
 605                 if( world.simulating )
 606                 {
 607                         world.simulating = 0;
 608                         world.num_fishes = 0;
 609                         world.sim_frame = 0;
 610
 611                         for( int i = 0; i < arrlen( world.io ); i ++ )
 612                                 world.io[i].recv_count = 0;
 613
 614                         vg_info( "Stopping simulation!\n" );
 615
 616                         sfx_system_fadeout( &audio_system_balls_rolling, 44100 );
 617                 }
 618                 else
 619                 {
 620                         vg_success( "Starting simulation!\n" );
 621
 622                         sfx_set_playrnd( &audio_rolls, &audio_system_balls_rolling, 0, 1 );
 623
 624                         world.simulating = 1;
 625                         world.num_fishes = 0;
 626                         world.sim_frame = 0;
 627                         world.sim_start = vg_time;
 628
 629                         for( int i = 0; i < world.w*world.h; i ++ )
 630                         {
 631                                 world.data[ i ].state &= ~FLAG_FLIP_FLOP;
 632                         }
 633
 634                         for( int i = 0; i < arrlen( world.io ); i ++ )
 635                                 world.io[i].recv_count = 0;
 636                 }
 637         }
 638
 639         // Fish ticks
 640         if( world.simulating )
 641         {
 642                 while( world.sim_frame < (int)((vg_time-world.sim_start)*2.0f) )
 643                 {
 644                         //vg_info( "frame: %u\n", world.sim_frame );
 645                         sfx_set_playrnd( &audio_random, &audio_system_balls_switching, 0, 9 );
 646
 647                         for( int i = 0; i < arrlen( world.io ); i ++ )
 648                         {
 649                                 struct cell_terminal *term = &world.io[ i ];
 650                                 int posx = term->id % world.w;
 651                                 int posy = (term->id - posx)/world.w;
 652                                 int is_input = world.data[ term->id ].state & FLAG_INPUT;
 653
 654                                 if( is_input )
 655                                 {
 656                                         if( world.sim_frame < arrlen( term->conditions ) )
 657                                         {
 658                                                 struct fish *fish = &world.fishes[world.num_fishes++];
 659                                                 fish->pos[0] = posx;
 660                                                 fish->pos[1] = posy;
 661                                                 fish->alive = 1;
 662                                                 fish->payload = term->conditions[world.sim_frame];
 663
 664                                                 int can_spawn = 0;
 665
 666                                                 v2i dirs[] = {{1,0},{-1,0},{0,-1}};
 667                                                 for( int j = 0; j < vg_list_size(dirs); j ++ )
 668                                                         if( pcell( (v2i){ posx+dirs[j][0], posy+dirs[j][1] } )->state & FLAG_CANAL )
 669                                                         {
 670                                                                 fish->dir[0] = dirs[j][0];
 671                                                                 fish->dir[1] = dirs[j][1];
 672                                                                 can_spawn = 1;
 673                                                                 break;
 674                                                         }
 675
 676                                                 if( !can_spawn )
 677                                                         world.num_fishes--;
 678                                         }
 679                                 }
 680                         }
 681
 682                         // Update splitter deltas
 683                         for( int i = 0; i < world.h*world.w; i ++ )
 684                         {
 685                                 struct cell *cell = &world.data[i];
 686                                 if( cell->config == k_cell_type_split )
 687                                 {
 688                                         cell->state &= ~FLAG_FLIP_ROTATING;
 689                                 }
 690                         }
 691
 692                         for( int i = 0; i < world.num_fishes; i ++ )
 693                         {
 694                                 struct fish *fish = &world.fishes[i];
 695                                 struct cell *cell_current = pcell( fish->pos );
 696
 697                                 if( !fish->alive )
 698                                         continue;
 699
 700                                 // Apply to output
 701                                 if( cell_current->state & FLAG_OUTPUT )
 702                                 {
 703                                         for( int j = 0; j < arrlen( world.io ); j ++ )
 704                                         {
 705                                                 struct cell_terminal *term = &world.io[j];
 706
 707                                                 if( term->id == fish->pos[1]*world.w + fish->pos[0] )
 708                                                 {
 709                                                         term->recv[ term->recv_count ++ ] = fish->payload;
 710                                                         break;
 711                                                 }
 712                                         }
 713
 714                                         fish->alive = 0;
 715                                         continue;
 716                                 }
 717
 718                                 if( cell_current->config == k_cell_type_split )
 719                                 {
 720                                         // Flip flop L/R
 721                                         fish->dir[0] = cell_current->state&FLAG_FLIP_FLOP?1:-1;
 722                                         fish->dir[1] = 0;
 723
 724                                         cell_current->state ^= FLAG_FLIP_FLOP;
 725                                 }
 726                                 else if( cell_current->config == k_cell_type_merge )
 727                                 {
 728                                         // Can only move up
 729                                         fish->dir[0] = 0;
 730                                         fish->dir[1] = -1;
 731                                 }
 732                                 else
 733                                 {
 734                                         struct cell *cell_next = pcell( (v2i){ fish->pos[0]+fish->dir[0], fish->pos[1]+fish->dir[1] } );
 735                                         if( !(cell_next->state & (FLAG_CANAL|FLAG_OUTPUT)) )
 736                                         {
 737                                                 // Try other directions for valid, so down, left, right..
 738                                                 v2i dirs[] = {{1,0},{-1,0},{0,-1}};
 739                                                 vg_info( "Trying some other directions...\n" );
 740
 741                                                 for( int j = 0; j < vg_list_size(dirs); j ++ )
 742                                                 {
 743                                                         if( (dirs[j][0] == -fish->dir[0]) && (dirs[j][1] == -fish->dir[1]) )
 744                                                                 continue;
 745
 746                                                         if( pcell( (v2i){ fish->pos[0]+dirs[j][0], fish->pos[1]+dirs[j][1] } )->state & (FLAG_CANAL|FLAG_OUTPUT) )
 747                                                         {
 748                                                                 fish->dir[0] = dirs[j][0];
 749                                                                 fish->dir[1] = dirs[j][1];
 750                                                         }
 751                                                 }
 752                                         }
 753                                 }
 754
 755                                 fish->pos[0] += fish->dir[0];
 756                                 fish->pos[1] += fish->dir[1];
 757
 758                                 struct cell *cell_entry = pcell( fish->pos );
 759
 760                                 if( !(cell_entry->state & (FLAG_INPUT|FLAG_CANAL|FLAG_OUTPUT) ))
 761                                         fish->alive = 0;
 762                                 else
 763                                         if( cell_entry->config == k_cell_type_split )
 764                                         {
 765                                                 sfx_set_playrnd( &audio_splitter, &audio_system_balls_important, 0, 1 );
 766                                                 cell_entry->state |= FLAG_FLIP_ROTATING;
 767                                         }
 768                         }
 769
 770                         world.sim_frame ++;
 771                 }
 772         }
 773 }
 774
 775 static void render_tiles( v2i start, v2i end, v4f const regular_colour, v4f const selected_colour )
 776 {
 777         v2i full_start = { 0,0 };
 778         v2i full_end = { world.w, world.h };
 779
 780         if( !start || !end )
 781         {
 782                 start = full_start;
 783                 end = full_end;
 784         }
 785
 786         glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
 787
 788         for( int y = start[1]; y < end[1]; y ++ )
 789         {
 790                 for( int x = start[0]; x < end[0]; x ++ )
 791                 {
 792                         struct cell *cell = pcell((v2i){x,y});
 793                         int selected = world.selected == y*world.w + x;
 794
 795                         int tile_offsets[][2] =
 796                         {
 797                                 {2, 0}, {0, 3}, {0, 2}, {2, 2},
 798                                 {1, 0}, {2, 3}, {3, 2}, {1, 3},
 799                                 {3, 1}, {0, 1}, {1, 2}, {2, 1},
 800                                 {1, 1}, {3, 3}, {2, 1}, {2, 1}
 801                         };
 802
 803                         int uv[2] = { 3, 0 };
 804
 805                         if( cell->state & FLAG_CANAL )
 806                         {
 807                                 uv[0] = tile_offsets[ cell->config ][0];
 808                                 uv[1] = tile_offsets[ cell->config ][1];
 809                         }
 810
 811                         glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ), (float)x, (float)y, uv[0], uv[1] );
 812                         if( selected )
 813                         {
 814                                 glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, selected_colour );
 815                                 draw_mesh( 0, 2 );
 816                                 glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
 817                         }
 818                         else
 819                                 draw_mesh( 0, 2 );
 820                 }
 821         }
 822 }
 823
 824 void vg_render(void)
 825 {
 826         glViewport( 0,0, vg_window_x, vg_window_y );
 827
 828         glDisable( GL_DEPTH_TEST );
 829         glClearColor( 0.8f, 0.8f, 0.8f, 1.0f );
 830         glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 831
 832         float scaled_time = 0.0f, frame_lerp = 0.0f;
 833
 834         if( world.simulating )
 835         {
 836                 scaled_time = (vg_time-world.sim_start)*2.0f;
 837                 frame_lerp = scaled_time - (float)world.sim_frame;
 838         }
 839
 840         v4f const colour_default = {1.0f, 1.0f, 1.0f, 1.0f};
 841         v4f const colour_selected = {0.90f, 0.92f, 1.0f, 1.0f};
 842
 843         v2f const curve_3[] = {{0.5f,1.0f},{0.5f,0.625f},{0.625f,0.5f},{1.0f,0.5f}};
 844         v2f const curve_6[] = {{0.5f,1.0f},{0.5f,0.625f},{0.375f,0.5f},{0.0f,0.5f}};
 845         v2f const curve_9[] = {{1.0f,0.5f},{0.625f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
 846         v2f const curve_12[]= {{0.0f,0.5f},{0.375f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
 847
 848         v2f const curve_7[] = {{0.5f,0.8438f},{0.875f,0.8438f},{0.625f,0.5f},{1.0f,0.5f}};
 849         v2f const curve_7_1[] = {{0.5f,0.8438f},{1.0f-0.875f,0.8438f},{1.0-0.625f,0.5f},{0.0f,0.5f}};
 850
 851         float const curve_7_linear_section = 0.1562f;
 852
 853         // TILE SET RENDERING
 854         //      todo: just slam everything into a mesh...
 855         //          when user modifies a tile the neighbours can be easily uploaded to gpu mem
 856         //          in ~3 subBuffers
 857         //          Currently we're uploading a fair amount of data every frame anyway.
 858         //          NOTE: this is for final optimisations ONLY!
 859         // ======================================================================
 860
 861         use_mesh( &world.tile );
 862
 863         SHADER_USE( shader_tile_main );
 864
 865         m2x2f subtransform;
 866         m2x2_identity( subtransform );
 867         glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
 868         glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_main, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
 869         glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 0.0f );
 870
 871         // Bind textures
 872         vg_tex2d_bind( &tex_tile_data, 0 );
 873         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexGlyphs" ), 0 );
 874
 875         vg_tex2d_bind( &tex_wood, 1 );
 876         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexWood" ), 1 );
 877
 878         render_tiles( NULL, NULL, colour_default, colour_default );
 879
 880         glEnable(GL_BLEND);
 881         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 882         glBlendEquation(GL_FUNC_ADD);
 883
 884         SHADER_USE( shader_ball );
 885         glUniformMatrix3fv( SHADER_UNIFORM( shader_ball, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
 886
 887         vg_tex2d_bind( &tex_ball, 0 );
 888         glUniform1i( SHADER_UNIFORM( shader_ball, "uTexMain" ), 0 );
 889
 890         // Draw 'fish'
 891         if( world.simulating )
 892         {
 893                 for( int i = 0; i < world.num_fishes; i ++ )
 894                 {
 895                         struct fish *fish = &world.fishes[i];
 896
 897                         if( !fish->alive )
 898                                 continue;
 899
 900                         // Evaluate position
 901                         struct cell *cell = pcell(fish->pos);
 902                         v2f fish_pos;
 903
 904                         v2f const *curve;
 905
 906                         float t = frame_lerp;
 907
 908                         switch( cell->config )
 909                         {
 910                                 case 13:
 911                                         if( fish->dir[0] == 1 )
 912                                                 curve = curve_12;
 913                                         else
 914                                                 curve = curve_9;
 915                                 break;
 916                                 case 3: curve = curve_3; break;
 917                                 case 6: curve = curve_6; break;
 918                                 case 9: curve = curve_9; break;
 919                                 case 12: curve = curve_12; break;
 920                                 case 7:
 921                                         if( t > curve_7_linear_section )
 922                                         {
 923                                                 t -= curve_7_linear_section;
 924                                                 t *= (1.0f/(1.0f-curve_7_linear_section));
 925
 926                                                 curve = cell->state & FLAG_FLIP_FLOP? curve_7: curve_7_1;
 927                                         }
 928                                         else curve = NULL;
 929                                 break;
 930                                 default: curve = NULL; break;
 931                         }
 932
 933                         if( curve )
 934                         {
 935                                 float t2 = t * t;
 936                                 float t3 = t * t * t;
 937
 938                                 float cA = 3.0f*t2 - 3.0f*t3;
 939                                 float cB = 3.0f*t3 - 6.0f*t2 + 3.0f*t;
 940                                 float cC = 3.0f*t2 - t3 - 3.0f*t + 1.0f;
 941
 942                                 fish_pos[0] = t3*curve[3][0] + cA*curve[2][0] + cB*curve[1][0] + cC*curve[0][0];
 943                                 fish_pos[1] = t3*curve[3][1] + cA*curve[2][1] + cB*curve[1][1] + cC*curve[0][1];
 944                                 fish_pos[0] += (float)fish->pos[0];
 945                                 fish_pos[1] += (float)fish->pos[1];
 946                         }
 947                         else
 948                         {
 949                                 v2f origin;
 950                                 origin[0] = (float)fish->pos[0] + (float)fish->dir[0]*-0.5f + 0.5f;
 951                                 origin[1] = (float)fish->pos[1] + (float)fish->dir[1]*-0.5f + 0.5f;
 952
 953                                 fish_pos[0] = origin[0] + (float)fish->dir[0]*t;
 954                                 fish_pos[1] = origin[1] + (float)fish->dir[1]*t;
 955                         }
 956
 957                         v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
 958                         colour_code_v3( fish->payload, dot_colour );
 959
 960                         glUniform3fv( SHADER_UNIFORM( shader_ball, "uColour" ), 1, dot_colour );
 961                         glUniform2f( SHADER_UNIFORM( shader_ball, "uOffset" ), fish_pos[0], fish_pos[1] );
 962                         draw_mesh( 0, 32 );
 963                 }
 964         }
 965
 966
 967         SHADER_USE( shader_tile_main );
 968
 969         // Bind textures
 970         vg_tex2d_bind( &tex_tile_data, 0 );
 971         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexGlyphs" ), 0 );
 972
 973         vg_tex2d_bind( &tex_wood, 1 );
 974         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexWood" ), 1 );
 975
 976         render_tiles( NULL, NULL, colour_default, colour_selected  );
 977
 978         //      Draw splitters
 979
 980         for( int y = 0; y < world.h; y ++ )
 981         {
 982                 for( int x = 0; x < world.w; x ++ )
 983                 {
 984                         struct cell *cell = pcell((v2i){x,y});
 985
 986                         if( cell->config == k_cell_type_split )
 987                         {
 988                                 float rotation = cell->state & FLAG_FLIP_FLOP? vg_rad( -45.0f ): vg_rad( 45.0f );
 989
 990                                 if( cell->state & FLAG_FLIP_ROTATING )
 991                                 {
 992                                         if( (frame_lerp > curve_7_linear_section) )
 993                                         {
 994                                                 float const rotation_speed = 0.4f;
 995                                                 if( (frame_lerp < 1.0f-rotation_speed) )
 996                                                 {
 997                                                         float t = frame_lerp - curve_7_linear_section;
 998                                                         t *= -2.0f * (1.0f/(1.0f-(curve_7_linear_section+rotation_speed)));
 999                                                         t += 1.0f;
1000
1001                                                         rotation *= t;
1002                                                 }
1003                                                 else
1004                                                         rotation *= -1.0f;
1005                                         }
1006                                 }
1007
1008                                 m2x2_create_rotation( subtransform, rotation );
1009
1010                                 glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
1011                                 glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ), (float)x, (float)y + 0.125f, 0.0f, 0.0f );
1012                                 draw_mesh( 0, 2 );
1013                         }
1014                 }
1015         }
1016
1017         // Edit overlay
1018         if( world.selected != -1 && !(world.data[ world.selected ].state & FLAG_CANAL) )
1019         {
1020                 v2i new_begin = { world.tile_x - 2, world.tile_y - 2 };
1021                 v2i new_end = { world.tile_x + 2, world.tile_y + 2 };
1022
1023                 world.data[ world.selected ].state ^= FLAG_CANAL;
1024                 map_reclassify( new_begin, new_end );
1025
1026                 m2x2_identity( subtransform );
1027                 glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 1.0f );
1028                 glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
1029                 glUniform2fv( SHADER_UNIFORM( shader_tile_main, "uMousePos" ), 1, world.tile_pos );
1030
1031                 render_tiles( new_begin, new_end, colour_default, colour_default );
1032
1033                 world.data[ world.selected ].state ^= FLAG_CANAL;
1034                 map_reclassify( new_begin, new_end );
1035         }
1036
1037         //glDisable(GL_BLEND);
1038
1039         glDisable(GL_BLEND);
1040
1041         SHADER_USE( shader_tile_colour );
1042         glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
1043         use_mesh( &world.circle );
1044
1045         // Draw i/o arrays
1046         for( int i = 0; i < arrlen( world.io ); i ++ )
1047         {
1048                 struct cell_terminal *term = &world.io[ i ];
1049                 int posx = term->id % world.w;
1050                 int posy = (term->id - posx)/world.w;
1051                 int is_input = world.data[ term->id ].state & FLAG_INPUT;
1052
1053                 int const filled_start = 0;
1054                 int const filled_count = 32;
1055                 int const empty_start = 32;
1056                 int const empty_count = 32*2;
1057
1058                 v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
1059
1060                 for( int j = 0; j < arrlen( term->conditions ); j ++ )
1061                 {
1062                         glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, (float)posy + 0.2f, 0.1f );
1063
1064                         if( is_input )
1065                         {
1066                                 colour_code_v3( term->conditions[j], dot_colour );
1067                                 glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
1068
1069                                 // Draw filled if tick not passed, draw empty if empty
1070                                 if( world.sim_frame > j )
1071                                         draw_mesh( empty_start, empty_count );
1072                                 else
1073                                         draw_mesh( filled_start, filled_count );
1074                         }
1075                         else
1076                         {
1077                                 if( term->recv_count > j )
1078                                 {
1079                                         colour_code_v3( term->recv[j], dot_colour );
1080                                         v3_muls( dot_colour, 0.8f, dot_colour );
1081                                         glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
1082
1083                                         draw_mesh( filled_start, filled_count );
1084                                 }
1085
1086                                 colour_code_v3( term->conditions[j], dot_colour );
1087                                 glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
1088
1089                                 draw_mesh( empty_start, empty_count );
1090                         }
1091                 }
1092         }
1093
1094         if( world.simulating )
1095         {
1096                 glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.0f, 0.0f, 0.0f, 1.0f );
1097                 glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), -0.5f + cosf( vg_time * 4.0f ) * 0.2f, sinf( vg_time * 4.0f ) * 0.2f + (float)world.h * 0.5f, 0.05f );
1098                 draw_mesh( 0, 32 );
1099         }
1100 }
1101
1102 void vg_ui(void)
1103 {
1104         //ui_test();
1105         sfx_internal_debug_overlay();
1106 }