Back to Evolution Project page

---

                 

---

sprite.c

#include "sprite.h"
#include <string.h>


#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

 
int get_unit_from_pixelx (int pixel) {
  return (pixel / UNIT_WIDTH);
}

int get_unit_from_pixely (int pixel) {
  return (pixel / UNIT_HEIGHT);
}

void read_sprite_from_file(FILE* f, sprite* sp, gchar *sp_dir) {
  char buffer[1100];

  fgets(buffer, 300, f);
  buffer[strlen(buffer)-1]='\0';
  g_strstrip(buffer);
  if (0==g_strcasecmp(buffer, SPRITE_TYPE_GROUND_STRING)) 
    sp->type = SPRITE_TYPE_GROUND;
  else if (0==g_strcasecmp(buffer, SPRITE_TYPE_SPRITE_STRING)) 
    sp->type = SPRITE_TYPE_SPRITE;
  else 
    sp->type = SPRITE_TYPE_NONE;

  fgets(buffer, 300, f);
  buffer[strlen(buffer)-1]='\0';
  strcpy(sp->name, buffer); 

  g_strchug(sp->name);
  g_strchomp(sp->name);

  fgets(buffer, 1000, f);
  buffer[strlen(buffer)-1]='\0';
  strcpy(sp->description, buffer);
  fgets(buffer, 10, f);
  sp->sizex = atoi(buffer);
  fgets(buffer, 10, f);
  sp->sizey = atoi(buffer);
 
  //Reads the pixmap from file
  strcpy(sp->filename, sp_dir);
  strcat(sp->filename, "xpm/");
  strcat(sp->filename, sp->name);
  strcat(sp->filename, ".xpm");
  
  strcpy(sp->filename_tga, sp_dir);
  strcat(sp->filename_tga, "tga/");
  strcat(sp->filename_tga, sp->name);
  strcat(sp->filename_tga, ".xpm.tga");
  
  sp->width_pixels  = sp->sizex * UNIT_WIDTH;
  sp->height_pixels = sp->sizey * UNIT_HEIGHT;
  

  //  printf("'%s'\n", filename);
  return;
}

void print_sprite_info(sprite* sp) {
  printf("Sprite name:'%s'\nSprite description:'%s'\nSize:%d %d \nId:%d Type: %d\nImage filename:%s\n\n", sp->name, sp->description, sp->sizex, sp->sizey, sp->id, sp->type, sp->filename);
}

void read_all_sprites(char* filename, gchar *sp_dir) {
  FILE* f;
  sprite* sp;
  int i, j;
  i=g_list_length(sprite_list)+1;   //Start from 1...
  j=g_list_length(sprite_list_sp)+1;  //Start from 1...
  f = fopen(filename, "r");
  while ((!feof(f))) {
    sp = (sprite *) malloc(sizeof(sprite)); //Alloc memory for the sprite
    read_sprite_from_file(f, sp, sp_dir);
    if ((sp->sizex==0) || (sp->sizey==0)) {
      free (sp);
      break;
    }
    if (sp->type == SPRITE_TYPE_GROUND) {
      sp->id=i;
      i++;
      sprite_list =  g_list_prepend(sprite_list, sp);
    }
    else if (sp->type == SPRITE_TYPE_SPRITE) {
      sp->id=j;
      j++;
      sprite_list_sp =  g_list_prepend(sprite_list_sp, sp);
    } else {
      g_print("Invalid sprite type: %s (type %d)\n", sp->description, sp->type);
    }
    print_sprite_info(sp);
  }
  fclose(f);
  return;
}

sprite *get_sprite_from_id(GList *splist, int id) {
  GList *last, *current;
   
  last =    g_list_first(splist);
  current = g_list_last (splist);

  if (last) {
    do {
      if ((((sprite *)(current->data))->id)==id)
    return ((sprite *)(current->data));
      if (current==last) break;
      current = current->prev;
    } while (1);    
  }
  return NULL;
}

sprite_unit *sprite_unit_add(GList **unit_list, sprite *sp, int x, int y) {
  sprite_unit *sp_unit;
  
  sp_unit = g_malloc0(sizeof(sprite_unit));
  sp_unit->sprite = sp;
  sp_unit->unitx  = x;
  sp_unit->unity  = y;
  //  sp_unit->id     = g_list_length(*unit_list);
  *unit_list =  g_list_prepend(*unit_list, sp_unit);  
  return sp_unit;
}

