src/tile.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
   5 //
   6 //  This program is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU General Public License
   8 //  as published by the Free Software Foundation; either version 2
   9 //  of the License, or (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  GNU General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU General Public License
  17 //  along with this program; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19 //  02111-1307, USA.
  20
  21 #include "tile.h"
  22 #include "scene.h"
  23 #include "assert.h"
  24
  25 TileManager* TileManager::instance_  = 0;
  26 std::set<TileGroup>* TileManager::tilegroups_  = 0;
  27
  28 Tile::Tile()
  29 {
  30 }
  31
  32 Tile::~Tile()
  33 {
  34   for(std::vector<Surface*>::iterator i = images.begin(); i != images.end();
  35       ++i) {
  36     delete *i;
  37   }
  38   for(std::vector<Surface*>::iterator i = editor_images.begin();
  39       i != editor_images.end(); ++i) {
  40     delete *i;
  41   }
  42 }
  43
  44 //---------------------------------------------------------------------------
  45
  46 TileManager::TileManager()
  47 {
  48   std::string filename = datadir + "/images/tilesets/supertux.stgt";
  49   load_tileset(filename);
  50 }
  51
  52 TileManager::~TileManager()
  53 {
  54   for(std::vector<Tile*>::iterator i = tiles.begin(); i != tiles.end(); ++i) {
  55     delete *i;
  56   }
  57 }
  58
  59 void TileManager::load_tileset(std::string filename)
  60 {
  61   if(filename == current_tileset)
  62     return;
  63
  64   // free old tiles
  65   for(std::vector<Tile*>::iterator i = tiles.begin(); i != tiles.end(); ++i) {
  66     delete *i;
  67   }
  68   tiles.clear();
  69
  70   lisp_object_t* root_obj = lisp_read_from_file(filename);
  71
  72   if (!root_obj)
  73     st_abort("Couldn't load file", filename);
  74
  75   if (strcmp(lisp_symbol(lisp_car(root_obj)), "supertux-tiles") == 0)
  76     {
  77       lisp_object_t* cur = lisp_cdr(root_obj);
  78       int tileset_id = 0;
  79
  80       while(!lisp_nil_p(cur))
  81         {
  82           lisp_object_t* element = lisp_car(cur);
  83
  84           if (strcmp(lisp_symbol(lisp_car(element)), "tile") == 0)
  85             {
  86
  87
  88               Tile* tile = new Tile;
  89               tile->id      = -1;
  90               tile->solid   = false;
  91               tile->brick   = false;
  92               tile->ice     = false;
  93               tile->water   = false;
  94               tile->fullbox = false;
  95               tile->distro  = false;
  96               tile->goal    = false;
  97               tile->data    = 0;
  98               tile->next_tile  = 0;
  99               tile->anim_speed = 25;
 100
 101               LispReader reader(lisp_cdr(element));
 102               assert(reader.read_int("id",  &tile->id));
 103               reader.read_bool("solid",     &tile->solid);
 104               reader.read_bool("brick",     &tile->brick);
 105               reader.read_bool("ice",       &tile->ice);
 106               reader.read_bool("water",     &tile->water);
 107               reader.read_bool("fullbox",   &tile->fullbox);
 108               reader.read_bool("distro",    &tile->distro);
 109               reader.read_bool("goal",      &tile->goal);
 110               reader.read_int("data",       &tile->data);
 111               reader.read_int("anim-speed", &tile->anim_speed);
 112               reader.read_int("next-tile",  &tile->next_tile);
 113               reader.read_string_vector("images",  &tile->filenames);
 114               reader.read_string_vector("editor-images", &tile->editor_filenames);
 115
 116               for(std::vector<std::string>::iterator it = tile->
 117                   filenames.begin();
 118                   it != tile->filenames.end();
 119                   ++it)
 120                 {
 121                   Surface* cur_image;
 122                   tile->images.push_back(cur_image);
 123                   tile->images[tile->images.size()-1] = new Surface(
 124                                datadir +  "/images/tilesets/" + (*it),
 125                                USE_ALPHA);
 126                 }
 127               for(std::vector<std::string>::iterator it = tile->editor_filenames.begin();
 128                   it != tile->editor_filenames.end();
 129                   ++it)
 130                 {
 131                   Surface* cur_image;
 132                   tile->editor_images.push_back(cur_image);
 133                   tile->editor_images[tile->editor_images.size()-1] = new Surface(
 134                                datadir + "/images/tilesets/" + (*it),
 135                                USE_ALPHA);
 136                 }
 137
 138               if (tile->id + tileset_id >= int(tiles.size())
 139                  )
 140                 tiles.resize(tile->id + tileset_id+1);
 141
 142               tiles[tile->id + tileset_id] = tile;
 143             }
 144           else if (strcmp(lisp_symbol(lisp_car(element)), "tileset") == 0)
 145             {
 146               LispReader reader(lisp_cdr(element));
 147               std::string filename;
 148               reader.read_string("file",  &filename);
 149               filename = datadir + "/images/tilesets/" + filename;
 150               load_tileset(filename);
 151             }
 152           else if (strcmp(lisp_symbol(lisp_car(element)), "tilegroup") == 0)
 153             {
 154               TileGroup new_;
 155               LispReader reader(lisp_cdr(element));
 156               reader.read_string("name",  &new_.name);
 157               reader.read_int_vector("tiles", &new_.tiles);
 158               if(!tilegroups_)
 159                 tilegroups_ = new std::set<TileGroup>;
 160               tilegroups_->insert(new_).first;
 161             }
 162           else if (strcmp(lisp_symbol(lisp_car(element)), "properties") == 0)
 163             {
 164               LispReader reader(lisp_cdr(element));
 165               reader.read_int("id",  &tileset_id);
 166               tileset_id *= 1000;
 167             }
 168           else
 169             {
 170               puts("Unhandled symbol");
 171             }
 172
 173           cur = lisp_cdr(cur);
 174         }
 175     }
 176   else
 177     {
 178       assert(0);
 179     }
 180
 181   lisp_free(root_obj);
 182   current_tileset = filename;
 183 }
 184
 185 void
 186 Tile::draw(float x, float y, unsigned int c, Uint8 alpha)
 187 {
 188   if (c != 0)
 189     {
 190       Tile* ptile = TileManager::instance()->get(c);
 191       if(ptile)
 192         {
 193           if(ptile->images.size() > 1)
 194             {
 195               ptile->images[( ((global_frame_counter*25) / ptile->anim_speed) % (ptile->images.size()))]->draw(x,y, alpha);
 196             }
 197           else if (ptile->images.size() == 1)
 198             {
 199               ptile->images[0]->draw(x,y, alpha);
 200             }
 201           else
 202             {
 203               //printf("Tile not dravable %u\n", c);
 204             }
 205         }
 206     }
 207 }
 208
 209 void
 210 Tile::draw_stretched(float x, float y, int w, int h, unsigned int c, Uint8 alpha)
 211 {
 212   if (c != 0)
 213     {
 214       Tile* ptile = TileManager::instance()->get(c);
 215       if(ptile)
 216         {
 217           if(ptile->images.size() > 1)
 218             {
 219               ptile->images[( ((global_frame_counter*25) / ptile->anim_speed) % (ptile->images.size()))]->draw_stretched(x,y,w,h, alpha);
 220             }
 221           else if (ptile->images.size() == 1)
 222             {
 223               ptile->images[0]->draw_stretched(x,y, w, h, alpha);
 224             }
 225           else
 226             {
 227               //printf("Tile not dravable %u\n", c);
 228             }
 229         }
 230     }
 231 }
 232
 233 // EOF //
 234