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::vector<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               if(!tilegroups_)
 156                 tilegroups_ = new std::vector<TileGroup>;
 157               tilegroups_->push_back(new_);
 158               LispReader reader(lisp_cdr(element));
 159               tilegroups_->back().name;
 160               reader.read_string("name",  &tilegroups_->back().name);
 161               reader.read_int_vector("tiles", &tilegroups_->back().tiles);
 162             }
 163           else if (strcmp(lisp_symbol(lisp_car(element)), "properties") == 0)
 164             {
 165               LispReader reader(lisp_cdr(element));
 166               reader.read_int("id",  &tileset_id);
 167               tileset_id *= 1000;
 168             }
 169           else
 170             {
 171               puts("Unhandled symbol");
 172             }
 173
 174           cur = lisp_cdr(cur);
 175         }
 176     }
 177   else
 178     {
 179       assert(0);
 180     }
 181
 182   lisp_free(root_obj);
 183   current_tileset = filename;
 184 }
 185
 186 void
 187 Tile::draw(float x, float y, unsigned int c, Uint8 alpha)
 188 {
 189   if (c != 0)
 190     {
 191       Tile* ptile = TileManager::instance()->get(c);
 192       if(ptile)
 193         {
 194           if(ptile->images.size() > 1)
 195             {
 196               ptile->images[( ((global_frame_counter*25) / ptile->anim_speed) % (ptile->images.size()))]->draw(x,y, alpha);
 197             }
 198           else if (ptile->images.size() == 1)
 199             {
 200               ptile->images[0]->draw(x,y, alpha);
 201             }
 202           else
 203             {
 204               //printf("Tile not dravable %u\n", c);
 205             }
 206         }
 207     }
 208 }
 209
 210 void
 211 Tile::draw_stretched(float x, float y, int w, int h, unsigned int c, Uint8 alpha)
 212 {
 213   if (c != 0)
 214     {
 215       Tile* ptile = TileManager::instance()->get(c);
 216       if(ptile)
 217         {
 218           if(ptile->images.size() > 1)
 219             {
 220               ptile->images[( ((global_frame_counter*25) / ptile->anim_speed) % (ptile->images.size()))]->draw_stretched(x,y,w,h, alpha);
 221             }
 222           else if (ptile->images.size() == 1)
 223             {
 224               ptile->images[0]->draw_stretched(x,y, w, h, alpha);
 225             }
 226           else
 227             {
 228               //printf("Tile not dravable %u\n", c);
 229             }
 230         }
 231     }
 232 }
 233
 234 // EOF //
 235