rect add_sprite_on_unit(sprite *sp, int x, int y) {
  int i, j;
  sprite_unit *sp_unit;
  unit *unitmap;
  GList **unit_list=NULL;
  rect r1;
  r1.x = 0;
  r1.y=0;
  r1.sx = 0;
  r1.sy = 0;

  if ((x<0) || (y<0) || (x>=level_width) || (y>=level_height) ) {
//    g_print ("There isn't unit (%d,%d)\n ", x, y);
    return r1; 
  }
  if (!sp) {
    g_print ("There isn't sprite to place on unit (%d, %d)!!! \n ", x, y);
    return r1;
  }
  if (sp->type==SPRITE_TYPE_SPRITE) {
    if (!can_place_sprite_on_unit(sp, x, y))
      return r1;
  } else 
    delete_sprite_on_unit(level, x, y);
  
    
  if (sp->type == SPRITE_TYPE_GROUND) {
    unitmap = level;
    unit_list = &sp_unit_list;
  }
  else if (sp->type == SPRITE_TYPE_SPRITE) {
    unitmap = levelsp;
    unit_list = &sp_unit_list_sp;
  } 
  else return r1;

  sp_unit = sprite_unit_add(unit_list, sp, x, y);

  for (i=x; i<x+sp->sizex; i++)
    for (j=y; j<y+sp->sizey; j++) {
      unitmap[(j*level_width)+i].sprite_id = sp->id;
      unitmap[(j*level_width)+i].draw_here = 0;
      unitmap[(j*level_width)+i].sp_unit = sp_unit;
      //      unitmap[(j*level_width)+i].unit_id = sp_unit->id;
    }
  unitmap[(y*level_width)+x].draw_here = 1;
  r1.x = x;
  r1.y=y;
  r1.sx = x+sp->sizex;
  r1.sy = y+sp->sizey;
  return r1;
}


int can_place_sprite_on_unit(sprite *sp, int x, int y) {
  int i, j;
  unit *unitmap;

  if (sp->type==SPRITE_TYPE_GROUND)
    unitmap = level;
  else if (sp->type==SPRITE_TYPE_SPRITE)
    unitmap = levelsp;
  else 
    return 0;
  
  for (i=x; i<x+sp->sizex; i++)
    for (j=y; j<y+sp->sizey; j++)
      if (unitmap[(j*level_width)+i].sp_unit) 
    return 0;

  return 1;
}

rect delete_sprite_on_unit(unit *unitmap, int x, int y){
  int i, j, x1, y1, sizex, sizey;
  sprite_unit *sp_unit;
  rect r1;
  r1.x = 0;
  r1.y=0;
  r1.sx = 0;
  r1.sy = 0;

  sp_unit = unitmap[(y*level_height)+x].sp_unit;
  if (!sp_unit) return r1;

  x1 = sp_unit->unitx;
  y1 = sp_unit->unity;
  sizex = sp_unit->sprite->sizex;
  sizey = sp_unit->sprite->sizey;
  for (i=x1; i<x1+sizex; i++)
    for (j=y1; j<y1+sizey; j++){
      unitmap[(j*level_height)+i].sprite_id = 0;
      unitmap[(j*level_height)+i].draw_here = 0;
      //      unitmap[(j*level_height)+i].unit_id = 0;
      unitmap[(j*level_height)+i].sp_unit = NULL;
    }
  //  g_print("(%d,%d) (%d,%d)\n", x1, y1, sizex, sizey);
  delete_sprite_unit(sp_unit);
  r1.x = x1;
  r1.y=y1;
  r1.sx = x1+sp_unit->sprite->sizex;
  r1.sy = y1+sp_unit->sprite->sizey;
  return r1;
}

void delete_sprite_unit(sprite_unit *sp_unit) {
  GList **list_of_units;
  if (!sp_unit) {
    g_print("?!? There isn't sprite_unit to delete....\n");
    return;
  }
  if (sp_unit->sprite->type == SPRITE_TYPE_GROUND)
    list_of_units = &sp_unit_list;
  else if (sp_unit->sprite->type == SPRITE_TYPE_SPRITE)
    list_of_units = &sp_unit_list_sp;
  else
    return;

  *list_of_units = g_list_remove(*list_of_units, sp_unit);
  //  g_print("%p \n", sp_unit);
  g_free(sp_unit);
}

