spritemanager.cpp

Go to the documentation of this file.

/***************************************************************************
                          spritemanager.cpp  -  description
                             -------------------
    begin                : Fri Mar 7 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.                                   *
 *                                                                         *
 ***************************************************************************/
#include <string.h>
#include <stdlib.h>
#include "spritemanager.h"
#include "ticktimer.h"
#include "spriteloader.h"


int SpriteManager::Event(int code, void *data1, void *data2)
{ return(0); }

void SpriteManager::Handler(SDL_Event *event)
{ }

void SpriteManager::Idle()
{ }


SpriteManager::SpriteManager(Uint16 w, Uint16 h, Uint8 depth, Uint32 vflags)
{
  flag=SM_TOTALREDRAW|SM_OWNBG;  

  lock=SDL_CreateMutex();

  if(!SDL_WasInit(SDL_INIT_VIDEO))
    if(SDL_InitSubSystem(SDL_INIT_VIDEO)<0)
    {
      fprintf(stderr,"Warning, couldn't initialize SDL video\n");
    }

  if(vflags&SDL_DOUBLEBUF)
  {
    fprintf(stderr,"SDL_DOUBLEBUF flag detected, using fullscreen flips\n");
    flag|=SM_DOUBLEBUF;
  }

  screen=SDL_SetVideoMode(w,h,depth,SDL_ANYFORMAT|vflags);

  if(screen==NULL)
  {
    fprintf(stderr,"SpriteManager::SpriteManager(%d,%d,%d,%d)\n",w,h,depth,vflags);
    fprintf(stderr,"Warning - can't set video mode!\n");
  }

  bg=SDL_DisplayFormat(screen);

  if(bg==NULL)
  {
    fprintf(stderr,"Error - can't create background!\n");
  }
}

void SpriteManager::DrawOnBG(SDL_Surface *src, SDL_Rect *srcrect, SDL_Rect *destrect)
{
  Lock();

  SDL_BlitSurface(src,srcrect,bg,destrect);

  flag|=SM_TOTALREDRAW;

  Unlock();
}

void SpriteManager::SendEvent(int code, void *data1, void *data2)
{
  Sprite *spr=sprites.Head();

  while(spr!=NULL)
  {
    spr->Event(code,data1,data2);
    spr=spr->next;
  }
}

SMRun_Return SpriteManager::Run(Sint32 frametick, Sint32 gametick)
{
  TickTimer frame,game;
  bool drawn=false;

  flag|=SM_RUNNING;
  frame.Reset();
  game.Reset();

  if((frametick<=0)||(gametick<=0))
    return(SMRUN_TIMESTEP);

  while(flag&SM_RUNNING)
  {
    SDL_Event event;
    while(SDL_PollEvent(&event))
      switch(event.type)
      {
      case SDL_QUIT:  /* Break the game loop on SDL_QUIT  */
        flag&=~SM_RUNNING;
        break;

      case SDL_USEREVENT:
        /* Pass SDL_USEREVENTs along to the virtual Event function  */
        if(!Event(event.user.code,event.user.data1,event.user.data2))
        {
          /* If Event() returns zero, pass the event to every sprite  */
          SendEvent(event.user.code, event.user.data1, event.user.data2);
        }
        break;

      default:  /* Pass any other events onto the virtual handler function */
        Handler(&event);
        break;
      }

    if(game>=gametick)
    { /* If we can't process game ticks fast enough
         to keep up with realtime, we've got ourselves
         an infinite loop here..  need max_iterations
         to break out, in worst case scenario.        */
      int max_iterations=(game/gametick)*2;
      int iterations=0;
      drawn=false;
      
      while(game>=gametick)
      { 
        if(iterations>max_iterations) /* Can't keep up with the timer! */
          return(SMRUN_TIMESTEP);
        
        if(!Paused()) Move(gametick);
        
        game-=gametick;
        iterations++;
      }
    }
    else if(frame>=frametick)
    {
      if(!drawn)
      {
        drawn=true;
        Draw();
        Update();
        Preserve();
      }      
      frame-=frametick;
    }
    else
    {
      Idle();
      SDL_Delay(10);
    }
  }
  
  return(SMRUN_OK);
}

SMRun_Return SpriteManager::Run(Sint32 frametick)
{
  TickTimer timer;
  flag|=SM_RUNNING;  

  if(frametick<=0)
    return(SMRUN_TIMESTEP);

  timer.Reset();
  /* Run the event loop until SDL_QUIT or enter/return keypress */
  while(flag&SM_RUNNING)
  {
    SDL_Event event;

    while(SDL_PollEvent(&event))/* SDL event loop */
    switch(event.type)
    {
    case SDL_QUIT:  /* Break the game loop on SDL_QUIT  */
      flag&=~SM_RUNNING;
      break;

    case SDL_USEREVENT:
      /* Pass SDL_USEREVENTs along to the virtual Event function  */
      if(!Event(event.user.code,event.user.data1,event.user.data2))
      {
        /* If Event() returns zero, pass the event to every sprite  */
        SendEvent(event.user.code, event.user.data1, event.user.data2);
      }
      break;

    default:  /* Pass any other events onto the virtual handler function */
      Handler(&event);
      break;
    }

    /* If the screen needs updating */
    if(timer>=frametick)
    {
      Draw();
      Update();

      if(!Paused()) /* Don't call Move() while paused */
      {
        Preserve();
        while(timer>=frametick)
        {        
          Move(frametick);
          timer-=frametick;
        }
      }
    }
    else  /* Screen doesn't need updating */
    {
      Idle();         /* Call the virtual Idle handler  */
      SDL_Delay(10);  /* give time to other processes */
    }
  }

  return(SMRUN_OK);
}

