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