Guest User

snakes.cpp

a guest
May 9th, 2013
128
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <sdl/SDL.h>
  2. #include "video.h"
  3. #include <math.h>
  4.  
  5. //
  6. #define sint64   signed long long
  7. #define uint32 unsigned int
  8. #define sint32   signed int
  9. #define uint16 unsigned short
  10. #define sint16   signed short
  11. #define uint8  unsigned char
  12. #define sint8    signed char
  13.  
  14. //
  15. const int c_ScreenWidth  = 640;
  16. const int c_ScreenHeight = 480;
  17.  
  18. //
  19. SDL_Surface *screen = NULL;
  20.  
  21. //
  22. static inline void plot( int x, int y, int c )
  23. {
  24.     if ( x <  0              ) return;
  25.     if ( y <  0              ) return;
  26.     if ( x >= c_ScreenWidth  ) return;
  27.     if ( y >= c_ScreenHeight ) return;
  28.     Uint32 *p  = (Uint32*)screen->pixels;
  29.             p += x + y * (screen->pitch >> 2);
  30.            *p  = c;
  31. }
  32.  
  33. //
  34. bool start_sdl( void )
  35. {
  36.     //
  37.     if ( SDL_Init( SDL_INIT_VIDEO ) != 0 )
  38.         return false;
  39.     //
  40.     screen = SDL_SetVideoMode
  41.     (
  42.         c_ScreenWidth,
  43.         c_ScreenHeight, 32, 0//SDL_FULLSCREEN
  44.     );
  45.     return ( screen != NULL );
  46. }
  47.  
  48. //
  49. const float pi = 3.14159265359f;
  50.  
  51. //
  52. const int nodeCount = 27;
  53.  
  54. //
  55. struct sTentacle
  56. {
  57.     float head;
  58.     float girth;
  59.     float friction;
  60.     float muscleRange;
  61.     float muscleFrequency;
  62.     float tv;
  63.     float theta;
  64.     float count;
  65.     float thetaMuscle;
  66.     //
  67.     float px;
  68.     float py;
  69.     //
  70.     float x[ nodeCount ];
  71.     float y[ nodeCount ];
  72. };
  73.  
  74. //
  75. float random( float range = 1.0f )
  76. {
  77.     float i  = (float)( rand( ) & 0xFFFF );
  78.           i /= (float)   0xFFFF;
  79.           i *= range;
  80.     return i;
  81. }
  82.  
  83. //
  84. const int snakeCount = 7;
  85. sTentacle snake[snakeCount];
  86.  
  87. //
  88. void generate( sTentacle *t )
  89. {
  90.     t->count           = 0;
  91.     t->theta           = 0;
  92.     t->tv              = 0;
  93.     t->thetaMuscle     = 0;
  94.     t->head            =  2.0f + random( 4   );
  95.     t->girth           =  8.0f + random( 12  );
  96.     t->friction        =  0.9f + random( 10  ) / 100.0f;
  97.     t->muscleRange     = 20.0f + random( 50  );
  98.     t->muscleFrequency =  0.1f + random( 100 ) / 250.0f;
  99.     //
  100.     for ( int i=0; i<nodeCount; i++ )
  101.     {
  102.         t->x[i] = 0;
  103.         t->y[i] = 0;
  104.     }
  105.     //
  106.     t->px = -64;
  107.     t->py = c_ScreenHeight/2 + random( 100 );
  108. }
  109.  
  110. //
  111. void update( sTentacle *t )
  112. {
  113.     //
  114.     t->tv    += 0.5f * (random() - random( ));
  115.     t->theta += t->tv;
  116.     t->tv    *= t->friction;
  117.     t->x[0]   = t->head * cos( pi / 180 * t->theta );
  118.     t->y[0]   = t->head * sin( pi / 180 * t->theta );
  119.  
  120.     //
  121.     t->count       += t->muscleFrequency;
  122.     t->thetaMuscle  = t->muscleRange * sin( t->count );
  123.    
  124.     //
  125.     t->x[1] = -t->head * cos( pi / 180 * ( t->theta + t->thetaMuscle ) );
  126.     t->y[1] = -t->head * sin( pi / 180 * ( t->theta + t->thetaMuscle ) );
  127.  
  128.     //
  129.     for ( int i=2; i<nodeCount; i++ )
  130.     {
  131.         float dx = t->x[i] - t->x[i-2];
  132.         float dy = t->y[i] - t->y[i-2];
  133.  
  134.         //
  135.         float  d = sqrtf( dx*dx + dy*dy );
  136.  
  137.         //
  138.         t->x[i] = t->x[i-1] + (dx * t->girth) / d;
  139.         t->y[i] = t->y[i-1] + (dy * t->girth) / d;
  140.  
  141.         //
  142.         setColour( 0xFFFFFF );
  143.         drawLine
  144.         (
  145.             t->px + (int)t->x[i  ],
  146.             t->py + (int)t->y[i  ],
  147.             t->px + (int)t->x[i-1],
  148.             t->py + (int)t->y[i-1]
  149.         );
  150.     }
  151.  
  152.     drawCircle( t->px + t->x[0], t->py + t->y[0], 6 );
  153.  
  154.     t->px -= t->x[1];
  155.     t->py -= t->y[1];
  156.  
  157.     //
  158.     if ( t->px > c_ScreenWidth + 200 ) generate( t );
  159.  
  160. }
  161.  
  162. //
  163. bool tick_sdl( void )
  164. {
  165.     SDL_Event event;
  166.     while ( SDL_PollEvent( &event ) )
  167.     {
  168.         switch ( event.type )
  169.         {
  170.         case ( SDL_QUIT ):
  171.             return false;
  172.         case ( SDL_KEYDOWN ):
  173.             if ( event.key.keysym.sym == SDLK_ESCAPE )
  174.                 return false;
  175.             if ( event.key.keysym.sym == SDLK_r )
  176.             {
  177.                 //
  178.                 for ( int i=0; i<snakeCount; i++ )
  179.                     generate( &(snake[i]) );
  180.             }
  181.             break;
  182.         }
  183.     }
  184.     return true;
  185. }
  186.  
  187. //
  188. int main( void )
  189. {
  190.     //
  191.     if (! start_sdl  ( ) )  return -1;
  192.  
  193.     //
  194.     for ( int i=0; i<snakeCount; i++ )
  195.         generate( &(snake[i]) );
  196.  
  197.     //
  198.     int time = SDL_GetTicks( );
  199.  
  200.     //
  201.     while ( tick_sdl( ) )
  202.     {
  203.         //
  204.         SDL_FillRect( screen, NULL, 0x000020 );
  205.  
  206.        
  207.         //
  208.         for ( int i=0; i<snakeCount; i++ )
  209.             update( &(snake[i]) );
  210.  
  211.         //
  212.         while ( true )
  213.         {
  214.             int dt = SDL_GetTicks( ) - time;
  215.             if ( dt > 33 )
  216.             {
  217.                 time += dt;
  218.                 break;
  219.             }
  220.             else
  221.             {
  222.                 SDL_Delay( 1 );
  223.             }
  224.         }
  225.  
  226.  
  227.         //
  228.         SDL_Flip( screen );
  229.     }
  230.     //
  231.     return 0;
  232. }
RAW Paste Data