Merged revisions 3750-3751,3755-3759,3761,3766-3767,3773-3776,3779,3781,3783-3789,3791-3800,3807,3814-3815,3817,3819-3820,3822,3824-3825,3827,3829-3838,3840-3841,3843-3858,3860-3875 via svnmerge from

https://themanaworld.svn.sourceforge.net/svnroot/themanaworld/tmw/branches/0.0

........
  r3750 | crush_tmw | 2007-11-20 00:36:02 +0100 (Tue, 20 Nov 2007) | 1 line
  
  Updated desert maps with new tiles by Len.
........
  r3755 | crush_tmw | 2007-11-20 17:47:44 +0100 (Tue, 20 Nov 2007) | 1 line
  
  fixed a collision layer error
........
  r3773 | crush_tmw | 2007-12-12 16:45:25 +0100 (Wed, 12 Dec 2007) | 2 lines
  
  Added my tmxcopy tool for copying parts of maps to other maps.
........
  r3774 | b_lindeijer | 2007-12-12 20:06:49 +0100 (Wed, 12 Dec 2007) | 2 lines
  
  Added two new cave tiles by yosuhara.
........
  r3775 | crush_tmw | 2007-12-12 20:25:40 +0100 (Wed, 12 Dec 2007) | 1 line
  
  Fixed the blurred outlines of the new tiles.
........
  r3791 | b_lindeijer | 2007-12-18 17:19:53 +0100 (Tue, 18 Dec 2007) | 2 lines
  
  Added initial version of the update analysis tool upalyzer.
........
  r3792 | b_lindeijer | 2007-12-18 17:22:27 +0100 (Tue, 18 Dec 2007) | 2 lines
  
  Small fix to the displayed obsolete data percentage.
........
  r3793 | b_lindeijer | 2007-12-18 17:31:52 +0100 (Tue, 18 Dec 2007) | 2 lines
  
  Calculate usage percentage correctly and display zip file overhead.
........
  r3794 | b_lindeijer | 2007-12-18 19:44:12 +0100 (Tue, 18 Dec 2007) | 4 lines
  
  Optimized with single loop approach and nicer printing calls, inspired by
  doener's version. Also added list of update entries and their respective
  update.
........
  r3795 | b_lindeijer | 2007-12-19 10:26:21 +0100 (Wed, 19 Dec 2007) | 4 lines
  
  Fixed association of entries to update, added no-cache headers, added a bit of
  error reporting in case of invalid zip files, kept original ordering of the
  update list and sorted the list of entries on their filename.
........
  r3796 | b_lindeijer | 2007-12-19 11:32:28 +0100 (Wed, 19 Dec 2007) | 3 lines
  
  Added list of files in each update with indication on whether they are still
  used.
........
  r3797 | b_lindeijer | 2007-12-19 12:16:24 +0100 (Wed, 19 Dec 2007) | 2 lines
  
  Fixed weird problem with zip_open failing with relative path.
........
  r3798 | b_lindeijer | 2007-12-19 12:22:50 +0100 (Wed, 19 Dec 2007) | 2 lines
  
  Incorporated some more of doener's leet PHP skills. ;)
........
  r3800 | crush_tmw | 2007-12-19 19:11:22 +0100 (Wed, 19 Dec 2007) | 1 line
  
  Fixed a map bug (monster trap) on map 18 (woodland village surrounding)
........
  r3814 | b_lindeijer | 2007-12-24 17:23:56 +0100 (Mon, 24 Dec 2007) | 2 lines
  
  Updated debian subfolder.
........
  r3817 | b_lindeijer | 2007-12-25 15:26:22 +0100 (Tue, 25 Dec 2007) | 2 lines
  
  Fixed missing backslash.
........
  r3822 | crush_tmw | 2007-12-28 01:26:57 +0100 (Fri, 28 Dec 2007) | 1 line
  
  Some mapping errors fixed by Zipon.
........
  r3824 | crush_tmw | 2007-12-29 03:25:16 +0100 (Sat, 29 Dec 2007) | 1 line
  
  Added new map by 5t3v3 (east desert cave) and enhanced version of eastern desert by Len.
........
  r3827 | crush_tmw | 2007-12-30 01:28:00 +0100 (Sun, 30 Dec 2007) | 1 line
  
  switched layer compression on.
........
  r3830 | crush_tmw | 2008-01-03 18:17:00 +0100 (Thu, 03 Jan 2008) | 1 line
  
  Some map bugs reported by Strump, fixed by Zipon.
........
  r3840 | crush_tmw | 2008-01-14 11:22:14 +0100 (Mon, 14 Jan 2008) | 1 line
  
  Added new versions of snow maps by 5t3v3 (with minor fixes)
........
  r3845 | crush_tmw | 2008-01-19 12:43:32 +0100 (Sat, 19 Jan 2008) | 1 line
  
  Fixes for the new snowland maps by 5t3v3.
........
  r3846 | crush_tmw | 2008-01-19 14:00:37 +0100 (Sat, 19 Jan 2008) | 1 line
  
  Added hot spring particle effect to pond south of snow village.
........
  r3873 | crush_tmw | 2008-02-08 23:07:21 +0100 (Fri, 08 Feb 2008) | 1 line
  
  Added Dimonds Cove Restaurant maps.
........
  r3875 | crush_tmw | 2008-02-10 15:40:00 +0100 (Sun, 10 Feb 2008) | 1 line
  
  Added Dimonds Cove outdoor map.
........

13 files changed, 1311 insertions, 0 deletions