void SpriteManager::Preserve()
{
  Sprite *spr=sprites.Head();

  while(spr!=NULL)
  {
    spr->Preserve();
    spr=spr->next;
  }
}

SpriteManager::SpriteManager(Uint16 flags,SDL_Surface *screenin,
                             const char *bgnd)
 :rects(MAX_RECTS)
{
  flag=flags|SM_TOTALREDRAW|SM_OWNBG;

  lock=SDL_CreateMutex();

  if(screenin==NULL)
  {
    screen=SDL_GetVideoSurface();
    if(screen==NULL)
    {
      fprintf(stderr,"Couldn't get video surface!\n");
          exit(1);
    }

    if(bgnd==NULL)
    {
      bg=SDL_DisplayFormat(screen);
    }
    else
    {
      bg=LoadConvertBMP(bgnd);
    }
  }
  else
  {
    screen=screenin;

    if(bgnd==NULL)
    {
      bg=SDL_DisplayFormat(screen);
    }
    else
    {
      bg=LoadConvertBMP(bgnd);
    }
  }
}

bool SpriteManager::AddSprite(Sprite *spr)
{
  bool retval;

  Lock();
  retval=sprites.Insert(spr);
  Unlock();

  return(retval);
}

bool SpriteManager::RemoveSprite(Sprite *spr)
{
  bool retval;

  Lock();
  retval=sprites.Extract(spr);
  Unlock();

  return(retval);
}

void SpriteManager::Draw()
{
  /* Redraw whole screen */
  if(flag&(SM_TOTALREDRAW|SM_DOUBLEBUF))
  {
    flag&=~SM_TOTALREDRAW;      /* Turn off total-redraw flag */
    SimpleBlit();               /* Draw */
  }
  else
  {
    QuadBlit();
  }
}

void SpriteManager::Move(Sint32 dtick)
{
  Sprite *spr=NULL;

  Lock(); /* Lock the mutex to prevent simultaneous access  */

  spr=sprites.Head();
  while(spr!=NULL)
  {
    if(spr->Expired())
    {
      spr=spr->next;
      continue;
    }
    else if(spr->New())
    { /*  If the sprite's new, clear the Wait flag
          so it will be drawn next frame.           */
      spr->ClearFlags(SPRITE_WAIT);
      /*  Set the MOVED flag so it will be checked for
          collisions against all sprites at least once. */
      spr->SetFlags(SPRITE_MOVED);
    }
    
    spr->Update(dtick);     /* Call the virtual update function */

    spr=spr->next;  /* Proceed to next sprite in list */
  }

  spr=sprites.Head();
  while(spr!=NULL)  /* Loop through every sprite in list  */
  {    
    Sprite *spr2=spr->next; /* Get next sprite in list  */

    if(spr->Expired())
    {
      /* Ignore collisions with dead sprites */
    }    
    else if(spr->Moved())  /* Test against moving and unmoving sprites */
    {

      while(spr2!=NULL) /* Loop through portion of list after spr */
      {
        if(spr2->Expired())
        {
          /* Ignore collisions with expired sprites */
        }
        else if(spr->CanCollide(spr2)) /* If the sprites collide */
        {
          /* Call their virtual collision handler functions */
          spr->OnCollide(  spr2,spr2->GetColIndex() );
          spr2->OnCollide( spr , spr->GetColIndex() );
        }

        spr2=spr2->next;  /* Advance to next sprite in inner loop */
      }
    }
    else /* Only test against moving sprites */
    {
      while(spr2!=NULL) /* Loop through portion of list after spr */
      {
        if(spr2->Expired())
        {
          /* Ignore collisions with expired sprites */
        }
        else if(spr2->Moved())
          if(spr->CanCollide(spr2)) /* If the sprites collide */
          {
            /* Call their virtual collision handler functions */
            spr->OnCollide(  spr2,spr2->GetColIndex() );
            spr2->OnCollide( spr , spr->GetColIndex() );
          }


        spr2=spr2->next;  /* Advance to next sprite in inner loop */
      }      
    }

    spr=spr->next;      /* Advance to next sprite in outer loop */
  }

  Unlock(); /*  Unlock the mutex to allow access to the manager */
}



SDL_Surface *SpriteManager::CheckOutBG()
{
  Lock();
  return(bg);
}
bool SpriteManager::CheckInBG(SDL_Surface *bg_in)
{
  if(bg_in==bg)
  {
    Unlock();
    return(true);
  }
  else
  {
    return(false);
  }
}



SpriteManager::~SpriteManager()
{
  Lock(); /* Lock mutex to prevent simultaneous access  */

  /* If the background is freeable */
  if((flag&SM_OWNBG)&&(bg!=NULL))
  {
    SDL_FreeSurface(bg);  /* Free the background surface */
  }
  
  SDL_DestroyMutex(lock); /* Destroy the mutex itself */
}

---