1. // CSprite class
  2.  
  3. #include "csprite.h"
  4.  
  5.  
  6. // --------------------------//
  7. // ------- CSPRITE ----------//
  8.  
  9. LPCSTR CSprite::getFilename()
  10. {
  11.     return filename;
  12. };
  13.  
  14. int CSprite::nextFrame()
  15. {
  16.     if (++animcount > animdelay)
  17.         animcount=0;
  18.     else
  19.         return 0; // use anim delay to slow down animations
  20.  
  21.     // increments current frame and checks for max
  22.     if (++curframe > lastframe)
  23.     {
  24.         curframe=0;
  25.         return 1;
  26.     }
  27.     else
  28.         return 0;
  29. }
  30. int CSprite::getFrame()
  31. {
  32.     return curframe;
  33. }
  34. void CSprite::setFrame(int newFrame)
  35. {
  36.     curframe=newFrame;
  37. }
  38. void CSprite::setLastFrame(int newLastFrame)
  39. {
  40.     lastframe = newLastFrame;
  41. }
  42. int CSprite::getLastFrame()
  43. {
  44.     return lastframe;
  45. }
  46.  
  47. void CSprite::setDelay(int newDelay)
  48. {
  49.     animdelay = newDelay;
  50. }
  51. int CSprite::getDelay()
  52. {
  53.     return animdelay;
  54. }
  55.  
  56.  
  57. void CSprite::setXY(int newX, int newY)
  58. {
  59.     x = newX;
  60.     y = newY;
  61. }  
  62.  
  63. void CSprite::setMoveXY(int moveX, int moveY)
  64. {
  65.     movex = moveX;
  66.     movey = moveY;
  67. }
  68.  
  69. int CSprite::getX()
  70. {
  71.     return x;
  72. }
  73. int CSprite::getY()
  74. {
  75.     return y;
  76. }
  77.  
  78. int CSprite::getMoveY()
  79. {
  80.     return movey;
  81. }
  82. void CSprite::setMoveY(int newY)
  83. {
  84.     movey = newY;
  85. }
  86.  
  87. int CSprite::getMoveX()
  88. {
  89.     return movex;
  90. }
  91. void CSprite::setMoveX(int newX)
  92. {
  93.     movex = newX;  
  94. }
  95.  
  96. void CSprite::setX(int newX)
  97. {
  98.     x = newX;  
  99. }
  100. void CSprite::addX(int addtoX)
  101. {
  102.     x += addtoX;
  103.  
  104. }
  105.  
  106. void CSprite::setY(int newY)
  107. {
  108.     y = newY;  
  109. }
  110. void CSprite::addY(int addtoY)
  111. {
  112.     y += addtoY;
  113. }
  114.  
  115. int CSprite::getHeight()
  116. {
  117.     return height;
  118. }
  119. int CSprite::getWidth()
  120. {
  121.     return width;  
  122. }
  123.  
  124. LPDIRECT3DTEXTURE9 CSprite::getImage()
  125. {
  126.     return _image;
  127. }
  128.  
  129. // returns a rect pointing to the sprites frame
  130. RECT CSprite::getRect()
  131. {
  132.     /*  EAST    = 1,
  133.         NORTH   = 2,
  134.         NE      = 3,
  135.         NW      = 4,
  136.         SOUTH   = 5,
  137.         SE      = 6,
  138.         SW      = 7,
  139.         WEST    = 8    
  140.     */
  141.  
  142.     RECT srcRect;
  143.  
  144.     // will return the RECT point to current sprite, within sprite sheet       
  145.     srcRect.left   = (curframe % columns) * width;
  146.     srcRect.top    = (curframe / columns) * height;
  147.     srcRect.right  = srcRect.left + width;
  148.     srcRect.bottom = srcRect.top  + height;
  149.    
  150.     return srcRect;
  151. }
  152.  
  153.  
  154. // returns a collision rect, using GAMEWORLD coordinates
  155. RECT CSprite::collisionRect(int ScrollX,int ScrollY)
  156. {
  157.     POINT loc;
  158.     loc.x = x - ScrollX;
  159.     loc.y = y - ScrollY;
  160.  
  161.     RECT r1;
  162.     r1.left     = loc.x + 1;
  163.     r1.top      = loc.y + 1;
  164.     r1.right    = loc.x + width  -2;
  165.     r1.bottom   = loc.y + height -2;
  166.  
  167.     return r1;
  168. };
  169.  
  170. // returns a collision rect, using GAMEWORLD coordinates (this one is scaled down)
  171. RECT CSprite::scaledRect(int ScrollX,int ScrollY, float scaleX, float scaleY)
  172. {
  173.     POINT scaled;
  174.     scaled.x = (int)((width/2)  * scaleX); // the gets the x amount to add/subtract from center point  
  175.     scaled.y = (int)((height/2) * scaleY); // the gets the x amount to add/subtract from center point
  176.  
  177.     POINT center;
  178.     center.x = x - ScrollX + (width  / 2) -1; // since first pixel is counted (0)
  179.     center.y = y - ScrollY + (height / 2) -1;
  180.  
  181.     RECT r1;
  182.     r1.left     = center.x - scaled.x;
  183.     r1.top      = center.y - scaled.y;
  184.     r1.right    = center.x + scaled.x;
  185.     r1.bottom   = center.y + scaled.y;
  186.  
  187.     return r1;
  188. };
  189.  
  190.  
  191. DIRS CSprite::getFacing()
  192. {
  193.     return facingDir;
  194. }
  195. void CSprite::setFacing(DIRS newFacing)
  196. {
  197.     facingDir = newFacing;
  198.  
  199.     // set new angle to match
  200.     switch(newFacing)
  201.     {
  202.         case EAST:  setAngle(  0); break;
  203.         case SE:    setAngle( 45); break;
  204.         case SOUTH: setAngle( 90); break;
  205.         case SW:    setAngle(135); break;
  206.         case WEST:  setAngle(180); break;
  207.         case NW:    setAngle(225); break;
  208.         case NORTH: setAngle(270); break;
  209.         case NE:    setAngle(315); break;
  210.     }      
  211. /*  switch(facingDir)
  212.     {
  213.     case NORTH: angle = 0;   break;
  214.     case SOUTH: angle = 180; break;
  215.     case EAST:  angle = 90;  break;
  216.     case WEST:  angle = 270; break;
  217.     case NE:    angle = 45;  break;
  218.     case NW:    angle = 315; break;
  219.     case SE:    angle = 135; break;
  220.     case SW:    angle = 225; break;
  221.     }       */
  222.  
  223. };
  224.  
  225. bool CSprite::isMoving()
  226. {
  227.     return moving;
  228. }
  229.  
  230. void CSprite::setMoving(bool newState)
  231. {
  232.     moving = newState; 
  233. }
  234.  
  235. POINT CSprite::getPT()
  236. {
  237.     POINT tPT;
  238.     tPT.x = x;
  239.     tPT.y = y;
  240.  
  241.     return tPT;
  242. }
  243.  
  244. void CSprite::setPT(POINT tPT)
  245. {
  246.     x = tPT.x;
  247.     y = tPT.y;
  248. }
  249.  
  250. void CSprite::setNewDIR(int newDir)
  251. {
  252.     switch(newDir)
  253.     {
  254.         case  1: movey=-2;              facingDir = NORTH;  break;  // NORTH
  255.         case  2: movey= 2;              facingDir = SOUTH;  break;  // SOUTH
  256.         case  3: movex= 2;              facingDir = EAST;   break;  // EAST
  257.         case  4: movex=-2;              facingDir = WEST;   break;  // WEST
  258.         case  5: movex= 2;  movey=-1;   facingDir = NE;     break;  // NE
  259.         case  6: movex=-2;  movey=-1;   facingDir = NW;     break;  // NW
  260.         case  7: movex= 2;  movey= 1;   facingDir = SE;     break;  // SE
  261.         case  8: movex=-2;  movey= 1;   facingDir = SW;     break;  // SW
  262.     };
  263. }
  264.  
  265. // defines the screen walkable/collision border for this sprite
  266. void CSprite::setBorder(int Left, int Right, int Top, int Bottom)
  267. {
  268.     border.left     = Left;
  269.     border.right    = Right;
  270.     border.top      = Top;
  271.     border.bottom   = Bottom;
  272. }
  273.  
  274. // returns TRUE if sprite is within its defined border, FALSE otherwise
  275. bool CSprite::inBorder()
  276. {
  277.     // see if it is inside the border boundaries
  278.     POINT anchor = getAnchor();
  279.     if ((anchor.x < border.left) || (anchor.x > border.right) || (anchor.y < border.top)  || (anchor.y  > border.bottom))
  280.         return false;
  281.  
  282.     return true;
  283. }
  284.  
  285. bool CSprite::checkBorder()
  286. {
  287.     bool fixed = false;
  288.  
  289.     // ( (x <= border.right) && (x >= border.left) && (y <= border.bottom) && (y >= border.top) );
  290.     if (x < border.left)
  291.     {
  292.         x = border.left;
  293.         fixed = true;
  294.     }
  295.     else if (x > border.right)
  296.     {
  297.         x = border.right;
  298.         fixed = true;
  299.     }
  300.  
  301.     if (y < border.top)
  302.     {
  303.         y = border.top;
  304.         fixed = true;
  305.     }
  306.     else if (y > border.bottom)
  307.     {
  308.         y = border.bottom;
  309.         fixed = true;
  310.     };
  311.    
  312.     return fixed;
  313. }
  314.  
  315. void CSprite::setSTATE(STATEtype newS)
  316. {
  317.     STATE = newS;
  318. }
  319.  
  320. STATEtype CSprite::getSTATE()
  321. {
  322.     return STATE;
  323. }
  324.  
  325. POINT CSprite::getAnchor()
  326. {
  327.     POINT tPT;
  328.  
  329.     // returns center point
  330.     tPT.x = (x -1) + (width  * 0.5);
  331.     tPT.y = (y -1) + (height * 0.5);
  332.  
  333.     return tPT;
  334. }
  335.  
  336. void CSprite::doMove()
  337. {
  338.     x += movex;
  339.     y += movey;
  340. };
  341.  
  342. void CSprite::setAnimate(bool value)
  343. {
  344.     doANIM = value;
  345. };
  346.  
  347. void CSprite::setupAnim(int numFrames, DIRS newDir, int perRow)
  348. {
  349.     curframe = 0;
  350.     lastframe = numFrames-1; // first frame should be (0)
  351.     frames_per_anim = numFrames;
  352.     facingDir = newDir;
  353.     animdelay = 2;
  354.     animcount = 0;
  355.     columns = perRow; // sprite per row in sprite sheet
  356. }
  357.  
  358. // constructor for new sprites ... curFrame will always be (1) .. scale and rotation not currently implemented
  359. // and this is for non-animated sprites
  360. CSprite::CSprite(int X, int Y, int Width, int Height, LPCSTR Filename)
  361. {
  362.     x = X;
  363.     y = Y;
  364.     width = Width;
  365.     height = Height;
  366.  
  367.     // initialize these, but not currently in use since this is non-animated sprite
  368.     curframe = 0;
  369.     lastframe = 1;
  370.     animdelay = 3;
  371.     animcount = 0;
  372.     movex = 0;
  373.     movey = 0;
  374.  
  375.     columns = 1;
  376.     frames_per_anim = 1;
  377.  
  378.     setSTATE(INACTIVE);
  379.  
  380.     doANIM= true;
  381.  
  382.     // default
  383.     setFacing(EAST); // sets angle to 0 as well, EAST=1
  384.  
  385.     // save for later
  386.     filename = Filename;
  387.  
  388.     // Load the sprite file
  389.     LoadImage(Filename);       
  390. }
  391.  
  392. // destructor -- the default one should release all memory allocated for this sprite
  393.  CSprite::~CSprite(void)
  394. {
  395.     // release the sprite sheet
  396.     _image->Release();     
  397. }
  398.  
  399.  
  400. void CSprite::LoadImage(LPCSTR Filename)
  401. {
  402.     _image = LoadTexture(Filename, D3DCOLOR_XRGB(255,0,255));
  403.     assert(_image);        
  404. }
  405.  
  406. int CSprite::getAngle()
  407. { return angle; }
  408.  
  409. void CSprite::addAngle(int newA)
  410. {
  411.     setAngle(angle + newA);
  412. }
  413.  
  414. void CSprite::setAngle(int newA)
  415. {
  416.     angle = newA;
  417.     if ((angle >= 360) || (angle < 0))
  418.         angle = 360 - angle;
  419.  
  420.     if ((angle >= 360) || (angle < 0))
  421.         angle = 0;
  422. }
  423.  
  424. POINT calcXY(int degree, float distance, POINT startPT)
  425. {
  426.     POINT endPT;
  427.  
  428.     // formula assumes objects xy is {0,0} on a graph
  429.     endPT.x = (find_x(degree) * distance) + startPT.x;
  430.     endPT.y = (find_y(degree) * distance) + startPT.y;
  431.  
  432.     return endPT;
  433. };
  434. double find_x(int degree)
  435. {
  436.     // convert degree to radian first
  437.     return cos(degree * (PI / 180));
  438. };
  439. double find_y(int degree)
  440. {
  441.     // convert degree to radian first
  442.     return sin(degree * (PI / 180));
  443. };
  444.  
  445. POINT find_OrbitXY(int degree, float distance, POINT startPT)
  446. {
  447.     POINT endPT;
  448.  
  449.     // formula assumes objects xy is {0,0} on a graph
  450.     endPT.x = (find_x(degree) * distance) + startPT.x;
  451.     endPT.y = (find_y(degree) * distance) + startPT.y;
  452.  
  453.     return endPT;
  454. };
  455.