12 files changed, 284 insertions, 85 deletions

@@ -309,7 +309,7 @@ MapRenderComponent::MapRenderComponent(const Map& map)
   
   for (int i=0; i<MAP_WIDTH*(MAP_HEIGHT-1); i++)
   {
-    int tile = map.mapdata()[i];
+    int tile = map.getMapdata()[i];
     int x = i % MAP_WIDTH;
     int y = i / MAP_WIDTH;
     Rectangle dst {x*TILE_WIDTH, y*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT};
@@ -322,7 +322,7 @@ MapRenderComponent::MapRenderComponent(const Map& map)
   }
   
   Texture font("../res/font.bmp");
-  const char* map_name = map.title();
+  const char* map_name = map.getTitle();
   int start_x = (40/2) - (strlen(map_name)/2);
   for (size_t i=0; i<strlen(map_name); i++)
   {
@@ -348,7 +348,7 @@ MapCollisionComponent::MapCollisionComponent(const Map& map) : map(map)
   {
     int x = i % MAP_WIDTH;
     int y = i / MAP_WIDTH;
-    int tile = map.mapdata()[i];
+    int tile = map.getMapdata()[i];
     
     if ((tile > 0) && (tile < 28) && (!((tile >= 5) && (tile <= 7))))
     {
@@ -600,15 +600,15 @@ void StaticImageComponent::render(Game&, Entity& entity, Texture& buffer)
 
 // Simple collision
 
-SimpleColliderComponent::SimpleColliderComponent(std::function<void (Entity& collider)> callback) : callback(callback)
+SimpleColliderComponent::SimpleColliderComponent(std::function<void (Game& game, Entity& collider)> callback) : callback(callback)
 {
   
 }
 
-void SimpleColliderComponent::receive(Game&, Entity&, const Message& msg)
+void SimpleColliderComponent::receive(Game& game, Entity&, const Message& msg)
 {
   if (msg.type == Message::Type::collision)
   {
-    callback(*(msg.collisionEntity));
+    callback(game, *(msg.collisionEntity));
   }
 }
@@ -111,11 +111,11 @@ class StaticImageComponent : public Component {
 
 class SimpleColliderComponent : public Component {
   public:
-    SimpleColliderComponent(std::function<void (Entity& collider)> callback);
+    SimpleColliderComponent(std::function<void (Game& game, Entity& collider)> callback);
     void receive(Game& game, Entity& entity, const Message& msg);
     
   private:
-    std::function<void (Entity& collider)> callback;
+    std::function<void (Game& game, Entity& collider)> callback;
 };
 
 #endif
@@ -1,4 +1,7 @@
 #include "entity.h"
+#include <libxml/parser.h>
+#include "components.h"
+#include "muxer.h"
 
 void Entity::addComponent(std::shared_ptr<Component> c)
 {
@@ -7,6 +7,7 @@ class Component;
 #include <list>
 #include "renderer.h"
 #include "game.h"
+#include "map.h"
 
 class Message {
   public:
@@ -0,0 +1,101 @@
+#include "entityfactory.h"
+#include <libxml/parser.h>
+#include "components.h"
+#include "muxer.h"
+#include <cstdio>
+
+struct EntityData {
+  char* sprite;
+  char* action;
+  bool hasPhysics;
+  int width;
+  int height;
+};
+
+static std::map<std::string, EntityData> factories;
+
+std::shared_ptr<Entity> EntityFactory::createNamedEntity(const std::string name, const Map& map)
+{
+  auto it = factories.find(name);
+  EntityData data = factories[name];
+  if (it == factories.end())
+  {
+    xmlDocPtr doc = xmlParseFile(("../entities/" + name + ".xml").c_str());
+    if (doc == nullptr)
+    {
+      fprintf(stderr, "Error reading entity %s\n", name.c_str());
+      exit(-1);
+    }
+  
+    xmlNodePtr top = xmlDocGetRootElement(doc);
+    if (top == nullptr)
+    {
+      fprintf(stderr, "Empty entity %s\n", name.c_str());
+      exit(-1);
+    }
+  
+    if (xmlStrcmp(top->name, (const xmlChar*) "entity-def"))
+    {
+      fprintf(stderr, "Invalid entity definition %s\n", name.c_str());
+      exit(-1);
+    }
+  
+    for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)
+    {
+      if (!xmlStrcmp(node->name, (const xmlChar*) "sprite"))
+      {
+        xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+        data.sprite = (char*) calloc(xmlStrlen(key)+1, sizeof(char));
+        strcpy(data.sprite, (char*) key);
+        xmlFree(key);
+      } else if (!xmlStrcmp(node->name, (const xmlChar*) "action"))
+      {
+        xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+        data.action = (char*) calloc(xmlStrlen(key)+1, sizeof(char));
+        strcpy(data.action, (char*) key);
+        xmlFree(key);
+      } else if (!xmlStrcmp(node->name, (const xmlChar*) "size"))
+      {
+        xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+        data.hasPhysics = true;
+        sscanf((char*) key, "%d,%d", &(data.width), &(data.height));
+        xmlFree(key);
+      }
+    }
+  
+    xmlFreeDoc(doc);
+    
+    factories[name] = data;
+  }
+  
+  auto entity = std::make_shared<Entity>();
+  
+  if (data.sprite)
+  {
+    auto component = std::make_shared<StaticImageComponent>(data.sprite);
+    entity->addComponent(component);
+  }
+  
+  if (data.action)
+  {
+    if (!strcmp(data.action, "save"))
+    {
+      auto component = std::make_shared<SimpleColliderComponent>([&] (Game& game, Entity& collider) {
+        playSound("../res/Pickup_Coin23.wav", 0.25);
+  
+        game.saveGame(map, collider.position);
+      });
+      entity->addComponent(component);
+    }
+  }
+  
+  if (data.hasPhysics)
+  {
+    auto component = std::make_shared<PhysicsBodyComponent>();
+    entity->addComponent(component);
+    
+    entity->size = std::make_pair(data.width, data.height);
+  }
+  
+  return entity;
+}
@@ -0,0 +1,15 @@
+#ifndef ENTITYFACTORY_H
+#define ENTITYFACTORY_H
+
+#include "entity.h"
+#include <memory>
+#include <string>
+#include <map>
+#include "map.h"
+
+class EntityFactory {
+  public:
+    static std::shared_ptr<Entity> createNamedEntity(const std::string name, const Map& map);
+};
+
+#endif
@@ -2,12 +2,10 @@
 #include "renderer.h"
 #include "components.h"
 #include "muxer.h"
+#include "entityfactory.h"
 
 Game::Game()
 { 
-  m.setLeftMap(&m2);
-  m2.setRightMap(&m);
-  
   player = std::make_shared<Entity>();
   player->position = std::make_pair(100.0,100.0);
   player->size = std::make_pair(10.0,12.0);
@@ -116,32 +114,10 @@ void Game::loadMap(const Map& map)
   auto map_collision = std::make_shared<MapCollisionComponent>(map);
   mapEn->addComponent(map_collision);
   
+  // Map in the back, player on top, rest of entities in between
   nextEntities.clear();
   nextEntities.push_back(mapEn);
-  
-  // this is cheating but is just for testing
-  if (&map == &m2)
-  {
-    auto saveEn = std::make_shared<Entity>();
-    saveEn->position = std::make_pair(257.0, 160.0);
-    saveEn->size = std::make_pair(8.0, 11.0);
-    
-    auto save_render = std::make_shared<StaticImageComponent>("../res/keyring.png");
-    saveEn->addComponent(save_render);
-    
-    auto save_physics = std::make_shared<PhysicsBodyComponent>();
-    saveEn->addComponent(save_physics);
-    
-    auto save_collide = std::make_shared<SimpleColliderComponent>([&] (Entity& collider) {
-      playSound("../res/Pickup_Coin23.wav", 0.25);
-      
-      saveGame(map, collider.position);
-    });
-    saveEn->addComponent(save_collide);
-    
-    nextEntities.push_back(saveEn);
-  }
-  
+  map.createEntities(nextEntities);
   nextEntities.push_back(player);
   
   newWorld = true;
@@ -160,9 +136,9 @@ void Game::saveGame(const Map& map, std::pair<double, double> position)
   save = {&map, position};
 }
 
-void Game::schedule(double time, std::function<void ()>&& callback)
+void Game::schedule(double time, std::function<void ()> callback)
 {
-  scheduled.emplace_front(time, callback);
+  scheduled.emplace_front(time, std::move(callback));
 }
 
 void Game::playerDie(Entity& player, const Map& curMap)
@@ -30,7 +30,7 @@ class Game {
     void loadMap(const Map& map);
     void detectCollision(Entity& collider, std::pair<double, double> old_position);
     void saveGame(const Map& map, std::pair<double, double> position);
-    void schedule(double time, std::function<void ()>&& callback);
+    void schedule(double time, std::function<void ()> callback);
     void playerDie(Entity& player, const Map& curMap);
     
   private:
@@ -40,8 +40,8 @@ class Game {
     std::list<std::shared_ptr<Entity>> nextEntities;
     bool newWorld;
     std::shared_ptr<Entity> player;
-    Map m{"../maps/embarass.txt"};
-    Map m2{"../maps/second.txt"};
+    Map m {Map::getNamedMap("embarass")};
+    Map m2 {Map::getNamedMap("second")};
     Savefile save;
     std::list<std::pair<double, std::function<void ()>>> scheduled;
     bool shouldQuit = false;
@@ -2,43 +2,111 @@
 #include "game.h"
 #include <cstdlib>
 #include <cstring>
+#include <libxml/parser.h>
+#include <map>
+#include "entityfactory.h"
+
+static std::map<std::string, Map> maps;
 
 Map::Map()
 {
-  
+  title = (char*) calloc(1, sizeof(char));
+  mapdata = (int*) calloc(1, sizeof(int));
 }
 
-Map::Map(const char* filename)
+Map::Map(const std::string name)
 {
-  FILE* f = fopen(filename, "r");
+  xmlDocPtr doc = xmlParseFile(("../maps/" + name + ".xml").c_str());
+  if (doc == nullptr)
+  {
+    fprintf(stderr, "Error reading map %s\n", name.c_str());
+    exit(-1);
+  }
   
-  m_mapdata = (int*) malloc(MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(int));
-  for (int i=0; i<MAP_HEIGHT-1; i++)
+  xmlNodePtr top = xmlDocGetRootElement(doc);
+  if (top == nullptr)
   {
-    for (int j=0; j<MAP_WIDTH; j++)
+    fprintf(stderr, "Empty map %s\n", name.c_str());
+    exit(-1);
+  }
+  
+  if (xmlStrcmp(top->name, (const xmlChar*) "map-def"))
+  {
+    fprintf(stderr, "Invalid map definition %s\n", name.c_str());
+    exit(-1);
+  }
+  
+  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)
+  {
+    if (!xmlStrcmp(node->name, (const xmlChar*) "name"))
+    {
+      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+      title = (char*) calloc(xmlStrlen(key) + 1, sizeof(char));
+      strcpy(title, (char*) key);
+      xmlFree(key);
+    } else if (!xmlStrcmp(node->name, (const xmlChar*) "environment"))
+    {
+      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+      mapdata = (int*) malloc(MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(int));
+      mapdata[0] = atoi(strtok((char*) key, ",\n"));
+      for (int i=1; i<(MAP_WIDTH*(MAP_HEIGHT-1)); i++)
+      {
+        mapdata[i] = atoi(strtok(NULL, ",\n"));
+      }
+      xmlFree(key);
+    } else if (!xmlStrcmp(node->name, (const xmlChar*) "entities"))
     {
-      fscanf(f, "%d,", &(m_mapdata[i*MAP_WIDTH + j]));
+      for (xmlNodePtr entityNode = node->xmlChildrenNode; entityNode != NULL; entityNode = entityNode->next)
+      {
+        if (!xmlStrcmp(entityNode->name, (const xmlChar*) "entity"))
+        {
+          EntityData data;
+          for (xmlNodePtr entityDataNode = entityNode->xmlChildrenNode; entityDataNode != NULL; entityDataNode = entityDataNode->next)
+          {
+            if (!xmlStrcmp(entityDataNode->name, (const xmlChar*) "entity-type"))
+            {
+              xmlChar* key = xmlNodeListGetString(doc, entityDataNode->xmlChildrenNode, 1);
+              data.name = std::string((char*) key);
+              xmlFree(key);
+            } else if (!xmlStrcmp(entityDataNode->name, (const xmlChar*) "entity-position"))
+            {
+              xmlChar* key = xmlNodeListGetString(doc, entityDataNode->xmlChildrenNode, 1);
+              sscanf((char*) key, "%lf,%lf", &(data.position.first), &(data.position.second));
+              xmlFree(key);
+            }
+          }
+        
+          entities.push_back(data);
+        }
+      }
+    } else if (!xmlStrcmp(node->name, (const xmlChar*) "leftmap"))
+    {
+      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+      leftMap = &Map::getNamedMap(std::string((char*) key));
+      xmlFree(key);
+    } else if (!xmlStrcmp(node->name, (const xmlChar*) "rightmap"))
+    {
+      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
+      rightMap = &Map::getNamedMap(std::string((char*) key));
+      xmlFree(key);
     }
-    
-    fgetc(f);
   }
   
-  m_title = (char*) calloc(41, sizeof(char));
-  fgets(m_title, 41, f);
-  
-  fclose(f);
+  xmlFreeDoc(doc);
 }
 
-Map::Map(Map& map)
+Map::Map(const Map& map)
 {
-  m_mapdata = (int*) malloc(MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(int));
-  memcpy(m_mapdata, map.m_mapdata, MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(int));
+  mapdata = (int*) malloc(MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(int));
+  memcpy(mapdata, map.mapdata, MAP_WIDTH*(MAP_HEIGHT-1)*sizeof(int));
+  
+  title = (char*) malloc((MAP_WIDTH+1)*sizeof(char));
+  strncpy(title, map.title, MAP_WIDTH+1);
   
-  m_title = (char*) malloc((MAP_WIDTH+1)*sizeof(char));
-  strncpy(m_title, map.m_title, MAP_WIDTH+1);
+  leftMap = map.leftMap;
+  rightMap = map.rightMap;
   
-  m_leftMap = map.m_leftMap;
-  m_rightMap = map.m_rightMap;
+  entities = map.entities;
 }
 
 Map::Map(Map&& map) : Map()
@@ -48,8 +116,8 @@ Map::Map(Map&& map) : Map()
 
 Map::~Map()
 {
-  free(m_mapdata);
-  free(m_title);
+  free(mapdata);
+  free(title);
 }
 
 Map& Map::operator= (Map map)
@@ -61,38 +129,60 @@ Map& Map::operator= (Map map)
 
 void swap(Map& first, Map& second)
 {
-  std::swap(first.m_mapdata, second.m_mapdata);
-  std::swap(first.m_title, second.m_title);
-  std::swap(first.m_leftMap, second.m_leftMap);
-  std::swap(first.m_rightMap, second.m_rightMap);
+  std::swap(first.mapdata, second.mapdata);
+  std::swap(first.title, second.title);
+  std::swap(first.leftMap, second.leftMap);
+  std::swap(first.rightMap, second.rightMap);
+  std::swap(first.entities, second.entities);
 }
 
-const int* Map::mapdata() const
+const int* Map::getMapdata() const
 {
-  return m_mapdata;
+  return mapdata;
 }
 
-const char* Map::title() const
+const char* Map::getTitle() const
 {
-  return m_title;
+  return title;
 }
 
 const Map* Map::getLeftMap() const
 {
-  return m_leftMap;
+  return leftMap;
 }
 
 const Map* Map::getRightMap() const
 {
-  return m_rightMap;
+  return rightMap;
 }
 
 void Map::setLeftMap(const Map* m)
 {
-  m_leftMap = m;
+  leftMap = m;
 }
 
 void Map::setRightMap(const Map* m)
 {
-  m_rightMap = m;
+  rightMap = m;
+}
+
+void Map::createEntities(std::list<std::shared_ptr<Entity>>& entities) const
+{
+  for (auto data : this->entities)
+  {
+    auto entity = EntityFactory::createNamedEntity(data.name, *this);
+    entity->position = data.position;
+    
+    entities.push_back(entity);
+  }
+}
+
+Map& Map::getNamedMap(const std::string name)
+{
+  if (maps.count(name) == 0)
+  {
+    maps[name] = Map {name};
+  }
+  
+  return maps[name];
 }
@@ -1,28 +1,41 @@
 #ifndef MAP_H
 #define MAP_H
 
+#include <string>
+#include <list>
+
+class Entity;
+
 class Map {
   public:
-    Map(const char* filename);
-    Map(Map& map);
+    Map();
+    Map(const std::string name);
+    Map(const Map& map);
     Map(Map&& map);
     ~Map();
     Map& operator= (Map other);
     friend void swap(Map& first, Map& second);
     
-    const int* mapdata() const;
-    const char* title() const;
+    static Map& getNamedMap(const std::string name);
+    
+    const int* getMapdata() const;
+    const char* getTitle() const;
     const Map* getLeftMap() const;
     const Map* getRightMap() const;
     void setLeftMap(const Map* m);
     void setRightMap(const Map* m);
+    void createEntities(std::list<std::shared_ptr<Entity>>& entities) const;
   private:
-    Map();
+    struct EntityData {
+      std::string name;
+      std::pair<double, double> position;
+    };
     
-    int* m_mapdata;
-    char* m_title;
-    const Map* m_leftMap = nullptr;
-    const Map* m_rightMap = nullptr;
+    int* mapdata;
+    char* title;
+    const Map* leftMap = nullptr;
+    const Map* rightMap = nullptr;
+    std::list<EntityData> entities;
 };
 
 #endif
@@ -513,7 +513,7 @@ Texture::Texture(const char* filename)
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 }
 
-Texture::Texture(Texture& tex)
+Texture::Texture(const Texture& tex)
 {
   if (!rendererInitialized)
   {
@@ -15,7 +15,7 @@ class Texture {
   public:
     Texture(int width, int height);
     Texture(const char* file);
-    Texture(Texture& tex);
+    Texture(const Texture& tex);
     Texture(Texture&& tex);
     ~Texture();
     Texture& operator= (Texture tex);