home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / meteor.pak / SPRITE.H < prev   
Encoding:
C/C++ Source or Header  |  1997-07-24  |  8.9 KB  |  309 lines
  1. //--------------------------------------------------------------------------
  2. // Turbo Meteor -- Copyright (c) 1995, Borland International
  3. //--------------------------------------------------------------------------
  4. #ifndef SPRITE_H
  5. #define SPRITE_H
  6.  
  7. #include <owl/owlpch.h>
  8. #include <math.h>
  9.  
  10. const MAX_SPEED = 20;
  11.  
  12. //extern double sinTable[360];
  13. //extern double cosTable[360];
  14.  
  15. double sind( int angle );
  16. double cosd( int angle );
  17.  
  18. class SpriteList;  // forward declaration for use in Sprite class
  19.  
  20. // class Sprite -- a base class for any object which will be displayed
  21. // on the screen.
  22. //
  23. class Sprite {
  24.   friend class SpriteList;   // so the SpriteList class can access
  25.                              // data members
  26. protected:
  27.   SpriteList *owner;         // pointer to the list which contains us
  28.   Sprite     *next;          // pointer to next sprite in the list
  29.   TPoint     origin;         // sprites position in the window
  30.   TRect      boundingRect;   // a rectangle which completely encloses sprite
  31.   double     mx,my;          // current direction of sprite
  32.   TSize      screenSize;     // size of screen which contains the sprite
  33.                              // used to wrap objects from one side of screen to other
  34.   bool       condemned;      // used to mark dead objects
  35. private:
  36.   Sprite() {}                // to generate compile-time error
  37.  
  38. public:
  39.   Sprite( TSize& aScreenSize ) {
  40.     screenSize = aScreenSize;
  41.     ResetBoundingRect();
  42.     mx=my=0;
  43.     condemned = false;
  44.   }
  45.   void SetMomentum( TSize& newMomentum ) {
  46.     mx = newMomentum.cx;
  47.     my = newMomentum.cy;
  48.   }
  49.  
  50.   void Condemn() {
  51.     condemned = true;
  52.   }
  53.   // Update -- by default, moves sprite based on it's momentum.  Should
  54.   // return a value which will be added to the score
  55.   //
  56.   virtual int Update() {
  57.     origin.x+=mx;
  58.     origin.y+=my;
  59.     Wrap();
  60.     return 0;
  61.   }
  62.   void ResetBoundingRect() {
  63.     boundingRect = TRect( origin, origin );
  64.   }
  65.  
  66.   // ExpandBoundingRect -- given a point, expand our bounding rectangle
  67.   // to include this point.
  68.   //
  69.   void ExpandBoundingRect( TPoint& p ) {
  70.     if (p.x<boundingRect.left)
  71.       boundingRect.left = p.x;
  72.     if (p.y<boundingRect.top)
  73.       boundingRect.top = p.y;
  74.     if (p.x>boundingRect.right)
  75.       boundingRect.right = p.x;
  76.     if (p.y>boundingRect.bottom)
  77.       boundingRect.bottom = p.y;
  78.     boundingRect.Normalize();
  79.   }
  80.  
  81.   // Default draw function draws a pixel at the sprites origin
  82.   //
  83.   virtual void Draw( TMemoryDC& dc ) {
  84.     dc.SetPixel( origin, TColor( 255, 255, 255 ) );
  85.   }
  86.  
  87.   // DebugInfo -- returns string to display in the debugging log window
  88.   //
  89.   virtual const char *DebugInfo() { return "Sprite"; }
  90.  
  91.   // Wrap -- adjust the sprites origin, if it strays off the edge of
  92.   // the window
  93.   //
  94.   void Wrap() {
  95.     origin.x = (origin.x + screenSize.cx) % screenSize.cx;
  96.     origin.y = (origin.y + screenSize.cy) % screenSize.cy;
  97.   }
  98. };
  99.  
  100. // SpriteList -- contains a list of sprites.  Contains specific
  101. // functions for collision detection
  102. //
  103. class SpriteList {
  104.   Sprite *root;
  105. public:
  106.   int count;
  107.   SpriteList() {
  108.     root = 0;
  109.     count = 0;
  110.   }
  111.   void Add( Sprite* sprite );
  112. //  bool Remove( Sprite* sprite );
  113.   void DrawAll( TMemoryDC& dc );
  114.   void UpdateLog( TListBox *lb );
  115.   int UpdateAll();
  116.   Sprite* CheckForHitMeteor( TPoint& p );
  117. };
  118.  
  119. // Meteor -- a rock, floating in space.  The meteor is specified as
  120. // a series of polor-coordinate points (an angle and a radius).  This
  121. // allows for faster calculation when making the meteors rotate as
  122. // they float about.
  123. //
  124.  
  125. // the following are defined in sprite.cpp
  126.  
  127. extern int angle1[10];
  128. extern int radius1[10];
  129. extern int count1;
  130.  
  131. class Meteor: public Sprite {
  132.   int    angularMomentum,    // how fast the meteor is spinning
  133.          currentAngle;       // current angle of rotation
  134.   int    angle[10],          // angle and radius of the points
  135.          radius[10];         //   which define the meteor
  136.   int    count;              // # of points which define the meteor
  137.   int    size;               // 1=tiny, 2=medium, 3=large rock
  138.   int    spawnCount;         // how many smaller meteors to create when hit
  139.  
  140. public:
  141.   Meteor( TPoint& aOrigin, TSize& aMomentum, int aSize, int aSpawnCount );
  142.   int GetSize() { return size; }
  143.   void SetRotationAngle( int angle );
  144.   int Update() {
  145.     origin.x+=mx;
  146.     origin.y+=my;
  147.     Wrap();
  148.     currentAngle = (currentAngle+angularMomentum+360)%360;
  149.     return 0;
  150.   };
  151.   void Hit();
  152.   virtual void Draw( TMemoryDC& dc );
  153.   virtual const char *DebugInfo();
  154. };
  155.  
  156. // Shot -- a bullet (5 pixels in a cross pattern)
  157. //
  158. class Shot: public Sprite {
  159.   int timeToDie;            // shots dissapear after a set amount of time
  160. public:
  161.   Shot( TPoint& aOrigin, TSize& aMomentum, int aTimeToDie ):
  162.     Sprite( TSize(600,400) ) {  //*BBK*
  163.     origin = aOrigin;
  164.     mx = aMomentum.cx;
  165.     my = aMomentum.cy;
  166.     timeToDie = aTimeToDie;
  167.   }
  168.   virtual void Draw( TMemoryDC& dc ) {
  169.     if (timeToDie>0) {
  170.       dc.SetPixel( origin, TColor(255,255,255) );
  171.       dc.SetPixel( origin+TPoint(1,0), TColor(255,255,255) );
  172.       dc.SetPixel( origin+TPoint(0,1), TColor(255,255,255) );
  173.       dc.SetPixel( origin+TPoint(0,-1), TColor(255,255,255) );
  174.       dc.SetPixel( origin+TPoint(-1,0), TColor(255,255,255) );
  175. //      dc.MoveTo( origin );
  176. //      dc.LineTo( origin-momentum );
  177.     }
  178.   }
  179.   virtual int Update();
  180.   virtual const char *DebugInfo() { return "Shot"; }
  181. };
  182.  
  183. // Debris -- a spinning line.  it floats about for a few seconds and
  184. // disappears.  the player ship is turned into these when it is destroyed.
  185. //
  186. class Debris: public Sprite {
  187.   TPoint p1,p2;
  188.   int size;              // length of line
  189.   int angle;             // current angle of spinning line
  190.   int angularMomentum;   // rate of spin
  191.   int timeToDie;
  192. public:
  193.   Debris( TPoint& aP1, TPoint& aP2, TSize& screenSize ): Sprite(screenSize) {
  194. //    origin = TPoint( (p1.x+p2.x)/2, (p1.y+p2.y)/2 );
  195.     p1 = aP1;
  196.     p2 = aP2;
  197.     mx = random(10)-5;
  198.     my = random(10)-5;
  199.     angularMomentum = random(10)-5;
  200.     timeToDie = 20 + random(5);
  201.   }
  202.   int Update() {
  203.     if (timeToDie>0) {
  204.       p1+=TPoint(mx,my);
  205.       p2+=TPoint(mx,my);
  206.       timeToDie--;
  207.     } else
  208.       Condemn();
  209.     return 0;
  210.   }
  211.   void Draw( TMemoryDC& dc ) {
  212.     dc.MoveTo(p1);
  213.     dc.LineTo(p2);
  214.   }
  215. };
  216.  
  217. // Ship -- the player ship
  218. //
  219. class Ship: public Sprite {
  220.   int angle,radius,thrust;
  221. public:
  222.   Ship( TPoint& pos ): Sprite( TSize(600,400) ) { //*BBK*
  223.     origin = pos;
  224.     angle = 0;
  225.     radius=10;
  226.     thrust=0;
  227.     mx=my=0;
  228.   }
  229.   virtual void Draw( TMemoryDC& dc ) {
  230.     TPoint p1,p2,p3,p4;
  231.  
  232.     p1 = TPoint( radius*sind(angle), radius*cosd(angle) );
  233.     p2 = TPoint( radius*sind(angle+130), radius*cosd(angle+130) );
  234.     p3 = TPoint( (radius/4)*sind(angle+180), (radius/4)*cosd(angle+180) );
  235.     p4 = TPoint( radius*sind(angle+230), radius*cosd(angle+230) );
  236.     dc.MoveTo( p1+origin );
  237.     dc.LineTo( p2+origin );
  238.     dc.LineTo( p3+origin );
  239.     dc.LineTo( p4+origin );
  240.     dc.LineTo( p1+origin );
  241.   }
  242.   void Explode() {
  243.     Condemn();
  244.     TPoint p1,p2,p3,p4;
  245.     p1 = origin + TPoint( radius*sind(angle), radius*cosd(angle) );
  246.     p2 = origin + TPoint( radius*sind(angle+130), radius*cosd(angle+130) );
  247.     p3 = origin + TPoint( (radius/4)*sind(angle+180), (radius/4)*cosd(angle+180) );
  248.     p4 = origin + TPoint( radius*sind(angle+230), radius*cosd(angle+230) );
  249.  
  250.     owner->Add( new Debris( p1, p2, screenSize ) );
  251.     owner->Add( new Debris( p2, p3, screenSize ) );
  252.     owner->Add( new Debris( p3, p4, screenSize ) );
  253.     owner->Add( new Debris( p4, p1, screenSize ) );
  254.   }
  255.   void Rotate( int adjust ) {
  256.     angle = (angle+adjust+360)%360;
  257.   }
  258.   void AddThrust( int adjust ) {
  259.     thrust+=adjust;
  260.     if (thrust<0) thrust=0;
  261.   }
  262.   int Update() {
  263.     int len;
  264.     mx+= thrust*sind( angle );
  265.     my+= thrust*cosd( angle );
  266.     len = (sqrt(mx*mx+my*my));
  267.     if (len>MAX_SPEED) {
  268.       mx = mx/len*MAX_SPEED;
  269.       my = my/len*MAX_SPEED;
  270.       thrust=0;
  271.     }
  272.     origin.x+=mx;
  273.     origin.y+=my;
  274.     Wrap();
  275.  
  276.     // check to see if we hit a meteor
  277.  
  278.     Sprite* meteor = owner->CheckForHitMeteor( origin );
  279.  
  280.     if (meteor)
  281.       return -9999;
  282.  
  283.     return 0;
  284.   }
  285.   Shot* CreateNewShot() {
  286.     TSize shotDir( 10*sind(angle),10*cosd(angle) );
  287.     TPoint shotOrigin = TPoint( radius*sind( angle ), radius*cosd( angle ) );
  288.     return new Shot( origin+shotOrigin, shotDir+TPoint(mx,my), 20 );
  289.   }
  290.   virtual const char *DebugInfo() { return "Ship"; }
  291. };
  292.  
  293. // Message -- a sprite that can display numbers 0-9, used for score display
  294. //
  295. class Message: public Sprite {
  296.   char *text;
  297.   int  bufferLen;
  298. public:
  299.   Message( TPoint& aOrigin, int aBufferLen );
  300.   ~Message();
  301.   void SetText( const char *aText ) {
  302.     strncpy( text, aText, bufferLen );
  303.   }
  304.   virtual void Draw( TMemoryDC& dc );
  305.   virtual const char *DebugInfo();
  306. };
  307.  
  308. #endif // SPRITE_H
  309.