home *** CD-ROM | disk | FTP | other *** search
/ C++ Games Programming / CPPGAMES.ISO / thx / demos / skater / build / skater.cpp < prev   
Encoding:
C/C++ Source or Header  |  1995-05-12  |  4.6 KB  |  210 lines
  1. // ------- skater.cpp
  2. #include <theatrix.h>
  3. const int sidesteps = 25;  // number of steps in lateral movement
  4. const int fwdsteps = 12;   // number of steps in front/rear movement
  5. const int sstepincr = 5;   // lateral x coordinate increments
  6. const int fstepincr = 3;   // front/rear y coordinate increments
  7. // ------- a moving sprite
  8. class Skater : public Player    {
  9.     short int steps;    // number of steps taken current segment
  10.     short int mode;        // 1-8 = skating pattern #; 11-13 = splash
  11.     friend class Pond;
  12.     void on_enter();
  13. protected:
  14.     DECLARE_CUELIST
  15. public:
  16.     Skater();
  17.     virtual ~Skater() { }
  18.     void update_position();
  19. };
  20. CUELIST(Skater)
  21.     KEYSTROKE(ENTER, on_enter)
  22. ENDCUELIST
  23. // ---- construct a moving sprite
  24. Skater::Skater() : Player("skater.gfx", "skater.sfx")
  25. {
  26.     setxy(90,145);  // initial position on pond
  27.     set_imageno(1); // first skater frame
  28.     appear();
  29.     steps = 0;
  30.     mode = 1;
  31. }
  32. // --- skater frame animation entry point (once every tick)
  33. void Skater::update_position()
  34. {
  35.     switch (mode)    {
  36.         case 1:
  37.         case 3:
  38.         case 5:
  39.         case 7:
  40.             // --- side to side movement
  41.             if (++steps == sidesteps)    {
  42.                 steps = 0;
  43.                 set_imageno(++mode);
  44.                 break;
  45.             }
  46.             if (mode & 2) // modes 3 and 7: to the left
  47.                 setx(getx() - sstepincr);
  48.             else          // modes 1 and 5: to the right
  49.                 setx(getx() + sstepincr);
  50.             break;
  51.         case 2:
  52.         case 4:
  53.         case 6:
  54.         case 8:
  55.             // --- front or back movement
  56.             if (++steps == fwdsteps)    {
  57.                 steps = 0;
  58.                 if (mode == 8)
  59.                     mode = 0;
  60.                 set_imageno(++mode);
  61.                 break;
  62.             }
  63.             if (mode < 6)  // modes 2 and 4: away from the screen
  64.                 sety(gety() - fstepincr);
  65.             else           // modes 6 and 8: toward the screen
  66.                 sety(gety() + fstepincr);
  67.             break;
  68.         case 9:
  69.             setinterval(3);  // slow down refresh rate
  70.             set_imageno(13); // 1st frame of ice-breaking splash
  71.             mode++;
  72.             play_sound_clip(1);
  73.             break;
  74.         case 10:
  75.             set_imageno(12); // 2nd frame of ice-breaking splash
  76.             mode++;
  77.             break;
  78.         case 11:
  79.             set_imageno(13); // 3rd frame of ice-breaking splash
  80.             mode++;
  81.             break;
  82.         case 12:
  83.             set_imageno(11); // hole in ice
  84.             mode++;
  85.             steps = 0;
  86.             break;
  87.         default:
  88.             if (steps++ == 30)
  89.                 stop_director();
  90.             break;
  91.     }
  92. }
  93. // ---- pressed Enter, break the ice
  94. void Skater::on_enter()
  95. {
  96.     if (mode < 9)    {
  97.         int yp = 35;
  98.         if (mode == 3 || mode == 7)
  99.             yp = 25;
  100.         else if (mode > 3 && mode < 7)
  101.             yp = 15;
  102.         setxy(getx()-10, gety() + yp);
  103.         mode = 9;
  104.     }
  105. }
  106. // ---- stationary sprites
  107. class Stander : public Player    {
  108. public:
  109.     Stander() : Player("skater.gfx") { }
  110. };
  111. // ---- the scene: a skating pond
  112. class Pond : public SceneDirector    {
  113.     Stander *stander1;
  114.     Stander *stander2;
  115.     Skater *skater;
  116.     MusicHand *conductor;
  117.     void on_timer();
  118.     void on_enter();
  119.     void display();
  120.     void hide();
  121. public:
  122.     Pond();
  123.     ~Pond();
  124. };
  125. // ---- construct the scene
  126. Pond::Pond() : SceneDirector("pond.pcx")
  127. {
  128.     // --- most distant stationary sprite
  129.     stander1 = new Stander;
  130.     stander1->set_imageno(10);
  131.     stander1->setxy(180,100);
  132.     stander1->appear();
  133.     // --- closest stationary sprite
  134.     stander2 = new Stander;
  135.     stander2->set_imageno(9);
  136.     stander2->setxy(140,130);
  137.     stander2->appear();
  138.     // --- moving sprite
  139.     skater = new Skater;
  140.     conductor = new MusicHand("skater.xmi");
  141. }
  142. Pond::~Pond()
  143. {
  144.     delete conductor;
  145.     delete skater;
  146.     delete stander2;
  147.     delete stander1;
  148. }
  149. void Pond::display()
  150. {
  151.     SceneDirector::display();
  152.     conductor->play_music_clip(1);
  153. }
  154. void Pond::hide()
  155. {
  156.     conductor->stop_music_clip();
  157.     SceneDirector::hide();
  158. }
  159. // ---- to intercept Scenery's use of the Enter key
  160. void Pond::on_enter()
  161. {
  162.     return;
  163. }
  164. // ---- called after each timer tick
  165. void Pond::on_timer()
  166. {
  167.     if (skater->mode < 9 && conductor->isconducting() && 
  168.             !conductor->music_clip_is_playing())    {
  169.         skater->on_enter();
  170.         return;
  171.     }
  172.     SceneDirector::on_timer();
  173.     if (skater->steps == 0)    {
  174.         switch (skater->mode)    {
  175.             case 1:
  176.                 // -- front lateral segment
  177.                 //    set moving sprite in front of others
  178.                 MoveZToFront(skater);
  179.                 break;
  180.             case 3:
  181.             case 7:
  182.                 // -- center lateral segment
  183.                 //    set moving sprite between other two
  184.                 ChangeZOrder(skater,stander2);
  185.                 break;
  186.             case 5:
  187.                 // -- rear lateral segment
  188.                 //    set moving sprite behind others
  189.                 ChangeZOrder(skater,stander1);
  190.                 break;
  191.             default:
  192.                 break;
  193.         }
  194.     }
  195. }
  196. class SkaterDemo : public Theatrix  {
  197.      Pond* pond;
  198. public:
  199.     SkaterDemo() : Theatrix("Skater")
  200.         { pond=new Pond; }
  201.       ~SkaterDemo()
  202.          { delete pond; }
  203. };
  204. int main()
  205. {
  206.     SkaterDemo demo;
  207.     demo.go();
  208.     return 0;
  209. }
  210.