stop using pairs instead of index loops, please, it's so much slower

modules/game_market/market.lua

@@ -62,7 +62,8 @@ local function initMarketItems()
   -- populate all market items
   marketItems = {}
   local types = g_things.findThingTypeByAttr(ThingAttrMarket)
-  for k,t in pairs(types) do
+  for idx = 1, #types do
+    local t = types[idx]
     local newItem = Item.create(t:getId())
     if newItem then
       local item = {
@@ -352,4 +353,4 @@ function Market.onItemBoxChecked(widget)
   if widget:isChecked() then
     Market.updateSelectedItem(widget.item)
   end
-end
+end

src/framework/core/binarytree.cpp

@@ -162,3 +162,73 @@ std::string BinaryTree::getString()
     m_pos += len;
     return ret;
 }
+
+BinaryTreePtr BinaryTree::makeChild(uint8 type)
+{
+    BinaryTreePtr child(new BinaryTree(m_fin));
+    child->setType(type);
+    children.append(child);
+    return child;
+}
+
+void BinaryTree::setType(uint8 type)
+{
+    writeU8(0xFE);
+    writeU8(type);
+}
+
+void BinaryTree::writeU8(uint8 u8)
+{
+    m_buffer.add(u8);
+}
+
+void BinaryTree::writeU16(uint16 u16)
+{
+    stdext::writeLE16(m_buffer.data(), u16);
+}
+
+void BinaryTree::writeU32(uint32 u32)
+{
+    stdext::writeLE32(m_buffer.data(), u32);
+}
+
+void BinaryTree::writeString(const std::string& s)
+{
+    size_t len = s.length();
+    writeU16(len);
+    m_buffer.grow(m_pos + len);
+    memcpy(&m_buffer[m_pos], s.c_str(), len);
+    m_pos += len;
+}
+
+void BinaryTree::writePos(const Position& p)
+{
+    if(!p.isValid())
+      stdext::throw_exception("invalid position passed  to BinaryTree::writePos");
+
+    writeU16(p.x);
+    writeU16(p.y);
+    writeU8(p.z);
+}
+
+void BinaryTree::writePoint(const Point& p)
+{
+    if(p.isNull())
+      stdext::throw_exception("invalid point passed to BinaryTree::writePoint");
+
+    writeU8(p.x);
+    writeU8(p.y);
+}
+
+void BinaryTree::writeToFile()
+{
+    if(!m_fin)
+        stdext::throw_exception("attempt to write binary node to closed file");
+
+    /// first write self data
+    m_fin->write(&m_buffer[0], m_buffer.size());
+
+    /// write children data
+    for(const BinaryTreePtr& child : m_children)
+        child->writeToFile();
+}

src/framework/core/binarytree.h

@@ -52,6 +52,16 @@ public:
     Position getPosition() { return Position(getU16(), getU16(), getU8()); }
     Point getPoint() { return Point(getU8(), getU8()); }
 
+    void setType(uint8 type);
+    void writeU8(uint8 u8);
+    void writeU16(uint16 u16);
+    void writeU32(uint32 u32);
+    void writeString(const std::string& s);
+    void writePos(const Position& p);
+    void writePoint(const Point& p);
+    BinaryTreePtr makeChild(uint8 type);
+    void writeToFile();
+
     BinaryTreeVec getChildren();
     bool canRead() { unserialize(); return m_pos < m_buffer.size(); }
 

src/framework/core/filestream.cpp

@@ -256,6 +256,13 @@ BinaryTreePtr FileStream::getBinaryTree()
     return BinaryTreePtr(new BinaryTree(asFileStream()));
 }
 
+BinaryTreePtr FileStream::makeTree()
+{
+    BinaryTreePtr root(new BinaryTree(asFileStream()));
+    root->setType(0);
+    return root;
+}
+
 void FileStream::addU8(uint8 v)
 {
     if(!m_caching) {

src/framework/core/filestream.h

@@ -59,8 +59,7 @@ public:
     void addU32(uint32 v);
     void addU64(uint64 v);
     void addString(const std::string& v);
-    void startNode(uint8 nodeType) { addU8(0xFE); addU8(nodeType); }
-    void endNode() { addU8(0xFF); }
+    BinaryTreePtr makeTree();
 
     FileStreamPtr asFileStream() { return std::static_pointer_cast<FileStream>(shared_from_this()); }
 

src/otclient/houses.cpp

@@ -92,8 +92,6 @@ void Houses::load(const std::string& fileName)
 
         house->load(elem);
     }
-
-    g_logger.debug("Loaded houses.xml successfully.");
 }
 
 HouseList::iterator Houses::findHouse(uint32 houseId)

