sprite.h

Go to the documentation of this file.

/***************************************************************************
               sprite.h  -  Sprite types, and class definition
                         -------------------
    begin                : Wed Mar 5 2003
    copyright            : (C) 2003 by Tyler Montbriand
    email                : tsm@accesscomm.ca
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef SPRITE_H
#define SPRITE_H
#include "RotateImage.h"
#include "Fxp.h"
#include "rect.h"
#include "bitmask.h"

#include <SDL/begin_code.h>


typedef Uint16  SpriteFlag;

typedef Uint8  ColType;

#define COL_LAYER(x)  (0xff&(1<<x))


#define SPRITE_NONE       0x0000  

#define SPRITE_WAIT       0x0001

#define SPRITE_MOVED      0x0002

#define SPRITE_EXPIRED    0x0004

#define SPRITE_DELETEABLE 0x0008

#define SPRITE_OWNSURFACE 0x0010

#define SPRITE_OWNBITMASK 0x0020


class DECLSPEC Sprite
{
  friend class SpriteList;
  friend class SpriteManager;
  
public:

  Sprite();

  virtual void Update(Sint32 dtick);
  virtual void OnCollide(const Sprite *spr, ColType index);
  virtual int GetFrame();
  virtual Sprite *Clone();
  virtual void Event(int code, void *data1=NULL, void *data2=NULL);

  inline SfxpCoord Pos()  const {return pos;  }
  inline SfxpCoord Vel()  const {return vel;  }
  inline void ReverseXVelocity()
  { vel.SetFxp(  -vel.Xfxp(), vel.Yfxp()  );  }
  inline void ReverseYVelocity()
  { vel.SetFxp(   vel.Xfxp(),-vel.Yfxp()  );  }
  inline void Preserve()
  { prevpos=pos;  }
  inline void MoveTo(Sfxp x, Sfxp y)
  {  pos.SetFxp(x,y);  }
  inline void SetVel(SfxpCoord velin)
  {  vel=velin;  }
  Rect PrevRect() const
  {  return(Rect(prevpos,srcrect.w,srcrect.h)); }
  Rect CurRect() const
  {  return(Rect(pos, srcrect.w,srcrect.h));    }
  inline Sfxp VXfxp() const { return(vel.Xfxp()); }
  inline Sfxp VYfxp() const { return(vel.Yfxp()); }
  inline Sfxp Xfxp()  const { return pos.Xfxp(); };
  inline Sfxp Yfxp()  const { return pos.Yfxp(); }  

  inline void Remove()
  {  SetFlags(SPRITE_EXPIRED);  }
  inline void Tag()
  {  SetFlags(SPRITE_MOVED);  }
  inline int OwnSurface() const
  {  return(flag&SPRITE_OWNSURFACE);  }
  inline int OwnBitmask() const
  {  return(flag&SPRITE_OWNBITMASK);  }
  inline SpriteFlag SetFlags(const SpriteFlag flags)
  {
    flag|=flags;
    return(flag);
  }
  inline int Deleteable() const
  {  return(flag&SPRITE_DELETEABLE);  }
  inline int New() const
  {  return((flag&SPRITE_WAIT)&&!(flag&SPRITE_EXPIRED));  }
  inline int Moved() const
  {  return(flag&(SPRITE_MOVED|SPRITE_EXPIRED));  }
  inline void Expire()
  { SetFlags(SPRITE_EXPIRED); }
  inline int Expired() const
  {  return(flag&SPRITE_EXPIRED);  }
  inline const SpriteFlag ClearFlags(const SpriteFlag flags)
  {
    flag&=~flags;
    return(flag);
  }
  inline const SpriteFlag GetFlags() const
  { return(flag);  }  


  inline bool CanCollide(Sprite *spr)
  {
    if(spr==NULL) return false;
    Rect r1=CurRect(),r2=spr->CurRect();

    if((clayer&spr->cindex)&&(cindex&spr->clayer))
    if(r1.Overlaps(r2))
    {
      bitmask *b1=GetBitmask(),*b2=spr->GetBitmask();

      if((b1!=NULL)&&(b2!=NULL))
      {
        int dx=r2.x-r1.x,dy=r2.y-r1.y;
        if(bitmask_overlap(b1,b2,dx,dy))/* Bitmask collision */
          return(true);
        else
          return(false);
      }
      else  /* Bounding box collision only */
        return(true);
    }

    return false;
  }    

  bitmask *GetBitmask();
  inline Uint8 const GetColIndex()  { return(cindex); }
  inline ColType const GetColLayer(){ return(clayer); }
  

  inline void SetFrameRate(Sfxp frate)
  { framerate=frate;  }
  inline Sint16 DrawLayer() const
  { return(drawlayer);  }
  inline void CalcFrame()
  {
    int f=GetFrame();
    int xf=f%frames.x;
    int yf=(f/frames.x)%frames.y;

    srcrect.x=xf*frames.w;
    srcrect.y=yf*frames.h;
    srcrect.w=frames.w;
    srcrect.h=frames.h;
  }


  void Draw(SDL_Surface *screen);
  void Draw(SDL_Surface *screen, Rect portion);
  void Init_Surface(SDL_Surface *surface=NULL, bool os_in=false);
  void Init_Layers(Sint16 layer=0);
  void Init_List(Sprite *previn=NULL, Sprite *nextin=NULL);
  void Init_Flags(SpriteFlag flags=0);
  void Init_Frames(int xframes=-1, int yframes=-1);
  void Init_Collision(ColType c_index=0, ColType c_layer=0);
  void Init_Bitmask(bool enable=false, bitmask **bmask_in=NULL);

  virtual ~Sprite();
  
protected:
  bitmask **bmask;
  ColType clayer;
  ColType cindex;  

  Sfxp frame;
  Sfxp framerate;
  Rect   frames;
  SDL_Surface *surface;
  Rect srcrect;
  Sint16 drawlayer;  

  SfxpCoord pos;
  SfxpCoord prevpos;
  SfxpCoord vel;

  Sprite *prev,*next;

  SpriteFlag flag;
};

DECLSPEC SDL_Surface * SDLCALL LoadConvertBMP(const char *, Uint8 tr=255, Uint8 tg=0,
                            Uint8 tb=255                            );
DECLSPEC bitmask * SDLCALL MakeBitMask(SDL_Surface *surf, Rect rect);

#include <SDL/close_code.h>

#endif/*SPRITE_H*/

---