sprite.cpp

Go to the documentation of this file.

/***************************************************************************
                  sprite.cpp  -  Sprite class implementation
                             -------------------
    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.                                   *
 *                                                                         *
 ***************************************************************************/


/* Define this to use IMG_Load instead of SDL_LoadBMP */
#define USE_SDL_IMAGE
 
#include <malloc.h>
#include "Fxp.h"
#include "rect.h"
#include "sprite.h"
#include "bitmask.h"

Sprite::Sprite()
{
  Init_List();
  Init_Flags();
  Init_Layers();
  Init_Surface();
  Init_Frames();
  Init_Collision();
  Init_Bitmask();
}


void Sprite::Event(int code, void *data1, void *data2)
{
}

Sprite *Sprite::Clone()
{
  Sprite *spr=new Sprite();

  (*spr)=(*this);
  spr->ClearFlags(SPRITE_OWNSURFACE|SPRITE_OWNBITMASK);
  return(spr);
}

void Sprite::OnCollide(const Sprite *spr, ColType index)
{
}

int Sprite::GetFrame()
{ /* Just returns current integer frame, but could do table stuff */
  return(FROM_SFXP(frame));
}

void Sprite::Init_Collision(ColType c_index, ColType c_layer)
{
  cindex=c_index;
  clayer=c_layer;
}

void Sprite::Update(Sint32 dtick)
{
  /* Update frame # */
  if((surface!=NULL)&&(framerate!=0))
  {
    int of,newf;
    /* Get the current frame */
    of=FROM_SFXP(frame);    
    /* Increment frame position */
    
    if(framerate<0) /* Wrap negative framerates properly */
    {
      while((framerate*dtick)< -frame)
        frame+=TO_SFXP(frames.x*frames.y);
    }

    frame+=(framerate*dtick);      

    /* Get the new frame # */
    newf=FROM_SFXP(frame);

    /* If there has been a change of 1 whole digit or more */    
    if(of!=newf)
    {
      /* Calculate the new values for srcrect */
      CalcFrame();
      /* Mark the sprite as needing redraw */
      Tag();
    }            
  }
  
  /* Calculate movement */
  if((dtick!=0)&&(vel.Nonzero()))
  {
    /* Get current velocity */
    SfxpCoord dpos=vel;
    /* Calculate the distance moved */
    dpos.IntScalar(dtick);

    /* Increment position */
    pos+=dpos;

    /* If there's been a change of 1 pixel or more */
    if(!pos.MajorDigitsEqual(prevpos))
    {    
      /* Mark the sprite as needing redraw */
      Tag();
    }
  }    
}

void Sprite::Init_Frames(int xframes, int yframes)
{
  frame=framerate=0;

  if((xframes<=0)||(yframes<=0))
    frames.x=frames.y=1;        
  else
  {
    frames.x=xframes;
    frames.y=yframes;
  }

  if(surface==NULL)
    frames.w=frames.h=0;
  else
  {
    frames.w=surface->w/frames.x;
    frames.h=surface->h/frames.y;
  }

  CalcFrame();
}

void Sprite::Init_Flags(SpriteFlag flags)
{
  flag=flags|SPRITE_WAIT;
}

void Sprite::Init_Surface(SDL_Surface *surf, bool os_in)
{
  if(surf==NULL)
  {
    surface=NULL;
    srcrect.Set(0,0,0,0);
  }
  else
  {
    surface=surf;
    srcrect.Set(0,0,surface->w,surface->h);
    
    if(os_in)
      SetFlags(SPRITE_OWNSURFACE);
    else
      ClearFlags(SPRITE_OWNSURFACE);
  }
}

void Sprite::Init_List(Sprite *previn, Sprite *nextin)
{
  prev=previn;
  next=nextin;
}

void Sprite::Init_Bitmask(bool enable, bitmask **bmask_in)
{
  if(enable)  
  {
    if(bmask_in!=NULL)
    {
      bmask=bmask_in;
      ClearFlags(SPRITE_OWNBITMASK);
    }
    else
    {
      int n=-1;

      bmask =(bitmask **)malloc(sizeof(bitmask)*frames.x*frames.y);
      if(bmask==NULL) return;

      for(n=0; n<(frames.x*frames.y); n++)
      {
        frame=TO_SFXP(n);
        CalcFrame();

        bmask[n]=MakeBitMask(surface,srcrect);
      }

      SetFlags(SPRITE_OWNBITMASK);

      frame=0;
      CalcFrame();
    }
  }
  else
  {
    bmask=NULL;
    ClearFlags(SPRITE_OWNBITMASK);
  }
}