src/otclient/item.cpp

@@ -263,6 +263,37 @@ void Item::unserializeItem(const BinaryTreePtr &in)
     }
 }
 
+void Item::serializeItem(const BinaryTreePtr& out)
+{
+    out->writeU8(ATTR_COUNT);
+    out->writeU8(getCount());
+
+    out->writeU8(ATTR_CHARGES);
+    out->writeU16(getCountOrSubType());
+
+    Position dest = m_attribs.get<Position>(ATTR_TELE_DEST);
+    if(dest.isValid()) {
+        out->writeU8(ATTR_TELE_DEST);
+        out->writePos(dest);
+    }
+
+    if(isDepot()) {
+        out->writeU8(ATTR_DEPOT_ID);
+        out->writeU16(getDepotId());
+    }
+
+    uint16 aid = m_attribs.get<uint16>(ATTR_ACTION_ID), uid = m_attribs.get<uint16>(ATTR_UNIQUE_ID);
+    if(aid) {
+        out->writeU8(ATTR_ACTION_ID);
+        out->writeU16(aid);
+    }
+
+    if(uid) {
+        out->writeU8(ATTR_UNIQUE_ID);
+        out->writeU16(uid);
+    }
+}
+
 bool Item::isMoveable()
 {
     return !rawGetThingType()->isNotMoveable();

src/otclient/item.h

@@ -97,8 +97,8 @@ public:
 
     ItemPtr clone();
 
-    void unserializeItem(const BinaryTreePtr &in);
-    bool isMoveable();
+    void unserializeItem(const BinaryTreePtr& in);
+    void serializeItem(const BinaryTreePtr& out);
 
     void setDepotId(uint16 depotId) { m_attribs.set(ATTR_DEPOT_ID, depotId); }
     uint16 getDepotId() { return m_attribs.get<uint16>(ATTR_DEPOT_ID); }
@@ -113,6 +113,7 @@ public:
     bool isContainer() { return m_attribs.has(ATTR_CONTAINER_ITEMS); }
     bool isDoor() { return m_attribs.has(ATTR_HOUSEDOORID); }
     bool isTeleport() { return m_attribs.has(ATTR_TELE_DEST); }
+    bool isMoveable();
 
     ItemPtr asItem() { return std::static_pointer_cast<Item>(shared_from_this()); }
     bool isItem() { return true; }

src/otclient/luafunctions.cpp

@@ -98,7 +98,7 @@ void OTClient::registerLuaFunctions()
     g_lua.bindSingletonFunction("g_map", "getSpectators", &Map::getSpectators, &g_map);
     g_lua.bindSingletonFunction("g_map", "findPath", &Map::findPath, &g_map);
     g_lua.bindSingletonFunction("g_map", "loadOtbm", &Map::loadOtbm, &g_map);
-    //g_lua.bindSingletonFunction("g_map", "saveOtbm", &Map::saveOtbm, &g_map);
+    g_lua.bindSingletonFunction("g_map", "saveOtbm", &Map::saveOtbm, &g_map);
     g_lua.bindSingletonFunction("g_map", "loadOtcm", &Map::loadOtcm, &g_map);
     g_lua.bindSingletonFunction("g_map", "saveOtcm", &Map::saveOtcm, &g_map);
     g_lua.bindSingletonFunction("g_map", "loadMonsters", &Map::loadMonsters, &g_map);

src/otclient/map.cpp

@@ -36,6 +36,9 @@
 #include <framework/core/application.h>
 #include <framework/xml/tinyxml.h>
 
+/// TODO: Move it to Position class if needed
+static inline Position operator&(const Position& pos, int a) { return Position(pos.x & a, pos.y & a, pos.z); }
+
 Map g_map;
 
 void Map::terminate()
@@ -82,8 +85,7 @@ void Map::loadOtbm(const std::string& fileName)
     if(!headerVersion || headerVersion > 3)
         stdext::throw_exception(stdext::format("Unknown OTBM version detected: %u.", headerVersion));
 
-    m_width = root->getU16();
-    m_height = root->getU16();
+    setSize(root->getU16(), root->getU16());
     dump << "Map size: " << m_width << "x" << m_height;
 
     uint32 headerMajorItems = root->getU8();
@@ -188,17 +190,14 @@ void Map::loadOtbm(const std::string& fileName)
                     item->unserializeItem(nodeItem);
 
                     if(item->isContainer()) {
-                        // This is a temporary way for reading container items.
-                        MapContainerPtr mapContainer(new MapContainer);
-                        for(const BinaryTreePtr &insideItem : nodeItem->getChildren()) {
-                            if(insideItem->getU8() != OTBM_ITEM)
+                        for(const BinaryTreePtr& containerItem : nodeItem->getChildren()) {
+                            if(containerItem->getU8() != OTBM_ITEM)
                                 stdext::throw_exception("invalid container item node");
 
-                            ItemPtr newItem = Item::createFromOtb(insideItem->getU16());
-                            newItem->unserializeItem(insideItem);
-                            mapContainer->add(newItem);
+                            ItemPtr cItem = Item::createFromOtb(containerItem->getU16());
+                            cItem->unserializeItem(containerItem);
+                            item->addContainerItem(cItem);
                         }
-                        m_containers.push_back(mapContainer);
                     }
 
                     if(house && item->isMoveable()) {
@@ -255,111 +254,139 @@ void Map::loadOtbm(const std::string& fileName)
 
 void Map::saveOtbm(const std::string &fileName)
 {
-    // TODO: Continue sleepy work.
-#if 0
-    /// TODO: Use binary trees for this
-    FileStreamPtr fin = g_resources.openFile(fileName);
+    /// FIXME: Untested code
+    FileStreamPtr fin = g_resources.appendFile(fileName);
     if(!fin)
-        stdext::throw_exception(stdext::format("failed to open file '%s'", fileName));
+        stdext::throw_exception(stdext::format("failed to open file '%s' for write", fileName));
 
     std::string dir;
-    if(fileName.find_last_of('/') <= 0)
+    if(fileName.find_last_of('/') == std::string::npos)
         dir = g_resources.getWorkDir();
     else
         dir = fileName.substr(0, fileName.find_last_of('/'));
 
-    if(m_houseFile.empty())
-        m_houseFile = "houses.xml";
-    if(m_spawnFile.empty())
-        m_spawnFile = "spawns.xml";
+    uint32 version = 0;
+    /// Support old versions (< 810 or 860 IIRC)
+    /// TODO: Use constants?
+    if(g_things.getOtbMajorVersion() < 10)
+        version = 1;
+    else
+        version = 2;
+
+    /// Usually when a map has empty house/spawn file it means the map is new.
+    /// TODO: Ask the user for a map name instead of those ugly uses of substr
+    std::string houseFile = getHousefile(), spawnFile = getSpawnFile();
+    if(houseFile.empty() && version > 1)
+        houseFile = fileName.substr(fileName.find_last_of('/')) + "-houses.xml";
+    if(spawnFile.empty())
+        spawnFile = fileName.substr(fileName.find_last_of('/')) + "-spawns.xml";
 
 #if 0
-    if(!m_houses->save(dir + "/" + m_houseFile))
-        ;
-    if(!m_spawns->save(dir + "/" + m_spawnFile))
-        ;
-#endif
+    if(version > 1)
+        m_houses->save(dir + "/" + houseFile);
 
-    uint32 ver;
-    if(g_things.getOtbMajorVersion() < 2)
-        ver =0;
-    else if(g_things.getOtbMajorVersion() < 10)
-        ver = 1;
-    else
-        ver = 2;
+    saveSpawns(dir + "/" + spawnFile);
+#endif
 
-    fin->addU32(0x00); // file version
+    time_t start = time(0);
+    fin->addU32(0); // file version
+    BinaryTreePtr root = fin->makeTree();
     {
-        fin->startNode(0x00); //  root
-        fin->addU32(ver);
-        fin->addU16(m_width); // some random width.
-        fin->addU16(m_height); // some random height.
+        root->writeU32(version);
+
+        Size mapSize = getSize();
+        root->writeU16(mapSize.width());
+        root->writeU16(mapSize.height());
 
-        fin->addU32(g_things.getOtbMajorVersion());
-        fin->addU32(g_things.getOtbMinorVersion());
+        root->writeU32(g_things.getOtbMajorVersion());
+        root->writeU32(g_things.getOtbMinorVersion());
 
-        fin->startNode(OTBM_MAP_DATA); // map data node
+        BinaryTreePtr mapData = root->makeChild(OTBM_MAP_DATA);
         {
             // own description.
-            fin->addU8(OTBM_ATTR_DESCRIPTION);
-            fin->addString(m_description);
+            for(const auto& desc : getDescriptions()) {
+                mapData->writeU8(OTBM_ATTR_DESCRIPTION);
+                mapData->writeString(desc);
+            }
 
             // special one
-            fin->addU8(OTBM_ATTR_DESCRIPTION);
-            fin->addString(stdext::format("Saved with %s v%d", g_app.getName(), stdext::unsafe_cast<int>(g_app.getVersion())));
+            mapData->writeU8(OTBM_ATTR_DESCRIPTION);
+            mapData->writeString(stdext::format("Saved with %s v%d", g_app.getName(), stdext::unsafe_cast<int>(g_app.getVersion())));
 
             // spawn file.
-            fin->addU8(OTBM_ATTR_SPAWN_FILE);
-            fin->addString(m_spawnFile);
+            mapData->addU8(OTBM_ATTR_SPAWN_FILE);
+            mapData->addString(spawnFile);
 
             // house file.
             if(ver > 1) {
-                fin->addU8(OTBM_ATTR_HOUSE_FILE);
-                fin->addString(m_houseFile);
+                mapData->addU8(OTBM_ATTR_HOUSE_FILE);
+                mapData->addString(houseFile);
             }
 
-            Position pos(-1, -1, -1);
-            Boolean<true> first;
-            for (const auto& pair : m_tiles) {
+            /// write tiles first
+            BinaryTreePtr tileArea = mapData->makeChild(OTBM_TILE_AREA);
+            Position base(-1, -1, -1);
+            for(const auto& pair : m_tiles) {
+                Position pos = pair.first;
                 TilePtr tile = pair.second;
-                if(!tile || tile->isEmpty())
-                    continue;
 
-                Position tilePos = pair.first;
-                if(tilePos.x < pos.x || tilePos.x >= pos.x + 256 ||
-                    tilePos.y < pos.y || tilePos.y >= pos.y + 256 ||
-                    tilePos.z != pos.z) {
-                    if(!first)
-                        fin->endNode();
-
-                    pos.x = tilePos.x & 0xFF00;
-                    pos.y = tilePos.y & 0xFF00;
-                    pos.z = tilePos.z;
-                    fin->addU16(pos.x);
-                    fin->addU16(pos.y);
-                    fin->addU8(pos.z);
+                /// base position
+                if(pos.x < base.x || pos.x >= base.x + 256 || pos.y < base.y|| pos.y >= base.y + 256 ||
+                        pos.z != base.z) {
+                    tileArea->writePos(base = pos & 0xFF00);
                 }
 
-                // TODO: hOUSES.
-                fin->startNode(OTBM_TILE);
-                fin->addU8(tilePos.x);
-                fin->addU8(tilePos.y);
+                BinaryTreePtr tileNode(nullptr);
+                tileflags_t flags = tile->getFlags();
+                if((flags & TILESTATE_HOUSE) == TILESTATE_HOUSE)
+                    tileNode = tileArea->makeChild(OTBM_HOUSETILE);
+                else
+                    tileNode = tileArea->makeChild(OTBM_TILE);
+
+                tileNode->writePoint(Point(pos.x, pos.y));
+                if(tileNode->getType() == OTBM_HOUSETILE)
+                    tileNode->writeU32(tile->getHouseId());
 
-#if 0
-                // TODO: hOUSES again.
-                if(is house tile)
-                    add u32 house id...;
-#endif
-                if(tile->flags()) {
-                    fin->addU8(OTBM_ATTR_TILE_FLAGS);
-                    fin->addU32(tile->flags());
+                /// Tile flags
+                if(flags != 0) {
+                    tileNode->writeU8(OTBM_ATTR_TILE_FLAGS);
+                    tileNode->writeU32(flags);
                 }
 
+                /// start writing tile items
+                for(const ItemPtr& item : tile->getItems()) {
+                    BinaryTreePtr itemNode = tileNode->makeChild(OTBM_ATTR_ITEM);
+                    item->serializeItem(itemNode);
+                }
+            }
+
+            /// write towns
+            BinaryTreePtr townNode = mapData->makeChild(OTBM_TOWNS);
+            for(const TownPtr& town : m_towns.getTowns()) {
+                BinaryTreePtr newTown = townNode->makeChild(OTBM_TOWN);
+                {
+                    newTown->writeU32(town->getId());
+                    newTown->writeString(town->getName());
+                    newTown->writePos(town->getPos());
+                }
+            }
 
+            /// write waypoints
+            if(version > 1) {
+                BinaryTreePtr waypointNode = mapData->makeChild(OTBM_WAYPOINTS);
+                for(const auto& it : m_waypoints) {
+                    BinaryTreePtr newWaypoint = waypointNode->makeChild(OTBM_WAYPOINT);
+                    {
+                        newWaypoint->writeString(it.second);
+                        newWaypoint->writePos(it.first);
+                    }
+                }
             }
         }
     }
-#endif
+
+    root->writeToFile();
+    g_logger.debug(stdext::format("OTBM saving took %ld", time(0) - start);
 }
 
 void Map::loadSpawns(const std::string &fileName)

src/otclient/map.h

@@ -57,7 +57,10 @@ enum OTBM_ItemAttr
     OTBM_ATTR_SLEEPSTART = 21,
     OTBM_ATTR_CHARGES = 22,
     OTBM_ATTR_CONTAINER_ITEMS = 23,
-    OTBM_ATTR_ATTRIBUTE_MAP = 128
+    OTBM_ATTR_ATTRIBUTE_MAP = 128,
+    /// just random numbers, they're not actually used by the binary reader...
+    OTBM_ATTR_WIDTH = 129,
+    OTBM_ATTR_HEIGHT = 130
 };
 
 enum OTBM_NodeTypes_t
@@ -121,6 +124,18 @@ public:
     void loadSpawns(const std::string& fileName);
     void saveSpawns(const std::string&) { }
 
+    // otbm attributes (description, size, etc.)
+    void setHouseFile(const std::string& file) { m_attribs.set(OTBM_ATTR_HOUSE_FILE, file); }
+    void setSpawnFile(const std::string& file) { m_attribs.set(OTBM_ATTR_SPAWN_FILE, file); }
+    void setDescription(const std::string& desc) { m_attribs.set(OTBM_ATTR_DESCRIPTION, desc); }
+    void setWidth(uint16 w) { m_attribs.set(OTBM_ATTR_WIDTH, w); }
+    void setHeight(uint16 h) { m_attribs.set(OTBM_ATTR_HEIGHT, h); }
+
+    std::string getHouseFile() { return m_attribs.get<std::string>(OTBM_ATTR_HOUSE_FILE); }
+    std::string getSpawnFile() { return m_attribs.get<std::string>(OTBM_ATTR_SPAWN_FILE); }
+    Size getSize() { return Size(m_attribs.get<uint16>(OTBM_ATTR_WIDTH), m_attribs.get<uint16>(OTBM_ATTR_HEIGHT)); }
+    std::vector<std::string> getDescriptions() { return stdext::split(m_attribs.get<std::string>(), "\n"; }
+
     void loadMonsters(const std::string& fileName) { m_creatures.loadMonsters(fileName); }
     void loadSingleCreature(const std::string& file) { m_creatures.loadSingleCreature(file); }
     void loadNpcs(const std::string& folder) { m_creatures.loadNpcs(folder); }
@@ -190,13 +205,9 @@ private:
     Rect m_tilesRect;
 
     AttribStorage m_attribs;
-    std::string m_description, m_spawnFile, m_houseFile;
-
     Houses m_houses;
     Towns m_towns;
     Creatures m_creatures;
-
-    uint16 m_width, m_height;
 };
 
 extern Map g_map;

src/otclient/tile.h

@@ -101,7 +101,10 @@ public:
     bool canErase();
 
     void setFlags(tileflags_t flags) { m_flags |= (uint32)flags; }
-    uint32 flags() { return m_flags; }
+    uint32 getFlags() { return m_flags; }
+
+    void setHouseId(uint32 hid) { if(m_flags & TILESTATE_HOUSE) m_houseId = hid; }
+    uint32 getHouseId() { return m_houseId; }
 
     TilePtr asTile() { return std::static_pointer_cast<Tile>(shared_from_this()); }
 
@@ -113,7 +116,7 @@ private:
     std::vector<ThingPtr> m_things;
     Position m_position;
     uint8 m_drawElevation;
-    uint32 m_flags;
+    uint32 m_flags, m_houseId;
     uint8 m_minimapColorByte;
 };
 #pragma pack(pop)