int save_level_to_file(FILE *f){
  file_header fh;
  GList *last, *current;
  sprite_unit *sp_unit=NULL;

  fh.major_version = CURRENT_FILE_MAJORVERSION;
  fh.minor_version = CURRENT_FILE_MINORVERSION;
  fh.level_width = level_width;
  fh.level_height = level_height;
  fh.num_sprites_on_screen = g_list_length(sp_unit_list_sp);
  fh.num_grounds_on_screen = g_list_length(sp_unit_list);

  g_print("%ld %ld\n", fh.num_grounds_on_screen, fh.num_sprites_on_screen);

  //Writes header
  fwrite(&fh, sizeof(fh), 1, f);

  update_list_of_units();

  //Writes grounds map
  //  fwrite(level, sizeof(unit), level_width*level_height, f);

  //Writes sprites map
  //  fwrite(levelsp, sizeof(unit), level_width*level_height, f);

  //Writes each sprite_unit
  //grounds
  last = g_list_first(sp_unit_list);
  current = g_list_last(sp_unit_list);
  if (last) {
    do {
      sp_unit = (sprite_unit *)(current->data);
      fwrite(sp_unit, sizeof(sprite_unit), 1, f);
      //      g_print("(%d,%d)\n",  sp_unit->unitx, sp_unit->unity);

      if (current==last) break;
      current = current->prev;
    } while (1);    
  }
  //sprites
  last = g_list_first(sp_unit_list_sp);
  current = g_list_last(sp_unit_list_sp);
  if (last) {
    do {
      sp_unit = (sprite_unit *)(current->data);
      fwrite(sp_unit, sizeof(sprite_unit), 1, f);
      g_print("spriteid: %d, on (%d, %d)\n", 
          levelsp[(sp_unit->unity*level_width)+sp_unit->unitx].sprite_id,
          sp_unit->unitx, sp_unit->unity); 

      if (current==last) break;
      current = current->prev;
    } while (1);    
  }
  

  return 1;
}


int open_level_from_file(FILE *f){
  file_header fh;
  sprite_unit sp_unit;
  int i;

  if (!fread(&fh, sizeof(fh), 1, f)) return 0;
  if ((fh.major_version != CURRENT_FILE_MAJORVERSION) || 
      (fh.minor_version |= CURRENT_FILE_MINORVERSION)) {
    g_print("Warning: Version of file differs from current file version supported!!\n");
  }
  level_width = fh.level_width;
  level_height = fh.level_height;
  resize_array_of_units();

  //Reads grounds map
  //  if (fread(level, sizeof(unit), level_width*level_height, f)!= (level_width*level_height)) return 0;

  //Reads sprites map
  //  if (fread(levelsp, sizeof(unit), level_width*level_height, f)!= (level_width*level_height)) return 0;


  resize_array_of_units();
  
  g_print("%ld %ld\n", fh.num_grounds_on_screen, fh.num_sprites_on_screen);

  //Now, read each unit screen
  //grounds...
  for (i=0; i<fh.num_grounds_on_screen; i++) {
    if (!fread(&sp_unit, sizeof(sprite_unit), 1, f)) return 0;   
    add_sprite_on_unit(
               get_sprite_from_id(sprite_list, 
                      sp_unit.sprite_id),
               sp_unit.unitx, sp_unit.unity); 
  }
  //sprites...
  for (i=0; i<fh.num_sprites_on_screen; i++) {
    if (!fread(&sp_unit, sizeof(sprite_unit), 1, f)) return 0;   
    add_sprite_on_unit(
               get_sprite_from_id(sprite_list_sp, 
                      sp_unit.sprite_id),
               sp_unit.unitx, sp_unit.unity); 
  }

  //  g_print("%p %d , %p %d\n", sp_unit_list, g_list_length(sp_unit_list), sp_unit_list_sp, g_list_length(sp_unit_list_sp));
  return 1;
}

void resize_array_of_units(void) {
  int i, j;
  GList *last, *current, *next;
  //Initialize array of units...
  if (level) g_free (level);
  level = g_malloc0(level_width * level_height * sizeof(unit));
  if (levelsp) g_free (levelsp);
  levelsp = g_malloc0(level_width * level_height * sizeof(unit));


  if (sp_unit_list) {
    //Clear all items of list and, after, free the list...
    last = g_list_first(sp_unit_list);
    current = g_list_last(sp_unit_list);
    if (last) {
      do {
    if (sp_unit_list==NULL) break;
    next = current->prev;
    sp_unit_list = g_list_remove(sp_unit_list, current->data);
    g_free(current->data);
    current=next;
      } while (1);    
    }    
    g_list_free(sp_unit_list);
    sp_unit_list = NULL;
  }
  if (sp_unit_list_sp) {
    //Clear all items of list and, after, free the list...
    last = g_list_first(sp_unit_list_sp);
    current = g_list_last(sp_unit_list_sp);
    if (last) {
      do {
    if (sp_unit_list_sp==NULL) break;
    next = current->prev;
    sp_unit_list_sp = g_list_remove(sp_unit_list_sp, current->data);
    g_free(current->data);
    current=next;
      } while (1);    
    }    
    g_list_free(sp_unit_list_sp);
    sp_unit_list_sp = NULL;
  }
  //Initialize unit map
  for (i=0; i<level_width; i++)
    for (j=0; j<level_height; j++) {
      level[(j*level_width)+i].sprite_id = 1; //First ground
      level[(j*level_width)+i].draw_here = 1; 
      level[(j*level_width)+i].sp_unit = sprite_unit_add( &sp_unit_list,
                              get_sprite_from_id(sprite_list, 1) ,
                              i, j);
      //      level[(j*level_width)+i].unit_id = level[(j*level_width)+i].sp_unit->id;
      levelsp[(j*level_width)+i].sprite_id = 0;
      levelsp[(j*level_width)+i].draw_here = 0;
      levelsp[(j*level_width)+i].sp_unit = NULL;
      //      levelsp[(j*level_width)+i].unit_id = 0;
    }  
}

