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
 601         // Simulation stop/start
 602         if( vg_get_button_down("go") )
 603         {
 604                 if( world.simulating )
 605                 {
 606                         world.simulating = 0;
 607                         world.num_fishes = 0;
 608                         world.sim_frame = 0;
 609
 610                         for( int i = 0; i < arrlen( world.io ); i ++ )
 611                                 world.io[i].recv_count = 0;
 612
 613                         vg_info( "Stopping simulation!\n" );
 614
 615                         sfx_system_fadeout( &audio_system_balls_rolling, 44100 );
 616                 }
 617                 else
 618                 {
 619                         vg_success( "Starting simulation!\n" );
 620
 621                         sfx_set_playrnd( &audio_rolls, &audio_system_balls_rolling, 0, 1 );
 622
 623                         world.simulating = 1;
 624                         world.num_fishes = 0;
 625                         world.sim_frame = 0;
 626                         world.sim_start = vg_time;
 627
 628                         for( int i = 0; i < world.w*world.h; i ++ )
 629                         {
 630                                 world.data[ i ].state &= ~FLAG_FLIP_FLOP;
 631                         }
 632
 633                         for( int i = 0; i < arrlen( world.io ); i ++ )
 634                                 world.io[i].recv_count = 0;
 635                 }
 636         }
 637
 638         // Fish ticks
 639         if( world.simulating )
 640         {
 641                 while( world.sim_frame < (int)((vg_time-world.sim_start)*2.0f) )
 642                 {
 643                         vg_info( "frame: %u\n", world.sim_frame );
 644
 645                         for( int i = 0; i < arrlen( world.io ); i ++ )
 646                         {
 647                                 struct cell_terminal *term = &world.io[ i ];
 648                                 int posx = term->id % world.w;
 649                                 int posy = (term->id - posx)/world.w;
 650                                 int is_input = world.data[ term->id ].state & FLAG_INPUT;
 651
 652                                 if( is_input )
 653                                 {
 654                                         if( world.sim_frame < arrlen( term->conditions ) )
 655                                         {
 656                                                 struct fish *fish = &world.fishes[world.num_fishes++];
 657                                                 fish->pos[0] = posx;
 658                                                 fish->pos[1] = posy;
 659                                                 fish->alive = 1;
 660                                                 fish->payload = term->conditions[world.sim_frame];
 661
 662                                                 int can_spawn = 0;
 663
 664                                                 v2i dirs[] = {{1,0},{-1,0},{0,-1}};
 665                                                 for( int j = 0; j < vg_list_size(dirs); j ++ )
 666                                                         if( pcell( (v2i){ posx+dirs[j][0], posy+dirs[j][1] } )->state & FLAG_CANAL )
 667                                                         {
 668                                                                 fish->dir[0] = dirs[j][0];
 669                                                                 fish->dir[1] = dirs[j][1];
 670                                                                 can_spawn = 1;
 671                                                                 break;
 672                                                         }
 673
 674                                                 if( !can_spawn )
 675                                                         world.num_fishes--;
 676                                         }
 677                                 }
 678                         }
 679
 680                         // Update splitter deltas
 681                         for( int i = 0; i < world.h*world.w; i ++ )
 682                         {
 683                                 struct cell *cell = &world.data[i];
 684                                 if( cell->config == k_cell_type_split )
 685                                 {
 686                                         cell->state &= ~FLAG_FLIP_ROTATING;
 687                                 }
 688                         }
 689
 690                         for( int i = 0; i < world.num_fishes; i ++ )
 691                         {
 692                                 struct fish *fish = &world.fishes[i];
 693                                 struct cell *cell_current = pcell( fish->pos );
 694
 695                                 if( !fish->alive )
 696                                         continue;
 697
 698                                 // Apply to output
 699                                 if( cell_current->state & FLAG_OUTPUT )
 700                                 {
 701                                         for( int j = 0; j < arrlen( world.io ); j ++ )
 702                                         {
 703                                                 struct cell_terminal *term = &world.io[j];
 704
 705                                                 if( term->id == fish->pos[1]*world.w + fish->pos[0] )
 706                                                 {
 707                                                         term->recv[ term->recv_count ++ ] = fish->payload;
 708                                                         break;
 709                                                 }
 710                                         }
 711
 712                                         fish->alive = 0;
 713                                         continue;
 714                                 }
 715
 716                                 if( cell_current->config == k_cell_type_split )
 717                                 {
 718                                         // Flip flop L/R
 719                                         fish->dir[0] = cell_current->state&FLAG_FLIP_FLOP?1:-1;
 720                                         fish->dir[1] = 0;
 721
 722                                         cell_current->state ^= FLAG_FLIP_FLOP;
 723                                 }
 724                                 else if( cell_current->config == k_cell_type_merge )
 725                                 {
 726                                         // Can only move up
 727                                         fish->dir[0] = 0;
 728                                         fish->dir[1] = -1;
 729                                 }
 730                                 else
 731                                 {
 732                                         struct cell *cell_next = pcell( (v2i){ fish->pos[0]+fish->dir[0], fish->pos[1]+fish->dir[1] } );
 733                                         if( !(cell_next->state & (FLAG_CANAL|FLAG_OUTPUT)) )
 734                                         {
 735                                                 // Try other directions for valid, so down, left, right..
 736                                                 v2i dirs[] = {{1,0},{-1,0},{0,-1}};
 737                                                 vg_info( "Trying some other directions...\n" );
 738
 739                                                 for( int j = 0; j < vg_list_size(dirs); j ++ )
 740                                                 {
 741                                                         if( (dirs[j][0] == -fish->dir[0]) && (dirs[j][1] == -fish->dir[1]) )
 742                                                                 continue;
 743
 744                                                         if( pcell( (v2i){ fish->pos[0]+dirs[j][0], fish->pos[1]+dirs[j][1] } )->state & (FLAG_CANAL|FLAG_OUTPUT) )
 745                                                         {
 746                                                                 fish->dir[0] = dirs[j][0];
 747                                                                 fish->dir[1] = dirs[j][1];
 748                                                         }
 749                                                 }
 750                                         }
 751                                 }
 752
 753                                 fish->pos[0] += fish->dir[0];
 754                                 fish->pos[1] += fish->dir[1];
 755
 756                                 struct cell *cell_entry = pcell( fish->pos );
 757
 758                                 if( !(cell_entry->state & (FLAG_INPUT|FLAG_CANAL|FLAG_OUTPUT) ))
 759                                         fish->alive = 0;
 760                                 else
 761                                         if( cell_entry->config == k_cell_type_split )
 762                                         {
 763                                                 sfx_set_playrnd( &audio_splitter, &audio_system_balls_important, 0, 1 );
 764                                                 cell_entry->state |= FLAG_FLIP_ROTATING;
 765                                         }
 766                         }
 767
 768                         world.sim_frame ++;
 769                 }
 770         }
 771 }
 772
 773 static void render_tiles( v2i start, v2i end, v4f const regular_colour, v4f const selected_colour )
 774 {
 775         v2i full_start = { 0,0 };
 776         v2i full_end = { world.w, world.h };
 777
 778         if( !start || !end )
 779         {
 780                 start = full_start;
 781                 end = full_end;
 782         }
 783
 784         glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
 785
 786         for( int y = start[1]; y < end[1]; y ++ )
 787         {
 788                 for( int x = start[0]; x < end[0]; x ++ )
 789                 {
 790                         struct cell *cell = pcell((v2i){x,y});
 791                         int selected = world.selected == y*world.w + x;
 792
 793                         int tile_offsets[][2] =
 794                         {
 795                                 {2, 0}, {0, 3}, {0, 2}, {2, 2},
 796                                 {1, 0}, {2, 3}, {3, 2}, {1, 3},
 797                                 {3, 1}, {0, 1}, {1, 2}, {2, 1},
 798                                 {1, 1}, {3, 3}, {2, 1}, {2, 1}
 799                         };
 800
 801                         int uv[2] = { 3, 0 };
 802
 803                         if( cell->state & FLAG_CANAL )
 804                         {
 805                                 uv[0] = tile_offsets[ cell->config ][0];
 806                                 uv[1] = tile_offsets[ cell->config ][1];
 807                         }
 808
 809                         glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ), (float)x, (float)y, uv[0], uv[1] );
 810                         if( selected )
 811                         {
 812                                 glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, selected_colour );
 813                                 draw_mesh( 0, 2 );
 814                                 glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
 815                         }
 816                         else
 817                                 draw_mesh( 0, 2 );
 818                 }
 819         }
 820 }
 821
 822 void vg_render(void)
 823 {
 824         glViewport( 0,0, vg_window_x, vg_window_y );
 825
 826         glDisable( GL_DEPTH_TEST );
 827         glClearColor( 0.8f, 0.8f, 0.8f, 1.0f );
 828         glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 829
 830         float scaled_time = 0.0f, frame_lerp = 0.0f;
 831
 832         if( world.simulating )
 833         {
 834                 scaled_time = (vg_time-world.sim_start)*2.0f;
 835                 frame_lerp = scaled_time - (float)world.sim_frame;
 836         }
 837
 838         v4f const colour_default = {1.0f, 1.0f, 1.0f, 1.0f};
 839         v4f const colour_selected = {0.90f, 0.92f, 1.0f, 1.0f};
 840
 841         v2f const curve_3[] = {{0.5f,1.0f},{0.5f,0.625f},{0.625f,0.5f},{1.0f,0.5f}};
 842         v2f const curve_6[] = {{0.5f,1.0f},{0.5f,0.625f},{0.375f,0.5f},{0.0f,0.5f}};
 843         v2f const curve_9[] = {{1.0f,0.5f},{0.625f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
 844         v2f const curve_12[]= {{0.0f,0.5f},{0.375f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
 845
 846         v2f const curve_7[] = {{0.5f,0.8438f},{0.875f,0.8438f},{0.625f,0.5f},{1.0f,0.5f}};
 847         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}};
 848
 849         float const curve_7_linear_section = 0.1562f;
 850
 851         // TILE SET RENDERING
 852         //      todo: just slam everything into a mesh...
 853         //          when user modifies a tile the neighbours can be easily uploaded to gpu mem
 854         //          in ~3 subBuffers
 855         //          Currently we're uploading a fair amount of data every frame anyway.
 856         //          NOTE: this is for final optimisations ONLY!
 857         // ======================================================================
 858
 859         use_mesh( &world.tile );
 860
 861         SHADER_USE( shader_tile_main );
 862
 863         m2x2f subtransform;
 864         m2x2_identity( subtransform );
 865         glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
 866         glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_main, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
 867         glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 0.0f );
 868
 869         // Bind textures
 870         vg_tex2d_bind( &tex_tile_data, 0 );
 871         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexGlyphs" ), 0 );
 872
 873         vg_tex2d_bind( &tex_wood, 1 );
 874         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexWood" ), 1 );
 875
 876         render_tiles( NULL, NULL, colour_default, colour_default );
 877
 878         glEnable(GL_BLEND);
 879         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 880         glBlendEquation(GL_FUNC_ADD);
 881
 882         SHADER_USE( shader_ball );
 883         glUniformMatrix3fv( SHADER_UNIFORM( shader_ball, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
 884
 885         vg_tex2d_bind( &tex_ball, 0 );
 886         glUniform1i( SHADER_UNIFORM( shader_ball, "uTexMain" ), 0 );
 887
 888         // Draw 'fish'
 889         if( world.simulating )
 890         {
 891                 for( int i = 0; i < world.num_fishes; i ++ )
 892                 {
 893                         struct fish *fish = &world.fishes[i];
 894
 895                         if( !fish->alive )
 896                                 continue;
 897
 898                         // Evaluate position
 899                         struct cell *cell = pcell(fish->pos);
 900                         v2f fish_pos;
 901
 902                         v2f const *curve;
 903
 904                         float t = frame_lerp;
 905
 906                         switch( cell->config )
 907                         {
 908                                 case 13:
 909                                         if( fish->dir[0] == 1 )
 910                                                 curve = curve_12;
 911                                         else
 912                                                 curve = curve_9;
 913                                 break;
 914                                 case 3: curve = curve_3; break;
 915                                 case 6: curve = curve_6; break;
 916                                 case 9: curve = curve_9; break;
 917                                 case 12: curve = curve_12; break;
 918                                 case 7:
 919                                         if( t > curve_7_linear_section )
 920                                         {
 921                                                 t -= curve_7_linear_section;
 922                                                 t *= (1.0f/(1.0f-curve_7_linear_section));
 923
 924                                                 curve = cell->state & FLAG_FLIP_FLOP? curve_7: curve_7_1;
 925                                         }
 926                                         else curve = NULL;
 927                                 break;
 928                                 default: curve = NULL; break;
 929                         }
 930
 931                         if( curve )
 932                         {
 933                                 float t2 = t * t;
 934                                 float t3 = t * t * t;
 935
 936                                 float cA = 3.0f*t2 - 3.0f*t3;
 937                                 float cB = 3.0f*t3 - 6.0f*t2 + 3.0f*t;
 938                                 float cC = 3.0f*t2 - t3 - 3.0f*t + 1.0f;
 939
 940                                 fish_pos[0] = t3*curve[3][0] + cA*curve[2][0] + cB*curve[1][0] + cC*curve[0][0];
 941                                 fish_pos[1] = t3*curve[3][1] + cA*curve[2][1] + cB*curve[1][1] + cC*curve[0][1];
 942                                 fish_pos[0] += (float)fish->pos[0];
 943                                 fish_pos[1] += (float)fish->pos[1];
 944                         }
 945                         else
 946                         {
 947                                 v2f origin;
 948                                 origin[0] = (float)fish->pos[0] + (float)fish->dir[0]*-0.5f + 0.5f;
 949                                 origin[1] = (float)fish->pos[1] + (float)fish->dir[1]*-0.5f + 0.5f;
 950
 951                                 fish_pos[0] = origin[0] + (float)fish->dir[0]*t;
 952                                 fish_pos[1] = origin[1] + (float)fish->dir[1]*t;
 953                         }
 954
 955                         v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
 956                         colour_code_v3( fish->payload, dot_colour );
 957
 958                         glUniform3fv( SHADER_UNIFORM( shader_ball, "uColour" ), 1, dot_colour );
 959                         glUniform2f( SHADER_UNIFORM( shader_ball, "uOffset" ), fish_pos[0], fish_pos[1] );
 960                         draw_mesh( 0, 32 );
 961                 }
 962         }
 963
 964
 965         SHADER_USE( shader_tile_main );
 966
 967         // Bind textures
 968         vg_tex2d_bind( &tex_tile_data, 0 );
 969         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexGlyphs" ), 0 );
 970
 971         vg_tex2d_bind( &tex_wood, 1 );
 972         glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexWood" ), 1 );
 973
 974         render_tiles( NULL, NULL, colour_default, colour_selected  );
 975
 976         //      Draw splitters
 977
 978         for( int y = 0; y < world.h; y ++ )
 979         {
 980                 for( int x = 0; x < world.w; x ++ )
 981                 {
 982                         struct cell *cell = pcell((v2i){x,y});
 983
 984                         if( cell->config == k_cell_type_split )
 985                         {
 986                                 float rotation = cell->state & FLAG_FLIP_FLOP? vg_rad( -45.0f ): vg_rad( 45.0f );
 987
 988                                 if( cell->state & FLAG_FLIP_ROTATING )
 989                                 {
 990                                         if( (frame_lerp > curve_7_linear_section) )
 991                                         {
 992                                                 float const rotation_speed = 0.4f;
 993                                                 if( (frame_lerp < 1.0f-rotation_speed) )
 994                                                 {
 995                                                         float t = frame_lerp - curve_7_linear_section;
 996                                                         t *= -2.0f * (1.0f/(1.0f-(curve_7_linear_section+rotation_speed)));
 997                                                         t += 1.0f;
 998
 999                                                         rotation *= t;
1000                                                 }
1001                                                 else
1002                                                         rotation *= -1.0f;
1003                                         }
1004                                 }
1005
1006                                 m2x2_create_rotation( subtransform, rotation );
1007
1008                                 glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
1009                                 glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ), (float)x, (float)y + 0.125f, 0.0f, 0.0f );
1010                                 draw_mesh( 0, 2 );
1011                         }
1012                 }
1013         }
1014
1015         // Edit overlay
1016         if( world.selected != -1 && !(world.data[ world.selected ].state & FLAG_CANAL) )
1017         {
1018                 v2i new_begin = { world.tile_x - 2, world.tile_y - 2 };
1019                 v2i new_end = { world.tile_x + 2, world.tile_y + 2 };
1020
1021                 world.data[ world.selected ].state ^= FLAG_CANAL;
1022                 map_reclassify( new_begin, new_end );
1023
1024                 m2x2_identity( subtransform );
1025                 glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 1.0f );
1026                 glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
1027                 glUniform2fv( SHADER_UNIFORM( shader_tile_main, "uMousePos" ), 1, world.tile_pos );
1028
1029                 render_tiles( new_begin, new_end, colour_default, colour_default );
1030
1031                 world.data[ world.selected ].state ^= FLAG_CANAL;
1032                 map_reclassify( new_begin, new_end );
1033         }
1034
1035         //glDisable(GL_BLEND);
1036
1037         glDisable(GL_BLEND);
1038
1039         SHADER_USE( shader_tile_colour );
1040         glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
1041         use_mesh( &world.circle );
1042
1043         // Draw i/o arrays
1044         for( int i = 0; i < arrlen( world.io ); i ++ )
1045         {
1046                 struct cell_terminal *term = &world.io[ i ];
1047                 int posx = term->id % world.w;
1048                 int posy = (term->id - posx)/world.w;
1049                 int is_input = world.data[ term->id ].state & FLAG_INPUT;
1050
1051                 int const filled_start = 0;
1052                 int const filled_count = 32;
1053                 int const empty_start = 32;
1054                 int const empty_count = 32*2;
1055
1056                 v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
1057
1058                 for( int j = 0; j < arrlen( term->conditions ); j ++ )
1059                 {
1060                         glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, (float)posy + 0.2f, 0.1f );
1061
1062                         if( is_input )
1063                         {
1064                                 colour_code_v3( term->conditions[j], dot_colour );
1065                                 glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
1066
1067                                 // Draw filled if tick not passed, draw empty if empty
1068                                 if( world.sim_frame > j )
1069                                         draw_mesh( empty_start, empty_count );
1070                                 else
1071                                         draw_mesh( filled_start, filled_count );
1072                         }
1073                         else
1074                         {
1075                                 if( term->recv_count > j )
1076                                 {
1077                                         colour_code_v3( term->recv[j], dot_colour );
1078                                         v3_muls( dot_colour, 0.8f, dot_colour );
1079                                         glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
1080
1081                                         draw_mesh( filled_start, filled_count );
1082                                 }
1083
1084                                 colour_code_v3( term->conditions[j], dot_colour );
1085                                 glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
1086
1087                                 draw_mesh( empty_start, empty_count );
1088                         }
1089                 }
1090         }
1091
1092         if( world.simulating )
1093         {
1094                 glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.0f, 0.0f, 0.0f, 1.0f );
1095                 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 );
1096                 draw_mesh( 0, 32 );
1097         }
1098 }
1099
1100 void vg_ui(void)
1101 {
1102         //ui_test();
1103 }