void Sprite::Init_Layers(Sint16 layer)
{
  drawlayer=layer;
}

Sprite::~Sprite()
{
  int n=-1;
  
  if((bmask!=NULL)&&OwnBitmask())
  {
    for(n=0; n<(frames.x*frames.y); n++)
    {
      if(bmask[n]!=NULL)
      {
        bitmask_free(bmask[n]);
        bmask[n]=NULL;
      }
    }
    free(bmask);
    bmask=NULL;
  }
  
  if((surface!=NULL)&&OwnSurface())
  {
    SDL_FreeSurface(surface);
    surface=NULL;
  }
}

void Sprite::Draw(SDL_Surface *screen, Rect portion)
{
  Rect dstrect(pos.X(),pos.Y(),srcrect.w,srcrect.h);

  /* Both dstrect and portion are absolute coordinates in game space. */
  if(portion.Intersect(portion,dstrect))
  {
    Rect src=srcrect;
    Rect tmp=portion;
    tmp-=pos;

    /* Offset and reduce by X/Y difference */
    src.x+=tmp.x;
    src.y+=tmp.y;
    src.w-=tmp.x;
    src.h-=tmp.y;

    SDL_BlitSurface(surface,&src,screen,&portion);
  }  
}

void Sprite::Draw(SDL_Surface *screen)
{
  if(screen==NULL)  return;
  if(surface==NULL) return;

  Rect dstrect(pos.X(),pos.Y(),srcrect.w,srcrect.h);
  
  SDL_BlitSurface(surface,&srcrect,screen,&dstrect);
}

bitmask *Sprite::GetBitmask()
{
  if(bmask==NULL) return(NULL);
  
  int f=GetFrame()%(frames.x*frames.y);

  return(bmask[f]);
}

bitmask *MakeBitMask(SDL_Surface *surf, Rect rect)
{
  bitmask *bmask=NULL;  
  Uint32 colorkey=0;
  int x=-1,y=-1;
  
  /* Sanity checking */
  if(surf==NULL)                      return(NULL);
  if(!(surf->flags&SDL_SRCCOLORKEY))
  {
    fprintf(stderr,"MakeBitMask()-Can't make bitmask - no colorkey\n");
    return(NULL);
  }  
  if(rect.x+rect.w>surf->w)           return(NULL);
  else if(rect.y+rect.h>surf->h)      return(NULL);
  /* Get the color key */
  colorkey=surf->format->colorkey;

  bmask=bitmask_create(rect.w,rect.h);
  if(bmask==NULL) return(NULL);

  SDL_LockSurface(surf);
  
  for(y=0; y<rect.h; y++)
  {
    for(x=0; x<rect.w; x++)
    {
      Uint32 pixel=getpixel(surf,x+rect.x,y+rect.y);
      if(pixel==colorkey) /* Transparent - doesn't collide */
        bitmask_clearbit(bmask,x,y);
      else  /* Opaque - collides */
        bitmask_setbit(bmask,x,y);
    }
  }

  SDL_UnlockSurface(surf);

  return(bmask);
}

SDL_Surface *LoadConvertBMP(const char *fname, Uint8 tr, Uint8 tg, Uint8 tb)
{
  SDL_Surface *s1=NULL,*s2=NULL;

  if(fname==NULL) return(NULL);

#ifdef USE_SDL_IMAGE
  s1=IMG_Load(fname);
#else
  s1=SDL_LoadBMP(fname);
#endif

  if(s1==NULL) return(NULL);
  s2=SDL_DisplayFormat(s1); /* Convert to display format  */
  
  if(s2!=NULL)  /* If converted, free the old copy */
  {
    SDL_FreeSurface(s1);
    s1=NULL;
  }
  else  /* If not converted, print warning and keep the old copy  */
  {
    fprintf(stderr,"LoadConvertBMP() - couldn't convert\n"
                   "\"%s\"\n"
                   "to display format\n\n",fname);
    s2=s1;
    s1=NULL;
  }

  if(s2==NULL)
  {
    fprintf(stderr,"LoadConvertBmp() - couldn't load %s\n",fname);
    return(NULL);
  }
  else
  {
    SDL_SetColorKey(s2,SDL_SRCCOLORKEY,SDL_MapRGB(s2->format,tr,tg,tb));
    return(s2);
  }
}

---