spriteloader.cpp

Go to the documentation of this file.

/***************************************************************************
                          spriteloader.cpp  -  description
                             -------------------
    begin                : Thu Apr 10 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 <stdio.h>
#include <ctype.h>
#include "toyparse.h"
#include "sprite.h"
#include "spriteloader.h"

extern "C" int isblankstr(const char *str);

const char *Type_Param[]  ={  "IMAGE"       ,
                              "FRAMES"      ,
                              "FRAMERATE"   ,
                              "DRAWLAYER"   ,
                              "COLLAYER"    ,
                              "TRANSCOLOR"  ,
                              "BITMASK"     ,
                              NULL            };
const char *Type_Comment[]={ "#", "#%s", NULL};                              
const char *Type_Integer[]={  "%u",   NULL    };
const char *Type_String[] ={  "\"%s", NULL    };
const char **Types[]      ={  Type_Comment  ,
                              Type_Param    ,
                              Type_Integer  ,
                              Type_String   ,
                              NULL            };

typedef enum SpriteLoaderTypes
{
  SLT_COMMENT = 0 ,
  SLT_PARAM       ,
  SLT_INTEGER     ,
  SLT_STRING
} SpriteLoaderTypes;

typedef enum SpriteParam
{
  SP_IMAGE=0    ,
  SP_FRAME      ,
  SP_FRAMERATE  ,
  SP_DRAWLAYER  ,
  SP_COLLAYER   ,
  SP_TRANSCOLOR ,
  SP_BITMASK  
} SpriteParam;

SpriteLoader::SpriteLoader()
{
  r=b=244;
  g=0;
  xframes=yframes=0;
  framerate=0;
  bmask=NULL;
  image=NULL;
  drawlayer=colindex=colmask=0;
  good=loadbitmask=false;
  imagename[0]='\0';
}

bool SpriteLoader::ProcessLine(const char *buf)
{
  TokenType *tokens=NULL;

  if(isblankstr(buf))
    return(true);

  tokens=LineToTypes(buf,Types);
  if(tokens==NULL)
    return(true);

  switch(tokens[0].type)
  {
  case SLT_PARAM:
    switch(tokens[0].subtype)
    {
    int val;
    case SP_BITMASK:
      loadbitmask=true;
      break;
      
    case SP_TRANSCOLOR:
      if(CheckLineSyntax(tokens+1,SLT_INTEGER,-1,SLT_INTEGER,-1,
                                  SLT_INTEGER,-1,TYPE_ENDCLOSE)<0)
        return(false);

      if(sscanf(tokens[1].token,"%d",&r)!=1) return(false);
      if(sscanf(tokens[2].token,"%d",&g)!=1) return(false);
      if(sscanf(tokens[3].token,"%d",&b)!=1) return(false);
      
      r&=0xff;
      g&=0xff;
      b&=0xff;
      break;
      
    case SP_DRAWLAYER:
      if(CheckLineSyntax(tokens+1,SLT_INTEGER,-1,TYPE_ENDCLOSE)<0)
        return(false);

      if(sscanf(tokens[1].token,"%d",&drawlayer)!=1) return(false);        
      break;
      
    case SP_COLLAYER:
      if(CheckLineSyntax(tokens+1,SLT_INTEGER,-1,SLT_INTEGER,-1,TYPE_ENDOPEN)<0)
        return(false);
      
      if(sscanf(tokens[1].token,"%d",&colindex)!=1) return(false);

      colindex=COL_LAYER(colindex);
      
      for(val=2; tokens[val].token!=NULL; val++)
      {
        int layer=0;
        if(sscanf(tokens[val].token,"%d",&layer)!=1)  return(false);
        colmask|=COL_LAYER(layer);
      }

      colindex&=0xff;
      break;
      
    case SP_FRAMERATE:
      if(CheckLineSyntax(tokens+1,SLT_INTEGER,-1,TYPE_ENDCLOSE)<0)
        return(false);
      
      if(sscanf(tokens[1].token,"%d",&framerate)!=1)  return false;
            
      break;

    case SP_IMAGE:
      if(CheckLineSyntax(tokens+1,SLT_STRING,-1,TYPE_ENDCLOSE)<0)
        return(false);

      if(sscanf(tokens[1].token+1,"%s",imagename)!=1) return false;
      break;
      
    case SP_FRAME:
      if(CheckLineSyntax(tokens+1,SLT_INTEGER,-1,SLT_INTEGER,-1,TYPE_ENDCLOSE)<0)
        return(false);

      if(sscanf(tokens[1].token,"%d",&xframes)!=1) return false;
      if(sscanf(tokens[2].token,"%d",&yframes)!=1) return false;
      break;

    default:
      return(false);
      break;
    }
    break;

  case SLT_COMMENT:
    break;

  default:
    return(false);
    break;
  }

  return(true);
}

SpriteLoader::SpriteLoader(const char *fname, const char *path)
{
  r=b=244;
  g=0;
  xframes=yframes=0;
  framerate=0;
  bmask=NULL;
  image=NULL;
  drawlayer=colindex=colmask=0;
  good=loadbitmask=false;
  imagename[0]='\0';
  
  if(!SDL_WasInit(SDL_INIT_VIDEO))
  {
    if(SDL_Init(SDL_INIT_VIDEO)<0)
    {
      fprintf(stderr,"SpriteLoader::SpriteLoader(\"%s\",\"%s\")\n",fname,path);
      fprintf(stderr,"Couldn't initialize SDL video subsystem\n");
      return;
    }    
  }
  
  Load(fname,path);
}
SpriteLoader::~SpriteLoader()
{
  Reset();
}

bool SpriteLoader::Good()
{
  return(good);
}

Sprite *SpriteLoader::GetSprite(Sprite *sprite)
{  
  if(!Good())
    return(NULL);
  
  if(sprite==NULL)
  {
    sprite=new Sprite();
    sprite->SetFlags(SPRITE_DELETEABLE);    
  }  
  
  sprite->Init_Surface(image,false);
  sprite->Init_Layers(drawlayer);  
  sprite->Init_Collision(colindex,colmask);
  sprite->Init_Frames(xframes,yframes);
  sprite->Init_Bitmask(loadbitmask,bmask);
  sprite->SetFrameRate(framerate);
  
  return(sprite);
}

extern "C" int isblankstr(const char *str)
{
  int n=-1;

  if(str==NULL) return(1);

  for(n=0; str[n]!='\0'; n++)
  {
    if(!isspace(str[n]))
    {
      return(0);
    }
  }

  return(1);
}

bool SpriteLoader::Load(const char *fname, const char *path)
{
  char buf[300];
  int line=0;
  FILE *fp=NULL;
  buf[0]='\0';

  Reset();

  SprMakePath(fname,path,buf);
  
  /* Attempt to open configuration file */
  fp=fopen(buf,"r");
  if(fp==NULL)
  {
    fprintf(stderr,"SpriteLoader::Load() - couldn't open \"%s\"\n",buf);
    return(false);
  }

  buf[0]='\0';  /* Clear buffer */

  while((fgets(buf,299,fp)!=NULL)&&(!feof(fp)))
  {
    line++;
    if(!ProcessLine(buf))
      fprintf(stderr,"Syntax error in line %d:  %s",line,buf);

    buf[0]='\0';
  }

  /* Minimum required parameter is image */
  if(!isblankstr(imagename))
  {
    char buf[300];
    SprMakePath(imagename,path,buf);
    image=LoadConvertBMP(buf,r,g,b);
        
    if(image==NULL)
    {
      fprintf(stderr,"Error!  Can't load %s\n",imagename);
      good=false;
      return(false);
    }
    
    good=true;

    if(loadbitmask)
    {
      int n=-1;
      Rect r(0,0,image->w/xframes,image->h/yframes);
            
      bmask=(bitmask **)malloc(sizeof(bitmask *)*xframes*yframes);
      for(n=0; n<(xframes*yframes); n++)
      {
        int xf=(n%xframes);
        int yf=(n/xframes)%yframes;
        r.x=xf*r.w;
        r.y=yf*r.h;
                
        bmask[n]=MakeBitMask(image,r);
        
        if(bmask[n]==NULL)
          fprintf(stderr,"Warning!  Can't create bitmask for %s\n",imagename);
          
      }
    }
    else
    {
      bmask=NULL;
    }
  }  
  else
  {
    fprintf(stderr,"Error!  Can't load %s\n",fname);
    good=false;
  }

  return(good);
}

