home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / grafik / sprites / demosrc / sprdemo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-25  |  14.4 KB  |  446 lines
  1. /**********************************************************************
  2. * sprdemo.c
  3. * 
  4. * A Sprite Toolkit demonstration program
  5. * 
  6. **********************************************************************
  7.                     This file is part of
  8.  
  9.           STK -- The sprite toolkit -- version 1.1
  10.  
  11.               Copyright (C) Jari Karjala 1991
  12.  
  13. The sprite toolkit (STK) is a FreeWare toolkit for creating high
  14. resolution sprite graphics with PCompatible hardware. This toolkit 
  15. is provided as is without any warranty or such thing. See the file
  16. COPYING for further information.
  17.  
  18. **********************************************************************
  19. **********************************************************************/
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <alloc.h>
  24. #include <graphics.h>
  25. #include <time.h> 
  26.  
  27. #include "stk.h"            /*** The Sprite Toolkit prototypes ***/
  28.  
  29. #include "smp\anykeya.smp"
  30. #include "smp\anykeyb.smp"
  31. #include "smp\demo.smp"
  32. #include "smp\car.smp"
  33. #include "smp\one1.smp"
  34. #include "smp\one2.smp"
  35. #include "smp\one3.smp"
  36. #include "smp\one4.smp"
  37. #include "smp\two1.smp"
  38. #include "smp\two2.smp"
  39. #include "smp\two3.smp"
  40. #include "smp\two4.smp"
  41.  
  42. ANIM_SPRITE pacer;
  43.  
  44. void error(char *s)
  45. {
  46.     closegraph();
  47.     puts(s);
  48.     exit(255);    
  49. }
  50.  
  51. /**********************************************************************
  52. * Clear three bottom lines of the screen, run pacer amd wait for a key
  53. **********************************************************************/
  54. void wait_key(void)
  55. {
  56.     setfillstyle(EMPTY_FILL,0);
  57.     gr_setactivepage(0);
  58.     bar(0,spr_max_y-30,spr_max_x,spr_max_y);
  59.     gr_setactivepage(1);
  60.     bar(0,spr_max_y-30,spr_max_x,spr_max_y);
  61.     
  62.     spr_anim_start(pacer);
  63.     while (gr_inkey()) {    /** discard previous keys **/
  64.         gr_setactivepage(spr_anim_next_pass());
  65.         spr_regulate_speed();
  66.     }
  67.     while (!gr_inkey()) {   /** wait for a key press **/
  68.         gr_setactivepage(spr_anim_next_pass());
  69.         spr_regulate_speed();
  70.     }
  71.     spr_anim_stop(pacer);
  72.     gr_setactivepage(spr_anim_next_pass());
  73.     
  74.     /** now all sprites have disappeared from both display pages **/
  75.     /** and we can clear the display **/
  76.     gr_setactivepage(0);
  77.     cleardevice();
  78.     gr_setactivepage(1);
  79.     cleardevice();
  80.         
  81. }
  82.  
  83. /**********************************************************************
  84. * Initialize an animated sprite which wanders around the screen when 
  85. * we wait for a keypress.
  86. **********************************************************************/
  87. ANIM_SPRITE init_pacer(void)
  88. {
  89.     ANIM_SPRITE as;
  90.     
  91.     as = spr_anim_create(2, 
  92.                          spr_create(anykeya_width, anykeya_height,
  93.                                     anykeya_shape, anykeya_mask, 8, 1),
  94.                          spr_create(anykeyb_width, anykeyb_height,
  95.                                     anykeyb_shape, anykeyb_mask, 8, 1));
  96.     if (as==NULL)
  97.         return NULL;
  98.  
  99.     spr_anim_set_vector(as, -2, 1);
  100.     spr_anim_set_location(as, (spr_max_x-anykeya_width)/2, spr_max_y-50);
  101.     spr_anim_set_time(as, 0, 10, 0);
  102.     spr_anim_set_limits(as, 0, gr_max_y-60, gr_max_x, gr_max_y);
  103.     return as;
  104. }
  105.  
  106.  
  107. char *first_page_msg[] = {
  108.     "The Sprite Toolkit (STK) - Copyright Jari Karjala 1991",
  109.     "",
  110.     "",
  111.     "The STK functions provide support for sprites which do not",
  112.     "destroy background and whose size can be up to 512x256 pixels.",
  113.     "",
  114.     "Two interfaces are supported: The simple interface which provides",
  115.     "non-animated sprites which can be put on screen and erased.",
  116.     "The other interface supports automatically moving and animated",
  117.     "sprites. Both interfaces support collision detection at pixel",
  118.     "resolution. There is also a possibility to regulate the animation",
  119.     "speed to about 18 frames per second.",
  120.     "",
  121.     "Additional functions provide support for text IO in graphics",
  122.     "mode and direct keyboard reading (multiple simultanous keys).",
  123.     "",
  124.     "Currently only monochrome EGA and Hercules graphics supported.",
  125.     NULL
  126. };
  127.  
  128. /**********************************************************************
  129. * The intro page.
  130. **********************************************************************/
  131. void first_page(void)
  132. {
  133.     int i;
  134.     
  135.     for (i=0; first_page_msg[i]!=NULL && !gr_inkey(); i++)
  136.         gr_dual_xy_printf((spr_max_x-640)/2+48, i*10+32, first_page_msg[i]);
  137.     
  138.     wait_key();
  139. }
  140.  
  141. #define MAX_SPR 8
  142. #define MAX_FRAME 500
  143.  
  144. /**********************************************************************
  145. * Run MAX_SPR sprites by MAX_FRAME one pixel steps
  146. **********************************************************************/
  147. void run_simple_sprites(SPRITE sprites[MAX_SPR], int regulate)
  148. {
  149.     int i,j;
  150.     
  151.     for (i=0; i<MAX_FRAME; i++) {
  152.         for (j=0; j<MAX_SPR; j++)
  153.             spr_put(sprites[j], i, 50+(8+demo_height)*j);
  154.         gr_setactivepage(spr_next_pass());
  155.         if (regulate)
  156.             spr_regulate_speed();
  157.         if (gr_inkey())
  158.             break;
  159.     }
  160. }
  161.  
  162. /**********************************************************************
  163. * Demonstrate the simple sprite interface (SPR functions)
  164. **********************************************************************/
  165. void spr_demo(void)
  166. {
  167.     SPRITE sprites[MAX_SPR];
  168.     int i;
  169.     clock_t t1;
  170.     float t;
  171.     long far_free;
  172.     
  173.     gr_dual_xy_printf(0,0,"Demonstrating the simple sprite interface:");
  174.  
  175.     /**** First create the example sprites and background ****/
  176.     far_free = farcoreleft();
  177.     for (i=0; i<MAX_SPR; i++) {
  178.         sprites[i] = spr_create(demo_width, demo_height,
  179.                                 demo_shape, demo_mask, (1<<(i%4)), i);
  180.         
  181.         if (sprites[i]==NULL)
  182.             error("spr_demo: cannot create sprites");
  183.         
  184.         gr_dual_center_printf(56+(8+demo_height)*i,
  185.             ">> Horizontal resolution %d pixels, %d bytes memory needed <<",
  186.             8/(1<<(i%4)), far_free - farcoreleft());
  187.         far_free = farcoreleft();
  188.     }
  189.  
  190.     gr_dual_xy_printf(0,320,
  191.       "The STK functions used:");
  192.     gr_dual_xy_printf(0,330,
  193.       " spr_create, gr_dual_xy_printf, gr_inkey");
  194.     gr_dual_xy_printf(0,340,
  195.       " spr_put, spr_next_pass, spr_regulate_speed");
  196.     
  197.     /**** Then show some movement ****/
  198.     gr_dual_xy_printf(0,10,"First movement at appr. 18 frames/second...");
  199.     t1 = clock();
  200.     run_simple_sprites(sprites, 1);
  201.     t = (clock() - t1)/CLK_TCK;
  202.     if (t>1.0)
  203.         gr_dual_xy_printf(0,10, "%d frames, %.1f seconds, %.1f frames/second",
  204.                           MAX_FRAME, t, MAX_FRAME/t);
  205.     else
  206.         gr_dual_xy_printf(0,10, "%-50s","Cancelled.");
  207.  
  208.     
  209.     gr_dual_xy_printf(0,20,"Now movement at the fastest speed...");
  210.     t1 = clock();
  211.     run_simple_sprites(sprites, 0);
  212.     t = (clock() - t1)/CLK_TCK;
  213.     if (t>1.0)
  214.         gr_dual_xy_printf(0,20, "%d frames, %.1f seconds, %.1f frames/second",
  215.                           MAX_FRAME, t, MAX_FRAME/t);
  216.     else
  217.         gr_dual_xy_printf(0,20, "%-50s","Cancelled.");
  218.  
  219.     wait_key();
  220.     
  221.     /**** Delete sprites ****/
  222.     for (i=0; i<MAX_SPR; i++)
  223.         spr_delete(sprites[i]);
  224.     gr_setactivepage(spr_next_pass());
  225. }
  226.  
  227. /**********************************************************************
  228. * Demonstrate the collision detections (SPR_HIT functions)
  229. **********************************************************************/
  230. void spr_hit_demo(void)
  231. {
  232.     SPRITE s1,s2,s3;
  233.     int i,j;
  234.     
  235.     gr_dual_xy_printf(0,0,"Demonstrating the collision detection:");
  236.     
  237.     s1 = spr_create(demo_width, demo_height,
  238.                     demo_shape, demo_mask, 8, 1);
  239.     
  240.     s2 = spr_create(demo_width, demo_height,
  241.                     demo_shape, demo_mask, 8, 2);
  242.     
  243.     s3 = spr_create(car_width, car_height,
  244.                     car_shape, car_mask, 8, 3);
  245.     
  246.     gr_dual_xy_printf(0,320,
  247.       "The STK functions used:");
  248.     gr_dual_xy_printf(0,330,
  249.       " spr_create, gr_dual_xy_printf, gr_inkey");
  250.     gr_dual_xy_printf(0,340,
  251.       " spr_put, spr_hit, spr_next_pass, spr_regulate_speed");
  252.     
  253.     gr_dual_xy_printf(0,20,"Collision between UFOs:");
  254.     gr_dual_xy_printf(0,30,"Collision between UFO and car:");
  255.     j = (gr_max_x-car_width)/2;
  256.     for (i=10; i<j; i++) {
  257.         spr_put(s1, gr_max_x - i - 150, 100);
  258.         spr_put(s2, gr_max_x - i*2 - 50, 110);
  259.         spr_put(s3, i*2, 90);
  260.         
  261.         if (spr_hit(s1,s2))
  262.             gr_dual_xy_printf(24*8,20,"YES");
  263.         else
  264.             gr_dual_xy_printf(24*8,20,"no ");
  265.         
  266.         if (spr_hit(s1,s3) || spr_hit(s2,s3))
  267.             gr_dual_xy_printf(32*8,30,"YES");
  268.         else
  269.             gr_dual_xy_printf(32*8,30,"no ");
  270.         
  271.         spr_next_pass();
  272.         spr_regulate_speed();
  273.         if (gr_inkey())
  274.             break;
  275.     }
  276.         
  277.     wait_key();
  278. }
  279.  
  280. #define BOX_LEF 200
  281. #define BOX_RIG (gr_max_x-BOX_LEF)
  282. #define BOX_TOP 100
  283. #define BOX_BOT (gr_max_y-BOX_TOP)
  284.  
  285.  
  286. WORD demo_fx_handler(ANIM_SPRITE aspr, WORD fx, SPRITE spr)
  287. {
  288.     ANIM_SPR_INFO *asi;
  289.     WORD ret_code = SPR_ANIM_FX_RET_RE_PUT;
  290.  
  291.     asi = spr_anim_get_info(aspr);
  292.  
  293.     switch (fx) {
  294.         case SPR_ANIM_FX_TIMEOUT:
  295.             spr_anim_set_vector(aspr, 2-random(5), 2-random(4));
  296.             spr_anim_set_time(aspr, -1, -1, random(500)+200);
  297.             break;
  298.             
  299.         case SPR_ANIM_FX_HIT_X_LIMIT:
  300.             if (asi->x > asi->rig) {
  301.                 spr_anim_set_location(aspr, asi->rig, asi->y);
  302.                 spr_anim_set_vector(aspr, -asi->dx, asi->dy);
  303.             }
  304.             else {
  305.                 spr_anim_set_location(aspr, asi->lef, asi->y);
  306.                 spr_anim_set_vector(aspr, -asi->dx, asi->dy);
  307.             }
  308.             break;
  309.  
  310.         case SPR_ANIM_FX_HIT_Y_LIMIT:
  311.             if (asi->y > asi->bot) {
  312.                 spr_anim_set_location(aspr, asi->x, asi->bot);
  313.                 spr_anim_set_vector(aspr, asi->dx, -asi->dy);
  314.             }
  315.             else {
  316.                 spr_anim_set_location(aspr, asi->x, asi->top);
  317.                 spr_anim_set_vector(aspr, asi->dx, -asi->dy);
  318.             }
  319.             break;
  320.  
  321.         case SPR_ANIM_FX_HIT_SPRITE:
  322.             if (asi->id==2)
  323.                 spr_anim_set_vector(aspr, -asi->dx, asi->dy);
  324.             break;
  325.             
  326.         default:
  327.             ret_code = SPR_ANIM_FX_RET_DELETE;
  328.     }
  329.     return ret_code;
  330. }
  331.  
  332. /**********************************************************************
  333. * Demonstrate the animated sprite interface (SPR_ANIM functions)
  334. **********************************************************************/
  335. void spr_anim_demo(void)
  336. {
  337.     ANIM_SPRITE as1,as2;
  338.     
  339.     gr_dual_xy_printf(0,0,"Demonstrating the animated sprites:");
  340.  
  341.     as1 = spr_anim_create(6, 
  342.                          spr_create(one1_width, one1_height,
  343.                                     one1_shape, one1_mask, 8, 1),
  344.                          spr_create(one2_width, one2_height,
  345.                                     one2_shape, one2_mask, 8, 1),
  346.                          spr_create(one3_width, one3_height,
  347.                                     one3_shape, one3_mask, 8, 1),
  348.                          spr_create(one4_width, one4_height,
  349.                                     one4_shape, one4_mask, 8, 1),
  350.                          spr_create(one3_width, one3_height,
  351.                                     one3_shape, one3_mask, 8, 1),
  352.                          spr_create(one2_width, one2_height,
  353.                                     one2_shape, one2_mask, 8, 1)
  354.                          );
  355.     if (as1==NULL)
  356.         return;
  357.  
  358.     spr_anim_set_limits(as1,BOX_LEF,BOX_TOP,BOX_RIG,BOX_BOT);
  359.     spr_anim_set_vector(as1, 2, 1);
  360.     spr_anim_set_location(as1, BOX_LEF+8, BOX_TOP+8);
  361.     spr_anim_set_fx_handler(as1, SPR_ANIM_FX_ALL, demo_fx_handler);
  362.     spr_anim_set_time(as1, 0, 3, 1000);
  363.     spr_anim_start(as1);
  364.     
  365.     as2 = spr_anim_create(6, 
  366.                          spr_create(two1_width, two1_height,
  367.                                     two1_shape, two1_mask, 8, 2),
  368.                          spr_create(two2_width, two2_height,
  369.                                     two2_shape, two2_mask, 8, 2),
  370.                          spr_create(two3_width, two3_height,
  371.                                     two3_shape, two3_mask, 8, 2),
  372.                          spr_create(two4_width, two4_height,
  373.                                     two4_shape, two4_mask, 8, 2),
  374.                          spr_create(two3_width, two3_height,
  375.                                     two3_shape, two3_mask, 8, 2),
  376.                          spr_create(two2_width, two2_height,
  377.                                     two2_shape, two2_mask, 8, 2)
  378.                          );
  379.     if (as2==NULL) {
  380.         spr_anim_destroy(as1);
  381.         return;
  382.     }
  383.  
  384.     spr_anim_set_limits(as2,BOX_LEF,BOX_TOP,BOX_RIG,BOX_BOT);
  385.     spr_anim_set_vector(as2, 2, -1);
  386.     spr_anim_set_location(as2, BOX_LEF+8, BOX_BOT-two1_height-8);
  387.     spr_anim_set_fx_handler(as2, SPR_ANIM_FX_ALL, demo_fx_handler);
  388.     spr_anim_set_time(as2, 3, 4, 500);
  389.     spr_anim_start(as2);
  390.  
  391.     /*** Sprites ready, draw the bounding box ***/
  392.     gr_setactivepage(1);
  393.     rectangle(BOX_LEF,BOX_TOP,BOX_RIG,BOX_BOT);
  394.     gr_setactivepage(0);
  395.     rectangle(BOX_LEF,BOX_TOP,BOX_RIG,BOX_BOT);
  396.     
  397.     /*** Wait key animates all sprites ***/
  398.     wait_key();
  399.     
  400.     spr_anim_destroy(as1);
  401.     spr_anim_destroy(as2);
  402. }
  403.  
  404. /**********************************************************************
  405. * The last page before DOS.
  406. **********************************************************************/
  407. void last_page(void)
  408. {
  409.     gr_dual_center_printf(100, "That's all, folks.  Thank You!");
  410.  
  411.     wait_key();
  412. }
  413.  
  414. int main(int argc, char **argv)
  415. {
  416.     int i,j;
  417.  
  418.     /**** Detect a suitable graphics mode, start it and init spr module ****/
  419.     gr_detect(GR_TYPE_SPR, &i, &j);
  420.     if (i == -1) {
  421.         puts("Unsupported graphics mode, need EGA or Hercules!");
  422.         return 1;
  423.     }
  424.     gr_text_mode = GR_MODE_CLEAR_FAST;
  425.     gr_start(&i, &j);
  426.     spr_initialize(i);
  427.     if (argc>1)     /** modify pass delay if given **/
  428.         spr_pass_delay = atoi(argv[1]);
  429.  
  430.     pacer = init_pacer();
  431.     if (pacer==NULL)
  432.         error("main: Cannot initialize pacer sprite");
  433.     
  434.     first_page();
  435.     spr_demo();
  436.     spr_hit_demo();
  437.     spr_anim_demo();
  438.     last_page();
  439.     
  440.     /**** No real need to use gr_end since it is bound with atexit() ****/
  441.     gr_end();
  442.     
  443.     return 0;
  444.     
  445. }
  446.