src/area.cpp

   1 /******************************
   2 ** Tsunagari Tile Engine     **
   3 ** area.cpp                  **
   4 ** Copyright 2011 OmegaSDG   **
   5 ******************************/
   6
   7 #include <boost/shared_ptr.hpp>
   8 #include <libxml/parser.h>
   9 #include <libxml/tree.h>
  10
  11 #include "area.h"
  12 #include "common.h"
  13 #include "entity.h"
  14 #include "log.h"
  15 #include "resourcer.h"
  16 #include "sprite.h"
  17
  18 Area::Area(Resourcer* rc, Entity* player, const std::string descriptor)
  19         : rc(rc), player(player), descriptor(descriptor)
  20 {
  21         dim.z = 0;
  22 }
  23
  24 Area::~Area()
  25 {
  26 }
  27
  28 bool Area::init()
  29 {
  30         if (!processDescriptor()) // Try to load in descriptor.
  31                 return false;
  32         return true;
  33 }
  34
  35 void Area::buttonDown(const Gosu::Button btn)
  36 {
  37         if (btn == Gosu::kbRight)
  38                 player->moveByTile(coord(1, 0, 0));
  39         else if (btn == Gosu::kbLeft)
  40                 player->moveByTile(coord(-1, 0, 0));
  41         else if (btn == Gosu::kbUp)
  42                 player->moveByTile(coord(0, -1, 0));
  43         else if (btn == Gosu::kbDown)
  44                 player->moveByTile(coord(0, 1, 0));
  45 }
  46
  47 void Area::draw()
  48 {
  49         for (unsigned int layer = 0; layer != map.size(); layer++)
  50         {
  51                 grid_t grid = map[layer];
  52                 for (unsigned int y = 0; y != grid.size(); y++)
  53                 {
  54                         row_t row = grid[layer];
  55                         for (unsigned int x = 0; x != row.size(); x++)
  56                         {
  57                                 // TODO support animations
  58                                 Tile* tile = row[x];
  59                                 Gosu::Image* img = tile->type->graphics[0];
  60                                 img->draw(x*img->width(), y*img->height(), 0);
  61                         }
  62                 }
  63         }
  64         player->draw();
  65 }
  66
  67 bool Area::needsRedraw() const
  68 {
  69         return player->needsRedraw();
  70 }
  71
  72 bool Area::processDescriptor()
  73 {
  74         xmlDoc* doc = rc->getXMLDoc(descriptor);
  75         if (!doc)
  76                 return false;
  77
  78         // use RAII to ensure doc is freed
  79         boost::shared_ptr<void> alwaysFreeTheDoc(doc, xmlFreeDoc);
  80
  81         // Iterate and process children of <map>
  82         xmlNode* root = xmlDocGetRootElement(doc); // <map> element
  83
  84         xmlChar* width = xmlGetProp(root, BAD_CAST("width"));
  85         xmlChar* height = xmlGetProp(root, BAD_CAST("height"));
  86         dim.x = atol((const char*)width);
  87         dim.y = atol((const char*)height);
  88
  89         xmlNode* child = root->xmlChildrenNode;
  90         for (; child != NULL; child = child->next) {
  91                 if (!xmlStrncmp(child->name, BAD_CAST("properties"), 11)) {
  92                         if (!processMapProperties(child))
  93                                 return false;
  94                 }
  95                 else if (!xmlStrncmp(child->name, BAD_CAST("tileset"), 8)) {
  96                         if (!processTileset(child))
  97                                 return false;
  98                 }
  99                 else if (!xmlStrncmp(child->name, BAD_CAST("layer"), 6)) {
 100                         if (!processLayer(child))
 101                                 return false;
 102                 }
 103                 else if (!xmlStrncmp(child->name, BAD_CAST("objectgroup"), 12)) {
 104                         if (!processObjectGroup(child))
 105                                 return false;
 106                 }
 107         }
 108
 109         return true;
 110 }
 111
 112 bool Area::processMapProperties(xmlNode* node)
 113 {
 114
 115 /*
 116  <properties>
 117   <property name="areaspec" value="1"/>
 118   <property name="author" value="Michael D. Reiley"/>
 119   <property name="name" value="Baby's First Area"/>
 120   <property name="music_loop" value="true"/>
 121   <property name="music_main" value="wind.music"/>
 122   <property name="onLoad" value="babysfirst_init()"/>
 123   <property name="scripts" value="areainits.event,test.event"/>
 124  </properties>
 125 */
 126
 127         xmlNode* child = node->xmlChildrenNode;
 128         for (; child != NULL; child = child->next) {
 129                 xmlChar* name = xmlGetProp(child, BAD_CAST("name"));
 130                 xmlChar* value = xmlGetProp(child, BAD_CAST("value"));
 131                 if (!xmlStrncmp(name, BAD_CAST("author"), 7))
 132                         author = (const char*)value;
 133                 else if (!xmlStrncmp(name, BAD_CAST("name"), 5))
 134                         this->name = (const char*)value;
 135                 else if (!xmlStrncmp(name, BAD_CAST("music_loop"), 11))
 136                         main.loop = parseBool((const char*)value);
 137                 else if (!xmlStrncmp(name, BAD_CAST("music_main"), 11))
 138                         main.filename = (const char*)value;
 139                 else if (!xmlStrncmp(name, BAD_CAST("onLoad"), 7))
 140                         onLoadEvents = (const char*)value;
 141                 else if (!xmlStrncmp(name, BAD_CAST("scripts"), 8))
 142                         scripts = (const char*)value; // TODO split(), load
 143         }
 144         return true;
 145 }
 146
 147 bool Area::processTileset(xmlNode* node)
 148 {
 149
 150 /*
 151  <tileset firstgid="1" name="tiles.sheet" tilewidth="64" tileheight="64">
 152   <image source="tiles.sheet" width="256" height="256"/>
 153   <tile id="14">
 154    ...
 155   </tile>
 156  </tileset>
 157 */
 158         Tileset ts;
 159         xmlChar* width = xmlGetProp(node, BAD_CAST("tilewidth"));
 160         xmlChar* height = xmlGetProp(node, BAD_CAST("tileheight"));
 161         ts.tiledim.x = atol((const char*)width);
 162         ts.tiledim.y = atol((const char*)height);
 163
 164         xmlNode* child = node->xmlChildrenNode;
 165         for (; child != NULL; child = child->next) {
 166                 if (!xmlStrncmp(child->name, BAD_CAST("tile"), 5)) {
 167                         xmlChar* idstr = xmlGetProp(child, BAD_CAST("id"));
 168                         unsigned id = atol((const char*)idstr);
 169
 170                         // Undeclared TileTypes have default properties.
 171                         while (ts.defaults.size() != id) {
 172                                 TileType tt = defaultTileType(ts.source,
 173                                         ts.tiledim, ts.defaults.size());
 174                                 ts.defaults.push_back(tt);
 175                         }
 176
 177                         // Handle explicit TileType
 178                         if (!processTileType(child, ts))
 179                                 return false;
 180                 }
 181                 else if (!xmlStrncmp(child->name, BAD_CAST("image"), 6)) {
 182                         xmlChar* source = xmlGetProp(child, BAD_CAST("source"));
 183                         ts.source = rc->getBitmap((const char*)source);
 184                 }
 185         }
 186
 187         tilesets.push_back(ts);
 188         return true;
 189 }
 190
 191 Area::TileType Area::defaultTileType(const Gosu::Bitmap source, coord_t tiledim,
 192                                int id)
 193 {
 194         int x = tiledim.x * (id % source.width());
 195         int y = tiledim.y * (id / source.height());
 196
 197         TileType tt;
 198         Gosu::Image* img = rc->bitmapSection(source, x, y,
 199                                              tiledim.x, tiledim.y, true);
 200         tt.graphics.push_back(img);
 201         tt.animated = false;
 202         tt.ani_speed = 0.0;
 203         return tt;
 204 }
 205
 206 bool Area::processTileType(xmlNode* node, Tileset& ts)
 207 {
 208 /*
 209   <tile id="8">
 210    <properties>
 211     <property name="flags" value="nowalk"/>
 212     <property name="onEnter" value="skid();speed(2)"/>
 213     <property name="onLeave" value="undo()"/>
 214    </properties>
 215   </tile>
 216   <tile id="14">
 217    <properties>
 218     <property name="animated" value="1"/>
 219     <property name="size" value="2"/>
 220     <property name="speed" value="2"/>
 221    </properties>
 222   </tile>
 223 */
 224
 225         // Initialize a default TileType, we'll build on that.
 226         TileType tt = defaultTileType(ts.source,
 227                 ts.tiledim, ts.defaults.size());
 228
 229         xmlChar* idstr = xmlGetProp(node, BAD_CAST("id"));
 230         unsigned id = atol((const char*)idstr);
 231         if (id != ts.defaults.size()) {
 232                 // XXX we need to know the Area we're loading...
 233                 Log::err("unknown area", std::string("expected TileType id ") +
 234                          itostr(ts.defaults.size()) + ", but got " + itostr(id));
 235                 return false;
 236         }
 237
 238         xmlNode* child = node->xmlChildrenNode; // <properties>
 239         child = node->xmlChildrenNode; // <property>
 240         for (; child != NULL; child = child->next) {
 241                 xmlChar* name = xmlGetProp(child, BAD_CAST("name"));
 242                 xmlChar* value = xmlGetProp(child, BAD_CAST("value"));
 243                 if (!xmlStrncmp(child->name, BAD_CAST("flags"), 6)) {
 244                         // TODO flags
 245                 }
 246                 else if (!xmlStrncmp(name, BAD_CAST("onEnter"), 8)) {
 247                         // TODO events
 248                 }
 249                 else if (!xmlStrncmp(name, BAD_CAST("onLeave"), 8)) {
 250                         // TODO events
 251                 }
 252                 else if (!xmlStrncmp(name, BAD_CAST("animated"), 9)) {
 253                         tt.animated = parseBool((const char*)value);
 254                 }
 255                 else if (!xmlStrncmp(name, BAD_CAST("size"), 5)) {
 256                         // TODO animation
 257                 }
 258                 else if (!xmlStrncmp(name, BAD_CAST("speed"), 6)) {
 259                         tt.ani_speed = atol((const char*)value);
 260                 }
 261         }
 262
 263         ts.defaults.push_back(tt);
 264         return true;
 265 }
 266
 267 bool Area::processLayer(xmlNode* node)
 268 {
 269
 270 /*
 271  <layer name="Tiles0" width="5" height="5">
 272   <properties>
 273    ...
 274   </properties>
 275   <data>
 276    <tile gid="9"/>
 277    <tile gid="9"/>
 278    <tile gid="9"/>
 279 ...
 280    <tile gid="3"/>
 281    <tile gid="9"/>
 282    <tile gid="9"/>
 283   </data>
 284  </layer>
 285 */
 286
 287         xmlChar* width = xmlGetProp(node, BAD_CAST("width"));
 288         xmlChar* height = xmlGetProp(node, BAD_CAST("height"));
 289         unsigned x = atol((const char*)width);
 290         unsigned y = atol((const char*)height);
 291
 292         if (dim.x != x || dim.y != y) {
 293                 // XXX we need to know the Area we're loading...
 294                 Log::err("unknown area", "layer x,y size != map x,y size");
 295                 return false;
 296         }
 297
 298         xmlNode* child = node->xmlChildrenNode;
 299         for (; child != NULL; child = child->next) {
 300                 if (!xmlStrncmp(child->name, BAD_CAST("properties"), 11)) {
 301                         if (!processLayerProperties(child))
 302                                 return false;
 303                 }
 304                 else if (!xmlStrncmp(child->name, BAD_CAST("data"), 5)) {
 305                         if (!processLayerData(child))
 306                                 return false;
 307                 }
 308         }
 309         return true;
 310 }
 311
 312 bool Area::processLayerProperties(xmlNode* node)
 313 {
 314
 315 /*
 316   <properties>
 317    <property name="layer" value="0"/>
 318   </properties>
 319 */
 320
 321         xmlNode* child = node->xmlChildrenNode;
 322         for (; child != NULL; child = child->next) {
 323                 xmlChar* name = xmlGetProp(child, BAD_CAST("name"));
 324                 xmlChar* value = xmlGetProp(child, BAD_CAST("value"));
 325                 if (!xmlStrncmp(name, BAD_CAST("layer"), 6)) {
 326                         unsigned depth = atol((const char*)value);
 327                         if (depth != dim.z) {
 328                                 Log::err("unknown area", "invalid layer depth");
 329                                 return false;
 330                         }
 331                 }
 332         }
 333
 334         return true;
 335 }
 336
 337 bool Area::processLayerData(xmlNode* node)
 338 {
 339
 340 /*
 341   <data>
 342    <tile gid="9"/>
 343    <tile gid="9"/>
 344    <tile gid="9"/>
 345 ...
 346    <tile gid="3"/>
 347    <tile gid="9"/>
 348    <tile gid="9"/>
 349   </data>
 350 */
 351
 352         row_t row;
 353         grid_t grid;
 354
 355         xmlNode* child = node->xmlChildrenNode;
 356         for (int i = 1; child != NULL; i++, child = child->next) {
 357                 if (!xmlStrncmp(child->name, BAD_CAST("tile"), 5)) {
 358                         xmlChar* gidStr = xmlGetProp(child, BAD_CAST("gid"));
 359                         unsigned gid = atol((const char*)gidStr);
 360                         Tile* t = new Tile;
 361                         t->type = &tilesets[0].defaults[gid]; // XXX can only access first tileset
 362                         row.push_back(t);
 363                         if (i % dim.x == 0) {
 364                                 grid.push_back(row);
 365                                 row.clear();
 366                         }
 367                 }
 368         }
 369
 370         map.push_back(grid);
 371         dim.z++;
 372         return true;
 373 }
 374
 375 bool Area::processObjectGroup(xmlNode*)
 376 {
 377         return true;
 378 }
 379
 380 coord_t Area::getDimensions() const
 381 {
 382         return dim;
 383 }
 384
 385 Area::Tile* Area::getTile(coord_t c)
 386 {
 387         return map[c.z][c.y][c.x];
 388 }
 389