diff --git a/tools/tmxcopy/base64.cpp b/tools/tmxcopy/base64.cpp
new file mode 100644
index 00000000..9a8f6356
--- /dev/null
+++ b/tools/tmxcopy/base64.cpp
@@ -0,0 +1,149 @@
+/*
+   +----------------------------------------------------------------------+
+   | PHP HTML Embedded Scripting Language Version 3.0                     |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1997-2000 PHP Development Team (See Credits file)      |
+   +----------------------------------------------------------------------+
+   | This program is free software; you can redistribute it and/or modify |
+   | it under the terms of one of the following licenses:                 |
+   |                                                                      |
+   |  A) the GNU General Public License as published by the Free Software |
+   |     Foundation; either version 2 of the License, or (at your option) |
+   |     any later version.                                               |
+   |                                                                      |
+   |  B) the PHP License as published by the PHP Development Team and     |
+   |     included in the distribution in the file: LICENSE                |
+   |                                                                      |
+   | This program is distributed in the hope that it will be useful,      |
+   | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
+   | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        |
+   | GNU General Public License for more details.                         |
+   |                                                                      |
+   | You should have received a copy of both licenses referred to here.   |
+   | If you did not, or have any questions about PHP licensing, please    |
+   | contact core@php.net.                                                |
+   +----------------------------------------------------------------------+
+   | Author: Jim Winstead (jimw@php.net)                                  |
+   +----------------------------------------------------------------------+
+   */
+/* $Id$ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "base64.h"
+
+static char base64_table[] =
+{
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '\0'
+};
+static char base64_pad = '=';
+
+unsigned char *php3_base64_encode(const unsigned char *string, int length, int *ret_length) {
+    const unsigned char *current = string;
+    int i = 0;
+    unsigned char *result = (unsigned char *)malloc(((length + 3 - length % 3) * 4 / 3 + 1) * sizeof(char));
+
+    while (length > 2) { /* keep going until we have less than 24 bits */
+        result[i++] = base64_table[current[0] >> 2];
+        result[i++] = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
+        result[i++] = base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)];
+        result[i++] = base64_table[current[2] & 0x3f];
+
+        current += 3;
+        length -= 3; /* we just handle 3 octets of data */
+    }
+
+    /* now deal with the tail end of things */
+    if (length != 0) {
+        result[i++] = base64_table[current[0] >> 2];
+        if (length > 1) {
+            result[i++] = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
+            result[i++] = base64_table[(current[1] & 0x0f) << 2];
+            result[i++] = base64_pad;
+        }
+        else {
+            result[i++] = base64_table[(current[0] & 0x03) << 4];
+            result[i++] = base64_pad;
+            result[i++] = base64_pad;
+        }
+    }
+    if(ret_length) {
+        *ret_length = i;
+    }
+    result[i] = '\0';
+    return result;
+}
+
+/* as above, but backwards. :) */
+unsigned char *php3_base64_decode(const unsigned char *string, int length, int *ret_length) {
+    const unsigned char *current = string;
+    int ch, i = 0, j = 0, k;
+    char *chp;
+
+    unsigned char *result = (unsigned char *)malloc(length + 1);
+
+    if (result == NULL) {
+        return NULL;
+    }
+
+    /* run through the whole string, converting as we go */
+    while ((ch = *current++) != '\0') {
+        if (ch == base64_pad) break;
+
+        /* When Base64 gets POSTed, all pluses are interpreted as spaces.
+           This line changes them back.  It's not exactly the Base64 spec,
+           but it is completely compatible with it (the spec says that
+           spaces are invalid).  This will also save many people considerable
+           headache.  - Turadg Aleahmad <turadg@wise.berkeley.edu>
+           */
+
+        if (ch == ' ') ch = '+';
+
+        chp = strchr(base64_table, ch);
+        if (chp == NULL) continue;
+        ch = chp - base64_table;
+
+        switch(i % 4) {
+            case 0:
+                result[j] = ch << 2;
+                break;
+            case 1:
+                result[j++] |= ch >> 4;
+                result[j] = (ch & 0x0f) << 4;
+                break;
+            case 2:
+                result[j++] |= ch >>2;
+                result[j] = (ch & 0x03) << 6;
+                break;
+            case 3:
+                result[j++] |= ch;
+                break;
+        }
+        i++;
+    }
+
+    k = j;
+    /* mop things up if we ended on a boundary */
+    if (ch == base64_pad) {
+        switch(i % 4) {
+            case 0:
+            case 1:
+                free(result);
+                return NULL;
+            case 2:
+                k++;
+            case 3:
+                result[k++] = 0;
+        }
+    }
+    if(ret_length) {
+        *ret_length = j;
+    }
+    result[k] = '\0';
+    return result;
+}
diff --git a/tools/tmxcopy/base64.h b/tools/tmxcopy/base64.h
new file mode 100644
index 00000000..ff20ac53
--- /dev/null
+++ b/tools/tmxcopy/base64.h
@@ -0,0 +1,37 @@
+/*
+   +----------------------------------------------------------------------+
+   | PHP HTML Embedded Scripting Language Version 3.0                     |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1997,1998 PHP Development Team (See Credits file)      |
+   +----------------------------------------------------------------------+
+   | This program is free software; you can redistribute it and/or modify |
+   | it under the terms of one of the following licenses:                 |
+   |                                                                      |
+   |  A) the GNU General Public License as published by the Free Software |
+   |     Foundation; either version 2 of the License, or (at your option) |
+   |     any later version.                                               |
+   |                                                                      |
+   |  B) the PHP License as published by the PHP Development Team and     |
+   |     included in the distribution in the file: LICENSE                |
+   |                                                                      |
+   | This program is distributed in the hope that it will be useful,      |
+   | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
+   | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        |
+   | GNU General Public License for more details.                         |
+   |                                                                      |
+   | You should have received a copy of both licenses referred to here.   |
+   | If you did not, or have any questions about PHP licensing, please    |
+   | contact core@php.net.                                                |
+   +----------------------------------------------------------------------+
+   | Author: Jim Winstead (jimw@php.net)                                  |
+   +----------------------------------------------------------------------+
+ */
+/* $Id$ */
+
+#ifndef _TMW_BASE64_H
+#define _TMW_BASE64_H
+
+extern unsigned char *php3_base64_encode(const unsigned char *, int, int *);
+extern unsigned char *php3_base64_decode(const unsigned char *, int, int *);
+
+#endif /* _TMW_BASE64_H */
diff --git a/tools/tmxcopy/main.cpp b/tools/tmxcopy/main.cpp
new file mode 100644
index 00000000..3d460961
--- /dev/null
+++ b/tools/tmxcopy/main.cpp
@@ -0,0 +1,66 @@
+/*
+ *  TMXCopy
+ *  Copyright 2007 Philipp Sehmisch
+ *
+ *
+ *  TMXCopy is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  TMXCopy is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with TMXCopy; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <iostream>
+#include <string>
+
+#include "map.hpp"
+
+int main(int argc, char * argv[] )
+{
+    // parsing command line options
+    if (argc < 9 || argc > 10)
+    {
+        std::cerr<<"Usage: srcFile x y height width tgtFile x y [outfile]";
+        return -1;
+    }
+
+    std::string srcFile = argv[1];
+    int srcX= atoi(argv[2]);
+    int srcY= atoi(argv[3]);
+    int height= atoi(argv[4]);
+    int width=atoi(argv[5]);
+    std::string tgtFile = argv[6];
+    int destX=atoi(argv[7]);
+    int destY=atoi(argv[8]);
+    std::string outFile = tgtFile;
+    if (argc == 10) outFile = argv[9];
+
+    // plausibility check of command line options
+    if (height < 1 || width < 1 || srcX < 1 || srcY < 1 || destX < 1 || destY < 1)
+    {
+        std::cerr<<"Illegal coordinates!"<<std::endl;
+        std::cerr<<"Usage: sourceFile x y height width targetFile x y [outputFile]"<<std::endl;
+        return -1;
+    }
+
+    try
+    {
+        Map* srcMap = new Map(srcFile);
+        Map* tgtMap = new Map(tgtFile);
+        tgtMap->overwrite(srcMap, srcX, srcY, height, width, destX, destY);
+        tgtMap->save(outFile);
+    }
+    catch (int)
+    {
+        return -1;
+    }
+
+}
diff --git a/tools/tmxcopy/map.cpp b/tools/tmxcopy/map.cpp
new file mode 100644
index 00000000..0674ae1a
--- /dev/null
+++ b/tools/tmxcopy/map.cpp
@@ -0,0 +1,371 @@
+/*
+ *  TMXCopy
+ *  Copyright 2007 Philipp Sehmisch
+ *
+ *
+ *  TMXCopy is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  TMXCopy is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with TMXCopy; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <iostream>
+#include <map>
+#include <list>
+
+#include <zlib.h>
+
+#include "xmlutils.h"
+#include "zlibutils.h"
+#include "base64.h"
+#include "tostring.h"
+
+#include "map.hpp"
+
+Map::Map(std::string filename):
+    mMaxGid(0)
+{
+    std::cout<<"Loading map "<<filename<<std::endl;
+    //load XML tree
+    mXmlDoc = xmlReadFile(filename.c_str(), NULL, 0);
+
+    if (!mXmlDoc)
+    {
+        std::cerr<<"Could not load "<<filename;
+        throw 1;
+    }
+
+    xmlNodePtr rootNode = xmlDocGetRootElement(mXmlDoc);
+
+    if (!rootNode || !xmlStrEqual(rootNode->name, BAD_CAST "map")) {
+        std::cerr<<filename<<"is not a Tiled map file!";
+        throw 1;
+    }
+
+    mWidth = XML::getProperty(rootNode, "width", 0);
+    mHeight = XML::getProperty(rootNode, "height", 0);
+    int layerNum = 0;
+    for_each_xml_child_node(node, rootNode)
+    {
+        if (xmlStrEqual(node->name, BAD_CAST "tileset"))
+        {
+            //add tilesets to vector of used tilesets
+            Tileset* tileset = new Tileset;
+            tileset->name = XML::getProperty(node, "name", "Unnamed");
+            tileset->tilewidth = XML::getProperty(node, "tilewidth", 0);
+            tileset->tileheight = XML::getProperty(node, "tileheight", 0);
+            tileset->firstgid = XML::getProperty(node, "firstgid", 0);
+            for_each_xml_child_node(imageNode, node)
+            {
+                if (xmlStrEqual(imageNode->name, BAD_CAST "image"))
+                tileset->imagefile = XML::getProperty(imageNode, "source", "");
+            }
+
+            //add tileset to tileset list
+            Map::mTilesets.push_back(tileset);
+        }
+    }
+
+    for_each_xml_child_node(node, rootNode)
+    {
+        if (xmlStrEqual(node->name, BAD_CAST "layer"))
+        {
+            Layer* layer = new Layer;
+            layer->resize(mWidth * mHeight);
+            //build layer information
+            for_each_xml_child_node(dataNode, node)
+            {
+                if (!xmlStrEqual(dataNode->name, BAD_CAST "data")) continue;
+
+                std::string encoding = XML::getProperty(dataNode, "encoding", "");
+                std::string compression = XML::getProperty(dataNode, "compression", "");
+
+                if (encoding != "base64")
+                {
+                    std::cerr<<"Layers in "<<filename<<" are not base64 encoded!";
+                    return;
+                }
+
+                // Read base64 encoded map file
+                xmlNodePtr dataChild = dataNode->xmlChildrenNode;
+                if (!dataChild)
+                    continue;
+
+                int len = strlen((const char*)dataChild->content) + 1;
+                unsigned char *charData = new unsigned char[len + 1];
+                const char *charStart = (const char*)dataChild->content;
+                unsigned char *charIndex = charData;
+
+                while (*charStart) {
+                    if (*charStart != ' ' && *charStart != '\t' &&
+                            *charStart != '\n')
+                    {
+                        *charIndex = *charStart;
+                        charIndex++;
+                    }
+                    charStart++;
+                }
+                *charIndex = '\0';
+
+                int binLen;
+                unsigned char *binData =
+                    php3_base64_decode(charData, strlen((char*)charData), &binLen);
+
+                delete[] charData;
+
+                if (binData) {
+                    if (compression == "gzip")
+                    {
+                        unsigned char *inflated;
+                        unsigned int inflatedSize =
+                            inflateMemory(binData, binLen, inflated);
+                        free(binData);
+                        binData = inflated;
+                        binLen = inflatedSize;
+                        if (inflated == NULL)
+                        {
+                            std::cerr<<"Error: while decompressing layer "<<layerNum<<" in "<<filename;
+                            throw 1;
+                        }
+                    }
+
+                    int c = 0;
+                    for (int i = 0; i < binLen - 3; i += 4) {
+                        int gid = binData[i] |
+                            binData[i + 1] << 8 |
+                            binData[i + 2] << 16 |
+                            binData[i + 3] << 24;
+
+                        if (gid == 0)
+                        {
+                            layer->at(c).tileset = -1;
+                            layer->at(c).index = 0;
+                        }
+                        else
+                        {
+                            for (int s = mTilesets.size()-1; s >= 0; s--)
+                            {
+                                if (mTilesets.at(s)->firstgid < gid)
+                                {
+                                    layer->at(c).tileset = s;
+                                    layer->at(c).index = gid - mTilesets.at(s)->firstgid;
+                                    if (mMaxGid < gid) mMaxGid = gid;
+                                    break;
+                                }
+                            }
+                        }
+
+                        c++;
+                    }
+                    free(binData);
+                } else {
+                    std::cerr<<"error processing layer data in "<<filename<<std::endl;
+                }
+            }
+            mLayers.push_back(layer);
+            layerNum++;
+        }
+    }
+
+    std::cout<<"tilesets: "<<mTilesets.size()<<std::endl;
+    std::cout<<"layers:"<<mLayers.size()<<std::endl;
+    std::cout<<"largest GID:"<<mMaxGid<<std::endl<<std::endl;
+}
+
+bool Map::overwrite(  Map* srcMap,
+                    int srcX, int srcY, int srcWidth, int srcHeight,
+                    int destX, int destY)
+{
+    //plausibility check of coordinates
+    bool checkPassed = true;
+    if (srcX + srcWidth > srcMap->getWidth()) {
+        std::cerr<<"Error: Area exceeds right map border of source map!";
+        checkPassed = false;
+    }
+    if (srcY + srcHeight > srcMap->getHeight()) {
+        std::cerr<<"Error: Area exceeds lower map border of source map!";
+        checkPassed = false;
+    }
+    if (destX + srcWidth > mWidth) {
+        std::cerr<<"Error: Area exceeds right map border of target map!";
+        checkPassed = false;
+    }
+    if (destY + srcHeight > mHeight) {
+        std::cerr<<"Error: Area exceeds lower map border of target map!";
+        checkPassed = false;
+    }
+    if (!checkPassed) return false;
+
+    std::map<int, int> translation;
+    translation[-1] = -1;
+    std::vector<Tileset*>* srcTilesets = srcMap->getTilesets();
+
+    //add new tilesets and add redundant tilesets to list of redundand tilesets
+    for (int a = 0; a < srcTilesets->size(); a++)
+    {
+        int b;
+        for (b = 0; b < mTilesets.size(); b++)
+        {
+            if (*srcTilesets->at(a) == *mTilesets.at(b))
+            {
+                break;
+            }
+        }
+        if (b == mTilesets.size())
+        {
+            mMaxGid += srcTilesets->at(a)->firstgid;
+            srcTilesets->at(a)->firstgid = mMaxGid;//it is possible to get some holes in the gid index this way but who cares, we got 32bit.
+            mTilesets.push_back(srcTilesets->at(a));
+        }
+        translation[a] = b;
+    }
+
+    //combining layer information
+    for (int i = 0; i < srcMap->getNumberOfLayers(); i++)
+    {
+        Layer* srcLayer = srcMap->getLayer(i);
+        Layer* destLayer = mLayers.at(i);
+
+        for (int y=0; y<srcWidth; y++)
+        {
+
+            for (int x=0; x<srcHeight; x++)
+            {
+                int srcIndex = srcMap->getWidth() * (y + srcY) + (x + srcX);
+                int tgtIndex = mWidth * (y + destY) + (x + destX);
+                Tile tmpTile = srcLayer->at(srcIndex);
+                tmpTile.tileset = translation[tmpTile.tileset];
+                destLayer->at(tgtIndex) = tmpTile;
+            }
+        }
+    }
+
+    std::clog<<"copying successful!"<<std::endl;
+}
+
+int Map::save(std::string filename)
+{
+    //remove old tileset and layer information in XML tree
+    xmlNodePtr rootNode = xmlDocGetRootElement(mXmlDoc);
+    std::list<xmlNodePtr> toRemove;
+    for_each_xml_child_node(node, rootNode)
+    {
+        if (    xmlStrEqual(node->name, BAD_CAST "tileset")
+            ||  xmlStrEqual(node->name, BAD_CAST "layer"))
+        {
+            toRemove.push_back(node);
+        }
+    }
+
+    while (!toRemove.empty())
+    {
+        xmlUnlinkNode(toRemove.back());
+        xmlFreeNode(toRemove.back());
+        toRemove.pop_back();
+    }
+
+    //TODO: reorganize GIDs
+
+    //add new tileset information to XML tree
+    for (int i = 0; i< mTilesets.size(); i++)
+    {
+        xmlNodePtr newNode;
+
+        xmlAddChild(rootNode, xmlNewDocText(mXmlDoc, BAD_CAST " "));
+        newNode = xmlNewNode(NULL, BAD_CAST "tileset");
+        xmlNewProp(newNode, BAD_CAST "name", BAD_CAST mTilesets.at(i)->name.c_str());
+        xmlNewProp(newNode, BAD_CAST "firstgid", BAD_CAST toString(mTilesets.at(i)->firstgid).c_str());
+        xmlNewProp(newNode, BAD_CAST "tilewidth", BAD_CAST toString(mTilesets.at(i)->tilewidth).c_str());
+        xmlNewProp(newNode, BAD_CAST "tileheight", BAD_CAST toString(mTilesets.at(i)->tileheight).c_str());
+        xmlAddChild(newNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n  "));
+        xmlNodePtr imageNode = xmlNewNode(NULL, BAD_CAST "image");
+        xmlNewProp(imageNode, BAD_CAST "source", BAD_CAST mTilesets.at(i)->imagefile.c_str());
+        xmlAddChild(newNode, imageNode);
+        xmlAddChild(newNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n "));
+        xmlAddChild(rootNode, newNode);
+        xmlAddChild(rootNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n"));
+    }
+
+    //add new layer information to XML tree
+    for (int i = 0; i < mLayers.size(); i++)
+    {
+        //lay out layer information in binary
+        unsigned char* binData = (unsigned char*)malloc(mWidth * mHeight * 4);
+
+        for (int a=0; a < mWidth * mHeight; a++)
+        {
+            Tile tile = mLayers.at(i)->at(a);
+            int ldata;
+            if (tile.tileset != -1)
+            {
+                ldata = tile.index + mTilesets.at(tile.tileset)->firstgid;
+            } else {
+                ldata = 0;
+            }
+
+            binData[a * 4 + 0] = (ldata & 0x000000ff);
+            binData[a * 4 + 1] = (ldata & 0x0000ff00) >> 8;
+            binData[a * 4 + 2] = (ldata & 0x00ff0000) >> 16;
+            binData[a * 4 + 3] = (ldata & 0xff000000) >> 24;
+        }
+
+
+        // GZIP layer information
+        // Doesn't work yet.
+        /*
+        unsigned char* gzipData = (unsigned char*)malloc((mWidth * mHeight * 4) + 128);
+        unsigned int gzipLen;
+        compressMemory (binData, (mWidth * mHeight * 4) + 128, gzipData, gzipLen);
+        free (binData);
+        std::cout<<"GZIP length: "<<gzipLen<<std::endl;
+        */
+
+        //encode layer information in base64
+        unsigned char* base64Data;
+        int base64len;
+        //base64Data = php3_base64_encode(gzipData, gzipLen, &base64len);
+        base64Data = php3_base64_encode(binData, (mWidth * mHeight * 4), &base64len);
+        //free(gzipData);
+
+        xmlNodePtr newNode;
+        xmlAddChild(rootNode, xmlNewDocText(mXmlDoc, BAD_CAST " "));
+        newNode = xmlNewNode(NULL, BAD_CAST "layer");
+        xmlNewProp(newNode, BAD_CAST "name", BAD_CAST ("Layer" + toString(i)).c_str());
+        xmlNewProp(newNode, BAD_CAST "width", BAD_CAST toString(mWidth).c_str());
+        xmlNewProp(newNode, BAD_CAST "height", BAD_CAST toString(mHeight).c_str());
+        xmlAddChild(newNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n  "));
+        xmlNodePtr dataNode = xmlNewNode(NULL, BAD_CAST "data");
+        xmlNewProp(dataNode, BAD_CAST "encoding", BAD_CAST "base64");
+        //xmlNewProp(dataNode, BAD_CAST "compression", BAD_CAST "gzip");
+        xmlAddChild(dataNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n   "));
+        xmlAddChild(dataNode, xmlNewDocText(mXmlDoc, BAD_CAST base64Data));
+        xmlAddChild(dataNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n  "));
+        xmlAddChild(newNode, dataNode);
+        xmlAddChild(newNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n "));
+        xmlAddChild(rootNode, newNode);
+        xmlAddChild(rootNode, xmlNewDocText(mXmlDoc, BAD_CAST "\n"));
+    }
+
+    //save XML tree
+    int retval = xmlSaveFile(filename.c_str(), mXmlDoc);
+
+    if (retval == -1)
+    {
+        std::cerr<<"Could not write outfile "<<filename<<std::endl;
+        return false;
+    }
+    else
+    {
+        std::cout<<"File saved successfully to"<<filename<<std::endl;
+        return true;
+    }
+}
diff --git a/tools/tmxcopy/map.hpp b/tools/tmxcopy/map.hpp
new file mode 100644
index 00000000..89ae1405
--- /dev/null
+++ b/tools/tmxcopy/map.hpp
@@ -0,0 +1,81 @@
+/*
+ *  TMXCopy
+ *  Copyright 2007 Philipp Sehmisch
+ *
+ *
+ *  TMXCopy is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  TMXCopy is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with TMXCopy; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <string>
+#include <vector>
+#include <set>
+#include <libxml/parser.h>
+
+struct Tileset
+{
+    std::string imagefile;
+    int firstgid;
+    std::string name;
+    int tilewidth;
+    int tileheight;
+
+    bool operator== (Tileset const& a)
+    {
+        return (imagefile == a.imagefile &&
+                tilewidth == a.tilewidth &&
+                tileheight == a.tileheight
+                );
+    }
+};
+
+struct Tile
+{
+    int tileset; // number of tileset
+    size_t index; // index in said tileset
+};
+
+typedef std::vector<Tile> Layer;
+
+class Map
+{
+    public:
+        Map(std::string filename);
+
+        bool overwrite(  Map* srcMap,
+                    int srcX, int srcY, int srcWidth, int srcHeight,
+                    int destX, int destY);
+
+        int save(std::string filename);
+
+        int getNumberOfLayers() { return mLayers.size(); }
+
+        Layer* getLayer(size_t num) { return mLayers.at(num); }
+
+        std::vector<Tileset*>* getTilesets() { return &mTilesets; }
+
+        int getWidth() { return mWidth; }
+        int getHeight() { return mHeight; }
+
+    private:
+        std::vector<Layer*> mLayers;
+
+        int mWidth;
+        int mHeight;
+        int mMaxGid;
+
+        std::vector<Tileset*> mTilesets;
+
+        xmlDocPtr mXmlDoc;
+};
diff --git a/tools/tmxcopy/readme.txt b/tools/tmxcopy/readme.txt
new file mode 100644
index 00000000..e4235b94
--- /dev/null
+++ b/tools/tmxcopy/readme.txt
@@ -0,0 +1,34 @@
+Tmxcopy is a little tool that allows to copy parts of one TMX map to another map. This will make it much easier to match the border areas of maps. The program is command line based. The usage is:
+
+tmxcopy sourceFile x y height width targetFile x y [outputFile]
+
+
+Here an example: 
+When you want to copy the lower right corner (20x20 tiles) of mapA.tmx to the upper left corner of mapB.txt you would open map A with tiled and check at which coordinates the area you want to copy begins. Let's say mapA is 120x130 tiles. Then the area you want to copy would begin at 100:110 and would be 20x20 tiles large. So the first part of the command is:
+
+ tmxcopy mapA.tmx 100 110 20 20
+
+Then you open the target map to check the coordinates where you want to put the copied map part. We want the upper left corner, so the coordinates are 0:0. That means the next part of the command would be:
+ 
+ mapB.tmx 0 0
+
+The command is now complete:
+
+ tmxcopy mapA.tmx 100 110 20 20 mapB.tmx 0 0
+
+But when you enter this command the mapB will be overwritten. This could be a problem when you made an error in the command. So it is saver to write the output to a new map file so we can look at the result in Tiled before we replace the original map:
+
+ tmxcopy mapA.tmx 100 110 20 20 mapB.tmx 0 0 temp.tmx
+
+Now we can check temp.tmx to see if the copying worked correctly. 
+
+
+The program works so far but there are still some minor problems: 
+
+-Only tested for TMW-compilant maps. I don't guarantee that it works with Tiled maps that are made for other games and thus use different features. It is assumed that the target map and the source maps have the same number of layers, for example. 
+-Compressed maps (tmx.gz) can not be handled yet (but compressed or uncompressed layers work properly) 
+-When the target map has an object layer it is moved to the bottom of the layer list of the map (no problem for the game but inconvenient for editing). Objects on the source map are ignored. 
+-Layer data of output file isn't gzip-compressed yet 
+-Created TMX file is a bit malformated (but working properly) 
+
+The last 2 problems can be solved easily by opening and saving the map in Tiled.
\ No newline at end of file
diff --git a/tools/tmxcopy/tmxcopy.cbp b/tools/tmxcopy/tmxcopy.cbp
new file mode 100644
index 00000000..90105493
--- /dev/null
+++ b/tools/tmxcopy/tmxcopy.cbp
@@ -0,0 +1,87 @@
+<?xml version="1.0"?>
+<!DOCTYPE CodeBlocks_project_file>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="1"/>
+	<Project>
+		<Option title="tmxcopy"/>
+		<Option makefile="Makefile"/>
+		<Option makefile_is_custom="0"/>
+		<Option active_target="0"/>
+		<Option compiler="0"/>
+		<Build>
+			<Target title="default">
+				<Option output="tmxcopy.exe"/>
+				<Option working_dir="."/>
+				<Option object_output=".objs"/>
+				<Option deps_output=".deps"/>
+				<Option type="1"/>
+				<Option compiler="0"/>
+				<Option projectResourceIncludeDirsRelation="1"/>
+			</Target>
+		</Build>
+		<Linker>
+			<Add library="libxml2"/>
+			<Add library="libz"/>
+		</Linker>
+		<Unit filename="base64.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="base64.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="main.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="map.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="map.hpp">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="tostring.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="xmlutils.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="xmlutils.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="zlibutils.cpp">
+			<Option compilerVar="CPP"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+		<Unit filename="zlibutils.h">
+			<Option compilerVar=""/>
+			<Option compile="0"/>
+			<Option link="0"/>
+			<Option target="default"/>
+			<Option target="release"/>
+		</Unit>
+	</Project>
+</CodeBlocks_project_file>
diff --git a/tools/tmxcopy/tostring.h b/tools/tmxcopy/tostring.h
new file mode 100644
index 00000000..95b8985f
--- /dev/null
+++ b/tools/tmxcopy/tostring.h
@@ -0,0 +1,37 @@
+/*
+ *  The Mana World
+ *  Copyright 2004 The Mana World Development Team
+ *
+ *  This file is part of The Mana World.
+ *
+ *  The Mana World is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  The Mana World is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with The Mana World; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *  $Id$
+ */
+
+#ifndef _TMW_UTILS_TOSTRING_H
+#define _TMW_UTILS_TOSTRING_H
+
+#include <sstream>
+
+template<typename T>
+std::string toString(const T &arg)
+{
+    std::stringstream ss;
+    ss << arg;
+    return ss.str();
+}
+
+#endif
diff --git a/tools/tmxcopy/xmlutils.cpp b/tools/tmxcopy/xmlutils.cpp
new file mode 100644
index 00000000..47bff51a
--- /dev/null
+++ b/tools/tmxcopy/xmlutils.cpp
@@ -0,0 +1,76 @@
+/*
+ *  The Mana World
+ *  Copyright 2004 The Mana World Development Team
+ *
+ *  This file is part of The Mana World.
+ *
+ *  The Mana World is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  The Mana World is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with The Mana World; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "xmlutils.h"
+
+namespace XML
+{
+    int
+    getProperty(xmlNodePtr node, const char* name, int def)
+    {
+        int &ret = def;
+
+        xmlChar *prop = xmlGetProp(node, BAD_CAST name);
+        if (prop) {
+            ret = atoi((char*)prop);
+            xmlFree(prop);
+        }
+
+        return ret;
+    }
+
+    double
+    getFloatProperty(xmlNodePtr node, const char* name, double def)
+    {
+        double &ret = def;
+
+        xmlChar *prop = xmlGetProp(node, BAD_CAST name);
+        if (prop) {
+            ret = atof((char*)prop);
+            xmlFree(prop);
+        }
+
+        return ret;
+    }
+
+    std::string
+    getProperty(xmlNodePtr node, const char *name, const std::string &def)
+    {
+        xmlChar *prop = xmlGetProp(node, BAD_CAST name);
+        if (prop) {
+            std::string val = (char*)prop;
+            xmlFree(prop);
+            return val;
+        }
+
+        return def;
+    }
+
+    xmlNodePtr findFirstChildByName(xmlNodePtr parent, const char *name)
+    {
+        for_each_xml_child_node(child, parent)
+            if (xmlStrEqual(child->name, BAD_CAST name))
+                return child;
+
+        return NULL;
+    }
+}
diff --git a/tools/tmxcopy/xmlutils.h b/tools/tmxcopy/xmlutils.h
new file mode 100644
index 00000000..32d1a960
--- /dev/null
+++ b/tools/tmxcopy/xmlutils.h
@@ -0,0 +1,62 @@
+/*
+ *  The Mana World
+ *  Copyright 2004 The Mana World Development Team
+ *
+ *  This file is part of The Mana World.
+ *
+ *  The Mana World is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  The Mana World is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with The Mana World; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ifndef _XMLUTILS_H
+#define _XMLUTILS_H
+
+#include <libxml/tree.h>
+
+#include <string>
+
+/**
+ * XML helper functions.
+ */
+namespace XML
+{
+    /**
+     * Gets an integer property from an xmlNodePtr.
+     */
+    int
+    getProperty(xmlNodePtr node, const char *name, int def);
+
+    /**
+     * Gets an floating point property from an xmlNodePtr.
+     */
+    double
+    getFloatProperty(xmlNodePtr node, const char *name, double def);
+
+    /**
+     * Gets a string property from an xmlNodePtr.
+     */
+    std::string
+    getProperty(xmlNodePtr node, const char *name, const std::string &def);
+
+    /**
+     * Finds the first child node with the given name
+     */
+    xmlNodePtr findFirstChildByName(xmlNodePtr parent, const char *name);
+}
+
+#define for_each_xml_child_node(var, parent) \
+    for (xmlNodePtr var = parent->xmlChildrenNode; var; var = var->next)
+
+#endif
diff --git a/tools/tmxcopy/zlibutils.cpp b/tools/tmxcopy/zlibutils.cpp
new file mode 100644
index 00000000..30c762b2
--- /dev/null
+++ b/tools/tmxcopy/zlibutils.cpp
@@ -0,0 +1,123 @@
+
+#include <stdlib.h>
+#include <iostream>
+#include <cassert>
+#include <zlib.h>
+
+/**
+ * Inflates either zlib or gzip deflated memory. The inflated memory is
+ * expected to be freed by the caller.
+ */
+int
+inflateMemory(unsigned char *in, unsigned int inLength,
+              unsigned char *&out, unsigned int &outLength)
+{
+    int bufferSize = 256 * 1024;
+    int ret;
+    z_stream strm;
+
+    out = (unsigned char*) malloc(bufferSize);
+
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.next_in = in;
+    strm.avail_in = inLength;
+    strm.next_out = out;
+    strm.avail_out = bufferSize;
+
+    ret = inflateInit2(&strm, 15 + 32);
+
+    if (ret != Z_OK)
+        return ret;
+
+    do
+    {
+        if (strm.next_out == NULL)
+        {
+            inflateEnd(&strm);
+            return Z_MEM_ERROR;
+        }
+
+        ret = inflate(&strm, Z_NO_FLUSH);
+        assert(ret != Z_STREAM_ERROR);
+
+        switch (ret) {
+            case Z_NEED_DICT:
+                ret = Z_DATA_ERROR;
+            case Z_DATA_ERROR:
+            case Z_MEM_ERROR:
+                (void) inflateEnd(&strm);
+                return ret;
+        }
+
+        if (ret != Z_STREAM_END)
+        {
+            out = (unsigned char*) realloc(out, bufferSize * 2);
+
+            if (out == NULL)
+            {
+                inflateEnd(&strm);
+                return Z_MEM_ERROR;
+            }
+
+            strm.next_out = out + bufferSize;
+            strm.avail_out = bufferSize;
+            bufferSize *= 2;
+        }
+    }
+    while (ret != Z_STREAM_END);
+    assert(strm.avail_in == 0);
+
+    outLength = bufferSize - strm.avail_out;
+    (void) inflateEnd(&strm);
+    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
+}
+
+int
+inflateMemory(unsigned char *in, unsigned int inLength,
+              unsigned char *&out)
+{
+    unsigned int outLength = 0;
+    int ret = inflateMemory(in, inLength, out, outLength);
+
+    if (ret != Z_OK || out == NULL)
+    {
+        if (ret == Z_MEM_ERROR)
+        {
+            std::cerr<<"Error: Out of memory while decompressing map data!";
+        }
+        else if (ret == Z_VERSION_ERROR)
+        {
+            std::cerr<<"Error: Incompatible zlib version!";
+        }
+        else if (ret == Z_DATA_ERROR)
+        {
+            std::cerr<<"Error: Incorrect zlib compressed data!";
+        }
+        else
+        {
+            std::cerr<<"Error: Unknown error while decompressing map data!";
+        }
+
+        free(out);
+        out = NULL;
+        outLength = 0;
+    }
+
+    return outLength;
+}
+
+/*
+ * This function doesn't work like it should. The output is not decompressable.
+ */
+int
+compressMemory(unsigned char *in, unsigned int inLength,
+              unsigned char *&out, unsigned int &outLength)
+{
+    uLongf fOutLen = outLength;
+    int ret = compress((Bytef*)out, &fOutLen, (Bytef*)in, inLength);
+    outLength = fOutLen;
+
+    assert (ret == Z_OK);
+}
diff --git a/tools/tmxcopy/zlibutils.h b/tools/tmxcopy/zlibutils.h
new file mode 100644
index 00000000..300c72ad
--- /dev/null
+++ b/tools/tmxcopy/zlibutils.h
@@ -0,0 +1,11 @@
+int
+inflateMemory(unsigned char *in, unsigned int inLength,
+              unsigned char *&out, unsigned int &outLength);
+
+int
+inflateMemory(unsigned char *in, unsigned int inLength,
+              unsigned char *&out);
+
+int
+compressMemory(unsigned char *in, unsigned int inLength,
+              unsigned char *&out, unsigned int &outLength);
diff --git a/tools/upalyzer/analyze.php b/tools/upalyzer/analyze.php
new file mode 100644
index 00000000..106fcbb5
--- /dev/null
+++ b/tools/upalyzer/analyze.php
@@ -0,0 +1,177 @@
+<?php
+/*  analyze.php
+ *  Copyright 2007 Bjørn Lindeijer
+ *
+ *  This file is part of upalyzer.
+ *
+ *  upalyzer is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  upalyzer is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with upalyzer; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+header("Content-type: text/html");
+header("Cache-Control: no-store, no-cache, must-revalidate"); 
+header("Cache-Control: post-check=0, pre-check=0", false);
+header("Pragma: no-cache");
+
+?>
+<html>
+<head><title>Update analysis</title></head>
+<body>
+<pre>
+List of current updates:
+
+<?php
+$update_file = array_filter(array_reverse(file('resources2.txt')));
+$updates = array();
+$update_file_maxlen = 0;
+$data_size = 0;
+$data_uncompressed_size = 0;
+$data_used_size = 0;
+$data_overhead_size = 0;
+$update_entries = array();
+$update_entry_maxlen = 0;
+
+foreach ($update_file as $update_line)
+{
+  list($file, $hash) = explode(' ', trim($update_line), 2);
+  $update = array(
+    'file' => $file,
+    'adler32' => $hash,
+    'filesize' => filesize($file),
+    'size' => 0,
+    'used_entry_count' => 0,
+    'used_size' => 0,
+    'uncompressed_size' => 0);
+  $update_file_maxlen = max($update_file_maxlen, strlen($file));
+
+  $entries = array();
+  $zip = zip_open(realpath($file));
+
+  if ($zip && !is_int($zip)) {
+    while ($zip_entry = zip_read($zip)) {
+      $update['uncompressed_size'] += zip_entry_filesize($zip_entry);
+      $entry_name = zip_entry_name($zip_entry);
+      $entry_size = zip_entry_compressedsize($zip_entry);
+      $entry_used = !array_key_exists($entry_name, $update_entries);
+      $entries[$entry_name] = array(
+        'name' => $entry_name,
+        'size' => $entry_size,
+        'used' => $entry_used);
+      $update['size'] += $entry_size;
+
+      if ($entry_used) {
+        $update['used_entry_count']++;
+        $update['used_size'] += $entry_size;
+        $update_entries[$entry_name] = $update;
+      }
+
+      $update_entry_maxlen = max($update_entry_maxlen, strlen($entry_name));
+    }
+    zip_close($zip);
+  }
+  else {
+    $update['zip_error'] = $zip or true;
+  }
+
+  ksort($entries);
+  $update['entries'] = $entries;
+  $update['used_percentage'] = $update['used_size'] / $update['size'];
+  $updates[] = $update;
+
+  $data_used_size += $update['used_size'];
+  $data_size += $update['size'];
+  $data_uncompressed_size += $update['uncompressed_size'];
+  $data_overhead_size += $update['filesize'] - $update['size'];
+}
+
+function print_update_name($update, $pad = true)
+{
+  global $update_file_maxlen;
+  printf("<a href=\"#%s\">%s</a>", $update['file'], $update['file']);
+  if ($pad)
+    echo str_repeat(' ', $update_file_maxlen - strlen($update['file']));
+}
+
+// Print overall statistics
+
+foreach (array_reverse($updates) as $update)
+{
+  print_update_name($update);
+  echo '  '. $update['adler32'];
+  printf("  %4d kb", $update['filesize'] / 1024);
+  if (!$update['zip_error']) {
+    printf("  %4d kb", $update['uncompressed_size'] / 1024);
+    printf("  %3d%% used (%d/%d files)", $update['used_percentage'] * 100,
+                                         $update['used_entry_count'],
+                                         count($update['entries']));
+  } else {
+    printf("  Error! ");
+    if (is_int($update['zip_error']))
+      echo $update['zip_error'];
+  }
+  echo "\n";
+}
+
+printf("\n");
+printf("Amount of data: %4d kb (+%d kb zip file overhead)\n",
+    $data_size / 1024,
+    $data_overhead_size / 1024);
+printf("Uncompressed:   %4d kb\n", $data_uncompressed_size / 1024);
+printf("Obsoleted data: %4d kb (%d%%)\n",
+    ($data_size - $data_used_size) / 1024,
+    100 - ($data_used_size / $data_size) * 100);
+
+printf("\n");
+
+
+// Print list of update entries and the update they are loaded from
+
+ksort($update_entries);
+
+foreach ($update_entries as $entry => $update)
+{
+  printf("%-{$update_entry_maxlen}s  ", $entry);
+  print_update_name($update, false);
+  echo "\n";
+}
+
+
+// For each update, print its list of files and indicate whether they are used
+
+foreach (array_reverse($updates) as $update)
+{
+  print "\n<a name=\"".$update['file']."\"/><b>".$update['file']."</b>\n";
+
+  foreach ($update['entries'] as $entry_name => $entry) {
+    printf("%-{$update_entry_maxlen}s", $entry_name);
+    if ($entry['used']) {
+      echo '  *';
+    } else {
+      echo '  ';
+      print_update_name($update_entries[$entry_name], false);
+    }
+    echo "\n";
+  }
+}
+
+/*
+if ($dh = opendir('.')) {
+  while (($file = readdir($dh)) !== false) {
+  }
+  closedir($dh);
+}
+*/
+?>
+</pre>
+</body>
+</html>