void SpriteLoader::Reset()
{
  if(bmask!=NULL) /* Free collision bitmasks  */
  {
    int n;
    for(n=0; n<(xframes*yframes); n++)
    {
      if(bmask[n]!=NULL)
      {
        bitmask_free(bmask[n]);
        bmask[n]=NULL;
      }
    }
    free(bmask);
    bmask=NULL;
  }

  if(image!=NULL) /* Free image  */
  {
    SDL_FreeSurface(image);
    image=NULL;
  }
  /* Resets variables */
  r           =255;
  g           =  0;
  b           =255;
  xframes     =  1;
  yframes     =  1;
  drawlayer   =  0;
  colindex    =  0;
  colmask     =  0;
  framerate   =  0;
  imagename[0]='\0';
  good        =false;
  loadbitmask =false;
}

char lastchar(const char *str)
{
  int len=0;
  if(str==NULL) return('\0');

  len=strlen(str);
  if(len==0) return('\0');
  else return(str[len-1]);  
}

char * SprMakePath(const char *filename, const char *path, char *buf)
{
  char *slash=SLASH;
  if(buf==NULL) return(NULL);
  buf[0]='\0';

  if(path!=NULL)
  if(strlen(path))
  {
    strcpy(buf,path);
    if(lastchar(path)!=slash[0])  strcat(buf,SLASH);    
  }

  if(filename!=NULL)  strcat(buf,filename);
  
  return(buf);    
}

---