home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / SVGALIB / SVGALIB1.TAR / svgalib / demos / fun.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-27  |  9.6 KB  |  497 lines
  1. /* Roaming-blobs-on-mars-collect-some-dust-on-a-tropical-island-and-go-pearl-
  2.    diving-before-population-goes-out-of-control. */
  3.  
  4. /* Each frame, a background virtual screen is copied to a virtual screen; */
  5. /* sprites (well, pixels) are written on that virtual screen; and the */
  6. /* virtual screen is copied to video memory. The background is updated as */
  7. /* appropriate. This simple animation technique works well for 320x200 */
  8. /* because it's so small. */
  9.  
  10.  
  11. #include <stdlib.h>
  12. #include <stdio.h>
  13. #include <vga.h>
  14. #include <vgagl.h>
  15.  
  16.  
  17. /* This can be changed into any 256 color mode. */
  18. /* For planar 256 color modes, enable page flipping. */
  19. /* Even 16 color modes work (ugly colors). */
  20. #define VGAMODE G320x200x256
  21.  
  22. /* #define USE_PAGEFLIPPING */
  23.  
  24. /* #define USE_SMALLOC */
  25.  
  26. /* This is the size of the animated window. */
  27. #define MAPWIDTH 320
  28. #define MAPHEIGHT 190
  29.  
  30. #define MAXMOVERS 1000
  31. #define MAXCITIES 1000
  32. #define NUMBEROFCITIES 20
  33. #define NUMBEROFMOVERS 400
  34. #define MOVERTHRESHOLD 400
  35. #define MOVERLIFETIME 1000
  36. #define COLORTIME 2000
  37.  
  38. #define randomn( n ) (random() % n)
  39. #define red(x) (32 + x)
  40. #define green(x) (64 + x)
  41. #define yellow(x) (96 + x)
  42. #define blue(x) (128 + x)
  43. #define magenta(x) (160 + x)
  44. #define cyan(x) (192 + x)
  45. #define white(x) (224 + x)
  46.  
  47.  
  48. /* Data types */
  49.  
  50. typedef struct {
  51.     int x;
  52.     int y;
  53. } Position;
  54.  
  55. #define STAT_ACTIVE 1
  56.  
  57. typedef struct {
  58.     int stat;
  59.     int x;
  60.     int y;
  61.     int vx;
  62.     int vy;
  63.     int color;
  64.     int time;
  65. } Mover;
  66.  
  67. typedef struct {
  68.     int x;
  69.     int y;
  70.     int pop;
  71.     int hit;
  72. } City;
  73.  
  74. /* Global variables */
  75.  
  76. int map[MAPWIDTH][MAPHEIGHT];
  77. /* Map encoding i: */
  78. /* (0 - 0xffff    Mover number i) */
  79. /* 0x10000...    Part of city (i - 0x10000) */  
  80.  
  81. Mover mover[MAXMOVERS];
  82. int nu_movers = 0;
  83. City city[MAXCITIES];
  84. int nu_cities = 0;
  85. int time = 0;
  86. int pop = 0;
  87. int framerate, framecount, frameclock;
  88.  
  89. GraphicsContext *physicalscreen;
  90. GraphicsContext *backscreen;
  91. GraphicsContext *background;
  92.  
  93.  
  94. void error( char *s ) {
  95.     printf("%s\n", s);
  96.     vga_setmode(TEXT);
  97.     exit(0);
  98. }
  99.  
  100. void setcustompalette() {
  101.     /* colors 0-31 are a RGB mix (bits 0 and 1 red, 2 green, 3 and 4 blue) */
  102.     /* 32-63    black to red */
  103.     /* 64-95    black to green */
  104.     /* 96-127   black to yellow */
  105.     /* 128-159  black to blue */
  106.     /* 160-191  black to magenta */
  107.     /* 192-223  black to cyan */
  108.     /* 224-255  black to white */
  109.     Palette pal;
  110.     int i;
  111.     for (i = 0; i < 256; i++) {
  112.         int r, g, b;
  113.         r = g = b = 0;
  114.         if ((i & 32) > 0) r = (i & 31) << 1;
  115.         if ((i & 64) > 0) g = (i & 31) << 1;
  116.         if ((i & 128) > 0) b = (i & 31) << 1;
  117.         if (i < 32) {
  118.             r = (i & 3) << 4;   /* 2 bits */
  119.             g = (i & 4) << 3;   /* 1 bit */
  120.             b = (i & 24) << 1;  /* 2 bits */
  121.         }
  122.         pal.color[i].red = r;
  123.         pal.color[i].green = g;
  124.         pal.color[i].blue = b;
  125.     }
  126.     gl_setpalette(&pal);
  127. }
  128.  
  129. void initfont() {
  130.     void *font;
  131. #ifdef USE_SMALLOC
  132.     font = smalloc(256 * 8 * 8 * BYTESPERPIXEL);
  133. #else    
  134.     font = malloc(256 * 8 * 8 * BYTESPERPIXEL);
  135. #endif
  136.     gl_expandfont(8, 8, white(24), gl_font8x8, font);
  137.     gl_setfont(8, 8, font);
  138. }
  139.  
  140. int fsize( FILE *f ) {
  141.     int oldpos, size;
  142.     oldpos = ftell(f);
  143.     fseek(f, 0, SEEK_END);
  144.     size = ftell(f);
  145.     fseek(f, oldpos, SEEK_SET);
  146.     return size;
  147. }
  148.  
  149. void loadfile( char **buf, char *fname ) {
  150.     FILE *f;
  151.     int size;
  152.     f = fopen(fname, "rb");
  153.     size = fsize(f);
  154.     *buf = malloc(size);
  155.     fread(*buf, 1, size, f);
  156.     fclose(f);
  157. }
  158.  
  159.  
  160. /* Map */
  161.  
  162. void clearmap() {
  163.     int x, y;
  164.     for (y = 0; y < MAPHEIGHT; y++)
  165.         for (x = 0; x < MAPWIDTH; x++)
  166.             map[x][y] = 0;
  167. }
  168.  
  169. Position findfreeposition() {
  170.     int x, y;
  171.     Position p;
  172.     do {
  173.         x = randomn(MAPWIDTH);
  174.         y = randomn(MAPHEIGHT);
  175.     } while (map[x][y] != 0);
  176.     p.x = x;
  177.     p.y = y;
  178.     return p;
  179. } 
  180.  
  181.  
  182. /* Movers */
  183.  
  184. void initmovers() {
  185.     int i;
  186.     for (i = 0; i < MAXMOVERS; i++)
  187.         mover[i].stat = 0;
  188. }
  189.  
  190. int findfreemoverslot() {
  191.     int i;
  192.     for (i = 0; i < MAXMOVERS; i++)
  193.         if (!(mover[i].stat & STAT_ACTIVE))
  194.             return i;
  195.     error("Mover table overflow");
  196. }
  197.  
  198. void addrandommover() {
  199.     Position p = findfreeposition();
  200.     int i = findfreemoverslot();
  201.     int c;
  202.     mover[i].x = p.x;
  203.     mover[i].y = p.y;
  204.     do {
  205.         mover[i].vx = randomn(3) - 1;
  206.         mover[i].vy = randomn(3) - 1;
  207.     } while (mover[i].vx == 0 && mover[i].vy == 0);
  208.     mover[i].stat = STAT_ACTIVE;
  209.     switch (randomn(4)) {
  210.         case 0 :
  211.             c = blue(20); break;
  212.         case 1 :
  213.             c = green(20); break;
  214.         case 2 :
  215.             c = magenta(20); break;
  216.         case 3 :
  217.             c = cyan(20); break;
  218.     }
  219.     mover[i].time = 0;
  220.     mover[i].color = c;
  221.     nu_movers++;
  222. }
  223.  
  224. void killmover( int i ) {
  225.     mover[i].stat = 0;
  226.     nu_movers--;
  227. }
  228.  
  229. void drawmover( int i ) {
  230.     gl_setpixel(mover[i].x, mover[i].y, mover[i].color);
  231. }
  232.  
  233.  
  234. /* Cities */
  235.  
  236. void initcities() {
  237.     nu_cities = 0;
  238. }
  239.  
  240. void addcity( int x, int y ) {
  241.     int i = nu_cities++;
  242.     map[x][y] = i + 0x10000;
  243.     city[i].x = x;
  244.     city[i].y = y;
  245.     city[i].pop = 1;
  246.     city[i].hit = 0;
  247. }
  248.  
  249. int cityat( int x, int y ) {
  250.     if (map[x][y] >= 0x10000)
  251.         return map[x][y] - 0x10000;
  252.     else
  253.         return -1;
  254. }
  255.  
  256. int citycolor() {
  257. static int colortable[5] =
  258.     { yellow(31), blue(31), white(31), green(31), cyan(31) };
  259.     return colortable[(time / COLORTIME) % 5] 
  260.         - (time % COLORTIME) * 25 / COLORTIME;   
  261. }
  262.  
  263. void growcity( int cx, int cy, int x, int y, int ct ) {
  264. /* add city unit at (x, y) adjacent to city unit (cx, cy) */
  265.     int c;
  266.     map[x][y] = ct + 0x10000;
  267.     c = citycolor();
  268.     gl_setpixel(x, y, c);    
  269.     city[ct].pop++;
  270.     city[ct].hit = 20;
  271.     pop++;
  272. }
  273.  
  274.  
  275. /* Main components */
  276.  
  277. void createbackground() {
  278. /* Create fancy dark red background */
  279.     int x, y;
  280.     for (y = 0; y < MAPHEIGHT; y++)
  281.         for (x = 0; x < MAPWIDTH; x++) {
  282.             int i = 0;
  283.             int n = 0;
  284.             int c;
  285.             if (x > 0) {
  286.                 i += gl_getpixel(x - 1, y) - red(0);
  287.                 n++;
  288.             }
  289.             if (y > 0) {
  290.                 i += gl_getpixel(x, y - 1) - red(0);
  291.                 n++;
  292.             }
  293.             c = (i + randomn(16)) / (n + 1);
  294.             if (c > 9)
  295.                 c = 9;
  296.             gl_setpixel(x, y, red(0) + c);
  297.         }
  298. }
  299.  
  300. void drawbackground() {
  301. /* Build up background from map data */
  302.     int x, y;
  303.     gl_setcontext(background);
  304.     gl_clearscreen(0);
  305.     createbackground();
  306.     for (y = 0; y < MAPHEIGHT; y++)
  307.         for (x = 0; x < MAPWIDTH; x++) {
  308.             int c = cityat(x, y);
  309.             if (c != -1)
  310.                 gl_setpixel(x, y, citycolor());
  311.         }
  312. }
  313.  
  314. void createcities() {
  315.     int i;
  316.     for (i = 0; i < NUMBEROFCITIES; i++) {
  317.         Position p = findfreeposition();
  318.         addcity(p.x, p.y);
  319.     }
  320. }
  321.  
  322. void writestat() {
  323.     char s[41];
  324.     int i, x, y;
  325.     int maxpopcity, maxpop;
  326.     sprintf(s, "Pop %7d  Time %7d  Rate %5d.%d", pop, time,
  327.         framerate / 10, framerate % 10);
  328.     gl_setwritemode(WRITEMODE_OVERWRITE);
  329.     gl_write(0, HEIGHT - 8, s);
  330.     maxpop = -1;
  331.     for (i = 0; i < nu_cities; i++)
  332.         if (city[i].pop > maxpop) {
  333.             maxpop = city[i].pop;
  334.             maxpopcity = i;
  335.         }
  336.  
  337.     gl_enableclipping();
  338.     gl_circle(city[maxpopcity].x, city[maxpopcity].y, 10,
  339.         blue(31));
  340.     gl_disableclipping();
  341.  
  342.     gl_setwritemode(WRITEMODE_MASKED);
  343.     x = city[maxpopcity].x;
  344.     y = city[maxpopcity].y;
  345.     sprintf(s, "%d", maxpop);
  346.     /* clipping */
  347.     if (x + strlen(s) * 8 > MAPWIDTH)
  348.         x = MAPWIDTH - strlen(s) * 8;
  349.     if (y + 8 > MAPHEIGHT)
  350.         y = MAPHEIGHT - 8;
  351.     gl_write(x, y, s);
  352. }
  353.  
  354. void drawscreen() {
  355.     int i;
  356.     /* Copy background to backscreen. */
  357.     gl_setcontext(background);
  358.     gl_copyscreen(backscreen);
  359.     
  360.     /* Now draw the objects in backscreen. */
  361.     gl_setcontext(backscreen);
  362.  
  363.     for (i = 0; i < MAXMOVERS; i++)
  364.         if (mover[i].stat & STAT_ACTIVE) {
  365.             drawmover(i);
  366.         }
  367.  
  368.     writestat();
  369.  
  370.     /* Copy backscreen to physical screen. */     
  371.     gl_copyscreen(physicalscreen);
  372. }
  373.  
  374. void move() {
  375.     int i;
  376.     gl_setcontext(background);
  377.     for (i = 0; i < MAXMOVERS; i++)
  378.         if (mover[i].stat & STAT_ACTIVE) {
  379.             int nx, ny;
  380.             int c;
  381.             if (++mover[i].time == MOVERLIFETIME) {
  382.                 killmover(i);
  383.                 continue;
  384.             }
  385.             for (;;) {
  386.                 nx = mover[i].x + mover[i].vx;
  387.                 ny = mover[i].y + mover[i].vy;
  388.                 if (nx < 0 || nx >= MAPWIDTH) {
  389.                     mover[i].vx = -mover[i].vx;
  390.                     continue;
  391.                 }
  392.                 if (ny < 0 || ny >= MAPHEIGHT) {
  393.                     mover[i].vy = -mover[i].vy;
  394.                     continue;
  395.                 }
  396.                 break;
  397.             }
  398.             c = cityat(nx, ny);
  399.             if (c != -1) {        /* found city */
  400.                 killmover(i);
  401.                 growcity(nx, ny, mover[i].x, mover[i].y, c);
  402.                 continue;    /* next mover */    
  403.             }
  404.             mover[i].x = nx;
  405.             mover[i].y = ny;
  406.         }
  407.     if (pop >= MAPWIDTH * MAPHEIGHT * 255 / 256) {
  408.         /* start all over again */
  409.         printf("fun: new run.\n");
  410.         pop = 0;
  411.         time = 0;
  412.         clearmap();
  413.         initcities();
  414.         createcities();
  415.         drawbackground();
  416.     }
  417. }
  418.  
  419. void createmovers() {
  420.     int i;
  421.     for (i = 0; i < NUMBEROFMOVERS; i++)
  422.         addrandommover();
  423. }
  424.  
  425. void main() {
  426.     vga_init();
  427.  
  428.     clearmap();
  429.     initmovers();
  430.     createcities();
  431.     createmovers();
  432.  
  433.     vga_setmode(VGAMODE);
  434.     gl_setcontextvga(VGAMODE);
  435.     physicalscreen = gl_allocatecontext();
  436.     gl_getcontext(physicalscreen);
  437.  
  438. #ifdef USE_PAGEFLIPPING    
  439.     /* Try to enable page flipping. */
  440.     gl_enablepageflipping(&physicalscreen);
  441. #endif
  442.     setcustompalette();
  443.     /* initfont() here caused trouble with planar 256 color modes. */
  444.  
  445.     gl_setcontextvgavirtual(VGAMODE);
  446.     backscreen = gl_allocatecontext();
  447.     gl_getcontext(backscreen);
  448. #ifdef USE_SMALLOC
  449.     free(backscreen.vbuf);
  450.     backscreen.vbuf = smalloc(BYTEWIDTH * HEIGHT);
  451.     gl_setcontext(backscreen);
  452. #endif
  453.  
  454.     initfont();
  455.  
  456.     gl_setcontextvgavirtual(VGAMODE);
  457.     background = gl_allocatecontext();
  458.     gl_getcontext(background);
  459. #ifdef USE_SMALLOC    
  460.     free(background.vbuf);
  461.     background.vbuf = smalloc(BYTEWIDTH * HEIGHT);
  462.     gl_setcontext(background);
  463. #endif
  464.  
  465.     drawbackground();
  466.  
  467.     framerate = 0;
  468.     framecount = 0;
  469.     frameclock = clock();
  470.  
  471.     for (;;) {
  472.         int i;
  473.         drawscreen();
  474.         move();
  475.         for (i = 0; i < 4; i++)
  476.             if (nu_movers < MOVERTHRESHOLD)
  477.                 addrandommover();
  478.         time++;
  479.         /* Update frame rate every 3 seconds. */
  480.         framecount++;
  481.         if (clock() - frameclock >= 300) {
  482.             framerate = framecount * 1000 / (clock() - frameclock);
  483.             framecount = 0;
  484.             frameclock = clock();
  485.         }
  486.  
  487.     }
  488.  
  489. #ifndef USE_SMALLOC
  490.     freecontext(backscreen);
  491.     freecontext(background);
  492. #endif    
  493.  
  494.     vga_setmode(TEXT);    
  495.     exit(0);
  496. }
  497.