void update_list_of_units(void) {
  //Updates the list of unit on the screen...
  GList *last, *current;
  sprite_unit *sp_unit;
  int i, j;
  
  //On grounds
  last = g_list_first(sp_unit_list);
  current = g_list_last(sp_unit_list);
  i = 0; //Ids init with 0...
  if (last) {
    do {
      sp_unit = (sprite_unit *)(current->data);
      //      sp_unit->id = i++;
      
      if (current==last) break;
      current = current->prev;
    } while (1);    
  }

  for (i=0; i<level_width; i++)
    for (j=0; j<level_height; j++)
      if (level[(j*level_height)+i].sp_unit) {
    //  level[(j*level_height)+i].unit_id = level[(j*level_height)+i].sp_unit->id;
    level[(j*level_height)+i].sp_unit->sprite_id = level[(j*level_height)+i].sp_unit->sprite->id;
      } else {
    //  level[(j*level_height)+i].unit_id = -1;
      }

  //On sprites...
  last = g_list_first(sp_unit_list_sp);
  current = g_list_last(sp_unit_list_sp);
  i = 0; //Ids init with 0...
  if (last) {
    do {
      sp_unit = (sprite_unit *)(current->data);
      //      sp_unit->id = i++;
      
      if (current==last) break;
      current = current->prev;
    } while (1);    
  }
  
  for (i=0; i<level_width; i++)
    for (j=0; j<level_height; j++)
      if (levelsp[(j*level_height)+i].sp_unit) {
    //  levelsp[(j*level_height)+i].unit_id = levelsp[(j*level_height)+i].sp_unit->id;
    levelsp[(j*level_height)+i].sp_unit->sprite_id = levelsp[(j*level_height)+i].sp_unit->sprite->id;
      } else {
    //  levelsp[(j*level_height)+i].unit_id = -1;
      }
}


int file_exists(gchar *fn) { //Returns 1 if the current file exists...
  FILE *f;
  f=fopen(fn, "rb");
  if ( f) {
    fclose(f);
    return 1;
  }
  return 0;
}

void read_config(void) {
  FILE *f;
  gchar rcfile[1000];
  //Read the configfile
  f = fopen(CONFIG_FILENAME, "r");
  fgets(sprites_dir, 900, f);
  fclose(f);
  sprites_dir[strlen(sprites_dir)-1]='\0';
  if (sprites_dir[strlen(sprites_dir)-1]!='/')
    strcat(sprites_dir, "/");

  strcpy(sprites_dir_home, getenv("HOME"));
  sprites_dir_home[strlen(sprites_dir_home)]='\0';
  if (sprites_dir_home[strlen(sprites_dir_home)-1]!='/')
    strcat(sprites_dir_home, "/");
  strcat(sprites_dir_home, ".evolution/");
  
  strcpy(rcfile, sprites_dir);
  strcat(rcfile, LEVELEDITORFILE);
  printf("resource file:'%s'\n\n", rcfile);
    // Read all sprites from rcfile
  if (file_exists(rcfile)) read_all_sprites(rcfile, sprites_dir);

  strcpy(rcfile, sprites_dir_home);
  strcat(rcfile, LEVELEDITORFILE);
  printf("resource file on home directory:'%s'\n\n", rcfile);
  // Read all sprites from rcfile
  if (file_exists(rcfile)) read_all_sprites(rcfile, sprites_dir_home);  

}



#ifdef __cplusplus
}
#endif /* __cplusplus */

void init_variables(void) {
  level=NULL;
  level_width = level_height = 0;
  sprite_list = sprite_list_sp = NULL;
  sp_unit_list = NULL;
  sp_unit_list_sp = NULL;
}

---