src/level.c

   1 //
   2 // C Implementation: level
   3 //
   4 // Description:
   5 //
   6 //
   7 // Author: Tobias Glaesser <tobi.web@gmx.de>, (C) 2003
   8 //
   9 // Copyright: See COPYING file that comes with this distribution
  10 //
  11 //
  12
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include "globals.h"
  17 #include "setup.h"
  18 #include "screen.h"
  19 #include "level.h"
  20 #include "physic.h"
  21
  22 texture_type img_bkgd, img_bkgd_tile[2][4], img_solid[4], img_brick[2];
  23
  24 void subset_init(st_subset* st_subset)
  25 {
  26   st_subset->title = NULL;
  27   st_subset->description = NULL;
  28   st_subset->levels = 0;
  29 }
  30
  31 void subset_load(st_subset* st_subset, char *subset)
  32 {
  33   FILE* fi;
  34   char filename[1024];
  35   char str[1024];
  36   int len,i;
  37
  38   st_subset->name = (char*) malloc(sizeof(char)*(strlen(subset)+1));
  39   strcpy(st_subset->name,subset);
  40
  41   snprintf(filename, 1024, "%s/levels/%s/info", st_dir, subset);
  42   if(!faccessible(filename))
  43     snprintf(filename, 1024, "%s/levels/%s/info", DATA_PREFIX, subset);
  44   if(faccessible(filename))
  45     {
  46       fi = fopen(filename, "r");
  47       if (fi == NULL)
  48         {
  49           perror(filename);
  50         }
  51
  52       /* Load title info: */
  53       fgets(str, 40, fi);
  54       st_subset->title = (char*) malloc(sizeof(char)*(strlen(str)+1));
  55       strcpy(st_subset->title, str);
  56
  57       /* Load the description: */
  58
  59       str[0] = '\0';
  60       st_subset->description = NULL;
  61       len = 0;
  62       while(fgets(str, 300, fi) != NULL)
  63         {
  64           len += strlen(str);
  65           if(st_subset->description == NULL)
  66             st_subset->description = (char*) calloc(len+1,sizeof(char));
  67           else
  68             st_subset->description = (char*) realloc(st_subset->description, sizeof(char) * (len+1));
  69           strcat(st_subset->description,str);
  70         }
  71       fclose(fi);
  72
  73       snprintf(str, 1024, "%s.png", filename);
  74       if(faccessible(str))
  75         {
  76           texture_load(&st_subset->image,str,IGNORE_ALPHA);
  77         }
  78       else
  79         {
  80           snprintf(filename, 1024, "%s/images/status/level-subset-info.png", DATA_PREFIX);
  81           texture_load(&st_subset->image,filename,IGNORE_ALPHA);
  82         }
  83     }
  84
  85   for(i=1; i != -1; ++i)
  86     {
  87       /* Get the number of levels in this subset */
  88       snprintf(filename, 1024, "%s/levels/%s/level%d.dat", st_dir, subset,i);
  89       if(!faccessible(filename))
  90         {
  91           snprintf(filename, 1024, "%s/levels/%s/level%d.dat", DATA_PREFIX, subset,i);
  92           if(!faccessible(filename))
  93             break;
  94         }
  95     }
  96     st_subset->levels = --i;
  97 }
  98
  99 void subset_free(st_subset* st_subset)
 100 {
 101   free(st_subset->title);
 102   free(st_subset->description);
 103   free(st_subset->name);
 104   texture_free(&st_subset->image);
 105   st_subset->levels = 0;
 106 }
 107
 108 /* Load data for this level: */
 109 /* Returns -1, if the loading of the level failed. */
 110 int level_load(st_level* plevel, char *subset, int level)
 111 {
 112   int y;
 113   FILE * fi;
 114   char str[80];
 115   char filename[1024];
 116   char * line;
 117
 118   /* Load data file: */
 119
 120   snprintf(filename, 1024, "%s/levels/%s/level%d.dat", st_dir, subset, level);
 121   if(!faccessible(filename))
 122     snprintf(filename, 1024, "%s/levels/%s/level%d.dat", DATA_PREFIX, subset, level);
 123   fi = fopen(filename, "r");
 124   if (fi == NULL)
 125     {
 126       perror(filename);
 127       return -1;
 128     }
 129
 130
 131   /* Load header info: */
 132
 133
 134   /* (Level title) */
 135   fgets(str, 20, fi);
 136   strcpy(plevel->name, str);
 137   plevel->name[strlen(plevel->name)-1] = '\0';
 138
 139   /* (Level theme) */
 140   fgets(str, 20, fi);
 141   strcpy(plevel->theme, str);
 142   plevel->theme[strlen(plevel->theme)-1] = '\0';
 143
 144
 145
 146   /* (Time to beat level) */
 147   fgets(str, 10, fi);
 148   plevel->time_left = atoi(str);
 149
 150   /* (Song file for this level) */
 151   fgets(str, sizeof(plevel->song_title), fi);
 152   strcpy(plevel->song_title, str);
 153   plevel->song_title[strlen(plevel->song_title)-1] = '\0';
 154
 155   /* (Level background image) */
 156   fgets(str, sizeof(plevel->bkgd_image), fi);
 157   strcpy(plevel->bkgd_image, str);
 158   plevel->bkgd_image[strlen(plevel->bkgd_image)-1] = '\0';
 159
 160   /* (Level background color) */
 161   fgets(str, 10, fi);
 162   plevel->bkgd_red = atoi(str);
 163   fgets(str, 10, fi);
 164   plevel->bkgd_green= atoi(str);
 165   fgets(str, 10, fi);
 166   plevel->bkgd_blue = atoi(str);
 167
 168   /* (Level width) */
 169   fgets(str, 10, fi);
 170   plevel->width = atoi(str);
 171
 172   /* (Level gravity) */
 173   fgets(str, 10, fi);
 174   plevel->gravity = atof(str);
 175
 176   /* Set the global gravity to the latest loaded level's gravity */
 177   gravity = plevel->gravity;
 178
 179   /* Allocate some space for the line-reading! */
 180
 181   line = (char *) malloc(sizeof(char) * (plevel->width + 5));
 182   if (line == NULL)
 183     {
 184       fprintf(stderr, "Couldn't allocate space to load level data!");
 185       fclose(fi);
 186       return -1;
 187     }
 188
 189
 190   /* Load the level lines: */
 191
 192   for (y = 0; y < 15; y++)
 193     {
 194       if(fgets(line, plevel->width + 5, fi) == NULL)
 195         {
 196           fprintf(stderr, "Level %s isn't complete!\n",plevel->name);
 197           free(line);
 198           fclose(fi);
 199           return -1;
 200         }
 201       line[strlen(line) - 1] = '\0';
 202       plevel->tiles[y] = (unsigned char*) strdup(line);
 203     }
 204
 205   free(line);
 206   fclose(fi);
 207   return 0;
 208 }
 209
 210 /* Save data for level: */
 211
 212 void level_save(st_level* plevel, char * subset, int level)
 213 {
 214   FILE * fi;
 215   char filename[1024];
 216   int y;
 217   char str[80];
 218
 219   /* Save data file: */
 220   sprintf(str, "/levels/%s/", subset);
 221   fcreatedir(str);
 222   snprintf(filename, 1024, "%s/levels/%s/level%d.dat", st_dir, subset, level);
 223   if(!fwriteable(filename))
 224     snprintf(filename, 1024, "%s/levels/%s/level%d.dat", DATA_PREFIX, subset, level);
 225
 226   fi = fopen(filename, "w");
 227   if (fi == NULL)
 228     {
 229       perror(filename);
 230       st_shutdown();
 231       exit(-1);
 232     }
 233
 234   fputs(plevel->name, fi);
 235   fputs("\n", fi);
 236   fputs(plevel->theme, fi);
 237   fputs("\n", fi);
 238   sprintf(str, "%d\n", plevel->time_left);      /* time */
 239   fputs(str, fi);
 240   fputs(plevel->song_title, fi);        /* song filename */
 241   fputs("\n",fi);
 242   fputs(plevel->bkgd_image, fi);        /* background image */
 243   sprintf(str, "\n%d\n", plevel->bkgd_red);     /* red background color */
 244   fputs(str, fi);
 245   sprintf(str, "%d\n", plevel->bkgd_green);     /* green background color */
 246   fputs(str, fi);
 247   sprintf(str, "%d\n", plevel->bkgd_blue);      /* blue background color */
 248   fputs(str, fi);
 249   sprintf(str, "%d\n", plevel->width);  /* level width */
 250   fputs(str, fi);
 251   sprintf(str, "%2.1f\n", plevel->gravity);     /* level gravity */
 252   fputs(str, fi);
 253
 254   for(y = 0; y < 15; ++y)
 255     {
 256       fputs((const char*)plevel->tiles[y], fi);
 257       fputs("\n", fi);
 258     }
 259
 260   fclose(fi);
 261 }
 262
 263
 264 /* Unload data for this level: */
 265
 266 void level_free(st_level* plevel)
 267 {
 268   int i;
 269   for(i=0; i < 15; ++i)
 270     free(plevel->tiles[i]);
 271
 272   plevel->name[0] = '\0';
 273   plevel->theme[0] = '\0';
 274   plevel->song_title[0] = '\0';
 275   plevel->bkgd_image[0] = '\0';
 276 }
 277
 278 /* Load graphics: */
 279
 280 void level_load_gfx(st_level *plevel)
 281 {
 282
 283   level_load_image(&img_brick[0],plevel->theme,"brick0.png", IGNORE_ALPHA);
 284   level_load_image(&img_brick[1],plevel->theme,"brick1.png", IGNORE_ALPHA);
 285
 286   level_load_image(&img_solid[0],plevel->theme,"solid0.png", USE_ALPHA);
 287   level_load_image(&img_solid[1],plevel->theme,"solid1.png", USE_ALPHA);
 288   level_load_image(&img_solid[2],plevel->theme,"solid2.png", USE_ALPHA);
 289   level_load_image(&img_solid[3],plevel->theme,"solid3.png", USE_ALPHA);
 290
 291   level_load_image(&img_bkgd_tile[0][0],plevel->theme,"bkgd-00.png", USE_ALPHA);
 292   level_load_image(&img_bkgd_tile[0][1],plevel->theme,"bkgd-01.png", USE_ALPHA);
 293   level_load_image(&img_bkgd_tile[0][2],plevel->theme,"bkgd-02.png", USE_ALPHA);
 294   level_load_image(&img_bkgd_tile[0][3],plevel->theme,"bkgd-03.png", USE_ALPHA);
 295
 296   level_load_image(&img_bkgd_tile[1][0],plevel->theme,"bkgd-10.png", USE_ALPHA);
 297   level_load_image(&img_bkgd_tile[1][1],plevel->theme,"bkgd-11.png", USE_ALPHA);
 298   level_load_image(&img_bkgd_tile[1][2],plevel->theme,"bkgd-12.png", USE_ALPHA);
 299   level_load_image(&img_bkgd_tile[1][3],plevel->theme,"bkgd-13.png", USE_ALPHA);
 300
 301   if(strcmp(plevel->bkgd_image,"") != 0)
 302     {
 303       char fname[1024];
 304       snprintf(fname, 1024, "%s/background/%s", st_dir, plevel->bkgd_image);
 305       if(!faccessible(fname))
 306         snprintf(fname, 1024, "%s/images/background/%s", DATA_PREFIX, plevel->bkgd_image);
 307       texture_load(&img_bkgd, fname, IGNORE_ALPHA);
 308     }
 309 }
 310
 311 /* Free graphics data for this level: */
 312
 313 void level_free_gfx(void)
 314 {
 315   int i;
 316
 317   for (i = 0; i < 2; i++)
 318     {
 319       texture_free(&img_brick[i]);
 320     }
 321   for (i = 0; i < 4; i++)
 322     {
 323       texture_free(&img_solid[i]);
 324       texture_free(&img_bkgd_tile[0][i]);
 325       texture_free(&img_bkgd_tile[1][i]);
 326     }
 327   texture_free(&img_bkgd);
 328 }
 329
 330 /* Load a level-specific graphic... */
 331
 332 void level_load_image(texture_type* ptexture, char* theme, char * file, int use_alpha)
 333 {
 334   char fname[1024];
 335
 336   snprintf(fname, 1024, "%s/themes/%s/%s", st_dir, theme, file);
 337   if(!faccessible(fname))
 338     snprintf(fname, 1024, "%s/images/themes/%s/%s", DATA_PREFIX, theme, file);
 339
 340   texture_load(ptexture, fname, use_alpha);
 341 }
 342
 343 /* Edit a piece of the map! */
 344
 345 void level_change(st_level* plevel, float x, float y, unsigned char c)
 346 {
 347   int xx, yy;
 348
 349   yy = ((int)y / 32);
 350   xx = ((int)x / 32);
 351
 352   if (yy >= 0 && yy < 15 && xx >= 0 && xx <= plevel->width)
 353     plevel->tiles[yy][xx] = c;
 354 }
 355
 356 /* Free music data for this level: */
 357
 358 void level_free_song(void)
 359 {
 360   free_music(level_song);
 361   free_music(level_song_fast);
 362 }
 363
 364 /* Load music: */
 365
 366 void level_load_song(st_level* plevel)
 367 {
 368
 369   char * song_path;
 370   char * song_subtitle;
 371
 372   song_path = (char *) malloc(sizeof(char) * (strlen(DATA_PREFIX) +
 373                               strlen(plevel->song_title) + 8));
 374   sprintf(song_path, "%s/music/%s", DATA_PREFIX, plevel->song_title);
 375   level_song = load_song(song_path);
 376   free(song_path);
 377
 378
 379   song_path = (char *) malloc(sizeof(char) * (strlen(DATA_PREFIX) +
 380                               strlen(plevel->song_title) + 8 + 5));
 381   song_subtitle = strdup(plevel->song_title);
 382   strcpy(strstr(song_subtitle, "."), "\0");
 383   sprintf(song_path, "%s/music/%s-fast%s", DATA_PREFIX, song_subtitle, strstr(plevel->song_title, "."));
 384   level_song_fast = load_song(song_path);
 385   free(song_subtitle);
 386   free(song_path);
 387 }