src/level.cpp

   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 #include "scene.h"
  22 #include "lispreader.h"
  23
  24 texture_type img_bkgd, img_bkgd_tile[2][4], img_solid[4], img_brick[2];
  25
  26 void subset_init(st_subset* st_subset)
  27 {
  28   st_subset->title = NULL;
  29   st_subset->description = NULL;
  30   st_subset->name = NULL;
  31   st_subset->levels = 0;
  32 }
  33
  34 void subset_parse (st_subset* st_subset, lisp_object_t* cursor)
  35 {
  36   while(!lisp_nil_p(cursor))
  37     {
  38       lisp_object_t* cur = lisp_car(cursor);
  39       char *s;
  40
  41       if (!lisp_cons_p(cur) || !lisp_symbol_p (lisp_car(cur)))
  42         {
  43           printf("Not good");
  44         }
  45       else
  46         {
  47           if (strcmp(lisp_symbol(lisp_car(cur)), "title") == 0)
  48             {
  49               if(( s = lisp_string(lisp_car(lisp_cdr(cur)))) != NULL)
  50                 {
  51                   st_subset->title = (char*) malloc(sizeof(char)*(strlen(s)+1));
  52                   strcpy(st_subset->title,s);
  53                 }
  54             }
  55           else if (strcmp(lisp_symbol(lisp_car(cur)), "description") == 0)
  56             {
  57               if(( s = lisp_string(lisp_car(lisp_cdr(cur)))) != NULL)
  58                 {
  59                   st_subset->description = (char*) malloc(sizeof(char)*(strlen(s)+1));
  60                   strcpy(st_subset->description,s);
  61                 }
  62             }
  63         }
  64       cursor = lisp_cdr (cursor);
  65     }
  66 }
  67
  68 void subset_load(st_subset* st_subset, char *subset)
  69 {
  70   FILE* fi;
  71   char filename[1024];
  72   char str[1024];
  73   int len,i;
  74   lisp_object_t* root_obj = 0;
  75
  76   st_subset->name = (char*) malloc(sizeof(char)*(strlen(subset)+1));
  77   strcpy(st_subset->name,subset);
  78
  79   snprintf(filename, 1024, "%s/levels/%s/info", st_dir, subset);
  80   if(!faccessible(filename))
  81     snprintf(filename, 1024, "%s/levels/%s/info", DATA_PREFIX, subset);
  82   if(faccessible(filename))
  83     {
  84       fi = fopen(filename, "r");
  85       if (fi == NULL)
  86         {
  87           perror(filename);
  88         }
  89       lisp_stream_t stream;
  90       lisp_stream_init_file (&stream, fi);
  91       root_obj = lisp_read (&stream);
  92
  93       if (root_obj->type == LISP_TYPE_EOF || root_obj->type == LISP_TYPE_PARSE_ERROR)
  94         {
  95           printf("World: Parse Error in file %s", filename);
  96         }
  97
  98       lisp_object_t* cur = lisp_car(root_obj);
  99
 100       if (!lisp_symbol_p (cur))
 101         {
 102           printf("World: Read error in %s",filename);
 103         }
 104
 105       if (strcmp(lisp_symbol(cur), "level-subset") == 0)
 106         {
 107           subset_parse(st_subset,lisp_cdr(root_obj));
 108
 109         }
 110
 111       fclose(fi);
 112
 113       snprintf(str, 1024, "%s.png", filename);
 114       if(faccessible(str))
 115         {
 116           texture_load(&st_subset->image,str,IGNORE_ALPHA);
 117         }
 118       else
 119         {
 120           snprintf(filename, 1024, "%s/images/status/level-subset-info.png", DATA_PREFIX);
 121           texture_load(&st_subset->image,filename,IGNORE_ALPHA);
 122         }
 123     }
 124
 125   for(i=1; i != -1; ++i)
 126     {
 127       /* Get the number of levels in this subset */
 128       snprintf(filename, 1024, "%s/levels/%s/level%d.dat", st_dir, subset,i);
 129       if(!faccessible(filename))
 130         {
 131           snprintf(filename, 1024, "%s/levels/%s/level%d.dat", DATA_PREFIX, subset,i);
 132           if(!faccessible(filename))
 133             break;
 134         }
 135     }
 136   st_subset->levels = --i;
 137 }
 138
 139 void subset_save(st_subset* st_subset)
 140 {
 141   FILE* fi;
 142   char filename[1024];
 143
 144   /* Save data file: */
 145   sprintf(filename, "/levels/%s/", st_subset->name);
 146
 147   fcreatedir(filename);
 148   snprintf(filename, 1024, "%s/levels/%s/info", st_dir, st_subset->name);
 149   if(!fwriteable(filename))
 150     snprintf(filename, 1024, "%s/levels/%s/info", DATA_PREFIX, st_subset->name);
 151   if(fwriteable(filename))
 152     {
 153       fi = fopen(filename, "w");
 154       if (fi == NULL)
 155         {
 156           perror(filename);
 157         }
 158
 159       /* Write header: */
 160       fprintf(fi,";SuperTux-Level-Subset\n");
 161       fprintf(fi,"(level-subset\n");
 162
 163       /* Save title info: */
 164       fprintf(fi,"  (title \"%s\")\n",st_subset->title);
 165
 166       /* Save the description: */
 167       fprintf(fi,"  (description \"%s\")\n",st_subset->description);
 168
 169       fprintf( fi,")");
 170       fclose(fi);
 171
 172     }
 173 }
 174
 175 void subset_free(st_subset* st_subset)
 176 {
 177   free(st_subset->title);
 178   free(st_subset->description);
 179   free(st_subset->name);
 180   texture_free(&st_subset->image);
 181   st_subset->levels = 0;
 182 }
 183
 184 /* Load data for this level: */
 185 /* Returns -1, if the loading of the level failed. */
 186 int level_load(st_level* plevel, char *subset, int level)
 187 {
 188   char filename[1024];
 189
 190   /* Load data file: */
 191
 192   snprintf(filename, 1024, "%s/levels/%s/level%d.dat", st_dir, subset, level);
 193   if(!faccessible(filename))
 194     snprintf(filename, 1024, "%s/levels/%s/level%d.dat", DATA_PREFIX, subset, level);
 195
 196   return level_load(plevel, filename);
 197 }
 198
 199 int level_load(st_level* plevel, const char* filename)
 200 {
 201   char str[80];
 202   int x, y;
 203   char * line;
 204   FILE * fi;
 205   fi = fopen(filename, "r");
 206   if (fi == NULL)
 207     {
 208       perror(filename);
 209       return -1;
 210     }
 211
 212   /* Load header info: */
 213
 214
 215   /* (Level title) */
 216   fgets(str, 20, fi);
 217   strcpy(plevel->name, str);
 218   plevel->name[strlen(plevel->name)-1] = '\0';
 219
 220   /* (Level theme) */
 221   fgets(str, 20, fi);
 222   strcpy(plevel->theme, str);
 223   plevel->theme[strlen(plevel->theme)-1] = '\0';
 224
 225
 226
 227   /* (Time to beat level) */
 228   fgets(str, 10, fi);
 229   plevel->time_left = atoi(str);
 230
 231   /* (Song file for this level) */
 232   fgets(str, sizeof(plevel->song_title), fi);
 233   strcpy(plevel->song_title, str);
 234   plevel->song_title[strlen(plevel->song_title)-1] = '\0';
 235
 236   /* (Level background image) */
 237   fgets(str, sizeof(plevel->bkgd_image), fi);
 238   strcpy(plevel->bkgd_image, str);
 239   plevel->bkgd_image[strlen(plevel->bkgd_image)-1] = '\0';
 240
 241   /* (Level background color) */
 242   fgets(str, 10, fi);
 243   plevel->bkgd_red = atoi(str);
 244   fgets(str, 10, fi);
 245   plevel->bkgd_green= atoi(str);
 246   fgets(str, 10, fi);
 247   plevel->bkgd_blue = atoi(str);
 248
 249   /* (Level width) */
 250   fgets(str, 10, fi);
 251   plevel->width = atoi(str);
 252
 253   /* (Level gravity) */
 254   fgets(str, 10, fi);
 255   plevel->gravity = atof(str);
 256
 257   /* Set the global gravity to the latest loaded level's gravity */
 258   gravity = plevel->gravity;
 259
 260   /* Allocate some space for the line-reading! */
 261
 262   line = (char *) malloc(sizeof(char) * (plevel->width + 5));
 263   if (line == NULL)
 264     {
 265       fprintf(stderr, "Couldn't allocate space to load level data!");
 266       fclose(fi);
 267       return -1;
 268     }
 269
 270
 271   /* Load the level lines: */
 272
 273   for (y = 0; y < 15; y++)
 274     {
 275       if(fgets(line, plevel->width + 5, fi) == NULL)
 276         {
 277           fprintf(stderr, "Level %s isn't complete!\n",plevel->name);
 278           free(line);
 279           fclose(fi);
 280           return -1;
 281         }
 282       line[strlen(line) - 1] = '\0';
 283       plevel->tiles[y] = (unsigned char*) strdup(line);
 284     }
 285
 286   /*  Mark the end position of this level! - Is a bit wrong here thought */
 287
 288   for (y = 0; y < 15; ++y)
 289     {
 290       for (x = 0; x < plevel->width; ++x)
 291         {
 292           if(plevel->tiles[y][x] == '|')
 293             {
 294               if(x*32 > endpos)
 295                 endpos = x*32;
 296             }
 297         }
 298     }
 299
 300   free(line);
 301   fclose(fi);
 302   return 0;
 303 }
 304
 305 /* Save data for level: */
 306
 307 void level_save(st_level* plevel, char * subset, int level)
 308 {
 309   FILE * fi;
 310   char filename[1024];
 311   int y;
 312   char str[80];
 313
 314   /* Save data file: */
 315   sprintf(str, "/levels/%s/", subset);
 316   fcreatedir(str);
 317   snprintf(filename, 1024, "%s/levels/%s/level%d.dat", st_dir, subset, level);
 318   if(!fwriteable(filename))
 319     snprintf(filename, 1024, "%s/levels/%s/level%d.dat", DATA_PREFIX, subset, level);
 320
 321   fi = fopen(filename, "w");
 322   if (fi == NULL)
 323     {
 324       perror(filename);
 325       st_shutdown();
 326       exit(-1);
 327     }
 328
 329   fputs(plevel->name, fi);
 330   fputs("\n", fi);
 331   fputs(plevel->theme, fi);
 332   fputs("\n", fi);
 333   sprintf(str, "%d\n", plevel->time_left);      /* time */
 334   fputs(str, fi);
 335   fputs(plevel->song_title, fi);        /* song filename */
 336   fputs("\n",fi);
 337   fputs(plevel->bkgd_image, fi);        /* background image */
 338   sprintf(str, "\n%d\n", plevel->bkgd_red);     /* red background color */
 339   fputs(str, fi);
 340   sprintf(str, "%d\n", plevel->bkgd_green);     /* green background color */
 341   fputs(str, fi);
 342   sprintf(str, "%d\n", plevel->bkgd_blue);      /* blue background color */
 343   fputs(str, fi);
 344   sprintf(str, "%d\n", plevel->width);  /* level width */
 345   fputs(str, fi);
 346   sprintf(str, "%2.1f\n", plevel->gravity);     /* level gravity */
 347   fputs(str, fi);
 348
 349   for(y = 0; y < 15; ++y)
 350     {
 351       fputs((const char*)plevel->tiles[y], fi);
 352       fputs("\n", fi);
 353     }
 354
 355   fclose(fi);
 356 }
 357
 358
 359 /* Unload data for this level: */
 360
 361 void level_free(st_level* plevel)
 362 {
 363   int i;
 364   for(i=0; i < 15; ++i)
 365     free(plevel->tiles[i]);
 366
 367   plevel->name[0] = '\0';
 368   plevel->theme[0] = '\0';
 369   plevel->song_title[0] = '\0';
 370   plevel->bkgd_image[0] = '\0';
 371 }
 372
 373 /* Load graphics: */
 374
 375 void level_load_gfx(st_level *plevel)
 376 {
 377   level_load_image(&img_brick[0],plevel->theme,"brick0.png", IGNORE_ALPHA);
 378   level_load_image(&img_brick[1],plevel->theme,"brick1.png", IGNORE_ALPHA);
 379
 380   level_load_image(&img_solid[0],plevel->theme,"solid0.png", USE_ALPHA);
 381   level_load_image(&img_solid[1],plevel->theme,"solid1.png", USE_ALPHA);
 382   level_load_image(&img_solid[2],plevel->theme,"solid2.png", USE_ALPHA);
 383   level_load_image(&img_solid[3],plevel->theme,"solid3.png", USE_ALPHA);
 384
 385   level_load_image(&img_bkgd_tile[0][0],plevel->theme,"bkgd-00.png", USE_ALPHA);
 386   level_load_image(&img_bkgd_tile[0][1],plevel->theme,"bkgd-01.png", USE_ALPHA);
 387   level_load_image(&img_bkgd_tile[0][2],plevel->theme,"bkgd-02.png", USE_ALPHA);
 388   level_load_image(&img_bkgd_tile[0][3],plevel->theme,"bkgd-03.png", USE_ALPHA);
 389
 390   level_load_image(&img_bkgd_tile[1][0],plevel->theme,"bkgd-10.png", USE_ALPHA);
 391   level_load_image(&img_bkgd_tile[1][1],plevel->theme,"bkgd-11.png", USE_ALPHA);
 392   level_load_image(&img_bkgd_tile[1][2],plevel->theme,"bkgd-12.png", USE_ALPHA);
 393   level_load_image(&img_bkgd_tile[1][3],plevel->theme,"bkgd-13.png", USE_ALPHA);
 394
 395   if(strcmp(plevel->bkgd_image,"") != 0)
 396     {
 397       char fname[1024];
 398       snprintf(fname, 1024, "%s/background/%s", st_dir, plevel->bkgd_image);
 399       if(!faccessible(fname))
 400         snprintf(fname, 1024, "%s/images/background/%s", DATA_PREFIX, plevel->bkgd_image);
 401       texture_load(&img_bkgd, fname, IGNORE_ALPHA);
 402     }
 403   else
 404     {
 405       /* Quick hack to make sure an image is loaded, when we are freeing it afterwards. */#
 406       level_load_image(&img_bkgd, plevel->theme,"solid0.png", IGNORE_ALPHA);
 407     }
 408 }
 409
 410 /* Free graphics data for this level: */
 411
 412 void level_free_gfx(void)
 413 {
 414   int i;
 415
 416   for (i = 0; i < 2; i++)
 417     {
 418       texture_free(&img_brick[i]);
 419     }
 420   for (i = 0; i < 4; i++)
 421     {
 422       texture_free(&img_solid[i]);
 423       texture_free(&img_bkgd_tile[0][i]);
 424       texture_free(&img_bkgd_tile[1][i]);
 425     }
 426
 427   texture_free(&img_bkgd);
 428 }
 429
 430 /* Load a level-specific graphic... */
 431
 432 void level_load_image(texture_type* ptexture, char* theme, char * file, int use_alpha)
 433 {
 434   char fname[1024];
 435
 436   snprintf(fname, 1024, "%s/themes/%s/%s", st_dir, theme, file);
 437   if(!faccessible(fname))
 438     snprintf(fname, 1024, "%s/images/themes/%s/%s", DATA_PREFIX, theme, file);
 439
 440   texture_load(ptexture, fname, use_alpha);
 441 }
 442
 443 /* Edit a piece of the map! */
 444
 445 void level_change(st_level* plevel, float x, float y, unsigned char c)
 446 {
 447   int xx, yy;
 448
 449   yy = ((int)y / 32);
 450   xx = ((int)x / 32);
 451
 452   if (yy >= 0 && yy < 15 && xx >= 0 && xx <= plevel->width)
 453     plevel->tiles[yy][xx] = c;
 454 }
 455
 456 /* Free music data for this level: */
 457
 458 void level_free_song(void)
 459 {
 460   free_music(level_song);
 461   free_music(level_song_fast);
 462 }
 463
 464 /* Load music: */
 465
 466 void level_load_song(st_level* plevel)
 467 {
 468
 469   char * song_path;
 470   char * song_subtitle;
 471
 472   song_path = (char *) malloc(sizeof(char) * (strlen(DATA_PREFIX) +
 473                               strlen(plevel->song_title) + 8));
 474   sprintf(song_path, "%s/music/%s", DATA_PREFIX, plevel->song_title);
 475   level_song = load_song(song_path);
 476   free(song_path);
 477
 478
 479   song_path = (char *) malloc(sizeof(char) * (strlen(DATA_PREFIX) +
 480                               strlen(plevel->song_title) + 8 + 5));
 481   song_subtitle = strdup(plevel->song_title);
 482   strcpy(strstr(song_subtitle, "."), "\0");
 483   sprintf(song_path, "%s/music/%s-fast%s", DATA_PREFIX, song_subtitle, strstr(plevel->song_title, "."));
 484   level_song_fast = load_song(song_path);
 485   free(song_subtitle);
 486   free(song_path);
 487 }