Initial commit.

This code based on mana client http://www.gitorious.org/mana/mana
and my private repository.

14 files changed, 1817 insertions, 0 deletions

diff --git a/tools/tmxcopy/base64.cpp b/tools/tmxcopy/base64.cpp
new file mode 100644
index 000000000..8cea60f90
--- /dev/null
+++ b/tools/tmxcopy/base64.cpp
@@ -0,0 +1,148 @@
+/*
+   +----------------------------------------------------------------------+
+   | 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)                                  |
+   +----------------------------------------------------------------------+
+   */
+
+#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 000000000..92c230169
--- /dev/null
+++ b/tools/tmxcopy/base64.h
@@ -0,0 +1,36 @@
+/*
+   +----------------------------------------------------------------------+
+   | 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)                                  |
+   +----------------------------------------------------------------------+
+ */
+
+#ifndef BASE64_H
+#define 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 /* BASE64_H */
diff --git a/tools/tmxcopy/map.cpp b/tools/tmxcopy/map.cpp
new file mode 100644
index 000000000..3e1f9bdaf
--- /dev/null
+++ b/tools/tmxcopy/map.cpp
@@ -0,0 +1,679 @@
+/*
+ *  TMXCopy
+ *  Copyright (C) 2007  Philipp Sehmisch
+ *  Copyright (C) 2009  Steve Cotton
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstring>
+#include <iostream>
+#include <list>
+
+#include <string.h>
+#include <zlib.h>
+#include <cassert>
+#include <ctime>
+
+#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"))
+        {
+            //build layer information
+            std::string name = XML::getProperty(node, "name", "");
+            Layer* layer = new Layer(name, mWidth * mHeight);
+            if (
+                (mWidth  != XML::getProperty(node, "width" , 0)) ||
+                (mHeight != XML::getProperty(node, "height", 0)) ||
+                (0       != XML::getProperty(node, "x"     , 0)) ||
+                (0       != XML::getProperty(node, "y"     , 0)))
+            {
+                std::cerr<<"Error: layer size does not match map size for layer \""<<name<<"\" in "<<filename<<std::endl;
+                throw 1;
+            }
+
+            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;
+}
+
+/**
+ * When copying tiles from another map, add new tilesets to this map, and return the translation table.
+ */
+std::map<int, int> Map::addAndTranslateTilesets(const Map* srcMap)
+{
+    std::map<int, int> translation;
+    translation[-1] = -1;
+    std::vector<Tileset*>* srcTilesets = const_cast<Map*>(srcMap)->getTilesets();
+
+    for (std::vector<Tileset*>::size_type a = 0; a < srcTilesets->size(); a++)
+    {
+        std::vector<Tileset*>::size_type 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;
+            Tileset* destTileset = new Tileset(*srcTilesets->at(a));
+            destTileset->firstgid = mMaxGid;//it is possible to get some holes in the gid index this way but who cares, we got 32bit.
+            mTilesets.push_back(destTileset);
+        }
+        translation[a] = b;
+    }
+    return translation;
+}
+
+bool Map::overwrite(  Map* srcMap,
+                    int srcX, int srcY, int srcWidth, int srcHeight,
+                    int destX, int destY,
+                    const ConfigurationOptions& config)
+{
+    //plausibility check of coordinates
+    bool checkPassed = true;
+    if (srcX + srcWidth > srcMap->getWidth()) {
+        std::cerr<<"Error: Area exceeds right map border of source map!"<<std::endl;
+        checkPassed = false;
+    }
+    if (srcY + srcHeight > srcMap->getHeight()) {
+        std::cerr<<"Error: Area exceeds lower map border of source map!"<<std::endl;
+        checkPassed = false;
+    }
+    if (destX + srcWidth > mWidth) {
+        std::cerr<<"Error: Area exceeds right map border of target map!"<<std::endl;
+        checkPassed = false;
+    }
+    if (destY + srcHeight > mHeight) {
+        std::cerr<<"Error: Area exceeds lower map border of target map!"<<std::endl;
+        checkPassed = false;
+    }
+    if (!config.createMissingLayers)
+    {
+        if (config.copyLayersByOrdinal)
+        {
+            if (srcMap->getNumberOfLayers() > mLayers.size()) {
+                std::cerr<<"Error: Source has more layers than target map"<<std::endl
+                         <<"(and the command-line \"create layers\" option was not used)"<<std::endl;
+                checkPassed = false;
+            }
+        }
+        else
+        {
+            for (size_t i = 0; i < srcMap->getNumberOfLayers(); i++)
+            {
+                Layer* srcLayer = srcMap->getLayer(i);
+                Layer* destLayer = getLayer(srcLayer->getName());
+                if (!destLayer)
+                {
+                    std::cerr<<"Error: target map has no layer named \""<<srcLayer->getName()<<"\""<<std::endl
+                         <<"(and the command-line \"create layers\" option was not used)"<<std::endl;
+                    checkPassed = false;
+                }
+            }
+        }
+    }
+
+    if (!checkPassed) return false;
+
+    std::map<int, int> translation = addAndTranslateTilesets(srcMap);
+
+
+    //combining layer information
+    for (size_t i = 0; i < srcMap->getNumberOfLayers(); i++)
+    {
+        Layer* srcLayer = srcMap->getLayer(i);
+        Layer* destLayer = NULL;
+        if (config.copyLayersByOrdinal)
+        {
+            if (i < mLayers.size())
+            {
+                destLayer = mLayers.at(i);
+            }
+        }
+        else
+        {
+            destLayer = getLayer(srcLayer->getName());
+        }
+
+        if (!destLayer)
+        {
+            assert(config.createMissingLayers); /* Tested earlier, in the checkPassed section */
+            /* Generate a name for the new layer, which must be
+             * unique in the target map, and should be unique in
+             * the source map (to avoid collisions later in the
+             * copying process).
+             * Start by trying the name of the source layer.
+             */
+            std::string name = srcLayer->getName();
+            if (getLayer(name))
+            {
+                int k=0;
+                do
+                {
+                    name = "Layer" + toString(k);
+                    k++;
+                } while (getLayer(name) || srcMap->getLayer(name));
+            }
+
+            destLayer = new Layer(name, mWidth * mHeight);
+            mLayers.push_back(destLayer);
+            std::cout<<"Created new layer "<<name<<std::endl;
+        }
+
+        for (int y=0; y<srcHeight; y++)
+        {
+
+            for (int x=0; x<srcWidth; 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;
+    return true;
+}
+
+bool Map::randomFill(Map* templateMap, const std::string& destLayerName,
+            int destX, int destY, int destWidth, int destHeight,
+            const ConfigurationOptions& config)
+{
+    //plausibility check of coordinates
+    bool checkPassed = true;
+    if (destX + destWidth > mWidth)
+    {
+        std::cerr<<"Error: Area exceeds right map border of target map!"<<std::endl;
+        checkPassed = false;
+    }
+    if (destY + destHeight > mHeight)
+    {
+        std::cerr<<"Error: Area exceeds lower map border of target map!"<<std::endl;
+        checkPassed = false;
+    }
+    if (destWidth < templateMap->getWidth())
+    {
+        std::cerr<<"Error: Template is wider than target area"<<std::endl;
+        checkPassed = false;
+    }
+    if (destWidth < templateMap->getHeight())
+    {
+        std::cerr<<"Error: Template is higher than target area"<<std::endl;
+        checkPassed = false;
+    }
+    if (templateMap->getNumberOfLayers() == 0)
+    {
+        std::cerr<<"Error: Template has no layers"<<std::endl;
+        checkPassed = false;
+    }
+    if (!config.createMissingLayers && !getLayer(destLayerName))
+    {
+        std::cerr<<"Error: target map has no layer named \""<<destLayerName<<"\""<<std::endl
+             <<"(and the command-line \"create layers\" option was not used)"<<std::endl;
+        checkPassed = false;
+    }
+    if (!checkPassed) return false;
+
+    std::map<int, int> translation = addAndTranslateTilesets(templateMap);
+
+
+    Layer* destLayer = getLayer(destLayerName);
+    if (!destLayer)
+    {
+        destLayer = new Layer(destLayerName, mWidth * mHeight);
+        mLayers.push_back(destLayer);
+        std::cout<<"Created new layer "<<destLayerName<<std::endl;
+    }
+
+    /* Now generate extra tiles.
+     *
+     * After considering ways to specify the number of objects to add, I think
+     * the best user interface (without integrating it with Tiled) is to place
+     * a small number of objects each time, and have the user run the utility
+     * several times, reloading the map in Tiled each time until it looks
+     * right.  Simpler than typing magic numbers in at a command prompt.
+     *
+     * This algorithm completes after a fixed number of attempts at placing an
+     * object; regardless of how many attempts are successful.
+     * For 2x1 trees, destWidth*destHeight/10 is very sparse, dW*dH/2 is dense.
+     */
+    srand(time(NULL));
+    int patternsGenerated = 0;
+    int occupiedAreas = 0;
+    for (int i = destWidth*destHeight / 10; i > 0; i--)
+    {
+        /* Pick a random location, with enough tiles left and down from it to
+         * fit the template in (the +1 is because it starts on tile (x,y))
+         */
+        int x = destX + (rand() % (destWidth  - templateMap->getWidth () + 1));
+        int y = destY + (rand() % (destHeight - templateMap->getHeight() + 1));
+
+        bool areaIsClear = true;
+
+        for (int loop_y=0; loop_y<templateMap->getHeight(); loop_y++)
+        {
+            for (int loop_x=0; loop_x<templateMap->getWidth(); loop_x++)
+            {
+                if (! destLayer->getTile(x+loop_x, y+loop_y, mWidth).empty())
+                {
+                    areaIsClear = false;
+                }
+            }
+        }
+
+        if (areaIsClear)
+        {
+            int p = rand() % templateMap->getNumberOfLayers();
+
+            Layer* srcLayer = templateMap->getLayer(p);
+            for (int loop_y=0; loop_y<templateMap->getHeight(); loop_y++)
+            {
+                for (int loop_x=0; loop_x<templateMap->getWidth(); loop_x++)
+                {
+                    Tile& srcTile  = srcLayer->getTile(loop_x, loop_y, templateMap->getWidth());
+                    Tile& destTile = destLayer->getTile(x+loop_x, y+loop_y, mWidth);
+                    destTile.tileset = translation[srcTile.tileset];
+                    destTile.index = srcTile.index;
+                }
+            }
+            patternsGenerated++;
+        }
+        else
+        {
+            occupiedAreas++;
+        }
+    }
+
+    std::clog<<"Generated " << patternsGenerated << " new objects" <<std::endl;
+    (void) occupiedAreas;  // Unused at the moment, but keep it without a compiler warning about unused variables
+    return true;
+}
+
+bool Map::translateAllLayers(Map* templateMap, const std::string& destLayerName,
+            const ConfigurationOptions& config)
+{
+    bool checkPassed = true;
+    if (templateMap->getNumberOfLayers() != 2)
+    {
+        std::cerr<<"Error: template should have exactly 2 layers"<<std::endl;
+        checkPassed = false;
+    }
+    if (!config.createMissingLayers && !getLayer(destLayerName))
+    {
+        std::cerr<<"Error: target map has no layer named \""<<destLayerName<<"\""<<std::endl
+             <<"(and the command-line \"create layers\" option was not used)"<<std::endl;
+        checkPassed = false;
+    }
+    if (!checkPassed) return false;
+
+    //TODO This will unnecessarily add tilesets that are in the template but
+    //not used in the main map
+    std::map<int, int> tilesetTranslation = addAndTranslateTilesets(templateMap);
+
+    //Lacking a better name, we'll say this is translating visible layers to collision
+    std::map<Tile, Tile> collisionTranslation;
+
+    Layer* fromLayer = templateMap->getLayer(0);
+    Layer* toLayer = templateMap->getLayer(1);
+    for (int xy = (templateMap->getWidth() * templateMap->getHeight() -1);
+        xy >= 0; xy--)
+    {
+        Tile fromTile = fromLayer->at(xy);
+        Tile toTile = toLayer->at(xy);
+        if (!fromTile.empty())
+        {
+            fromTile.tileset = tilesetTranslation[fromTile.tileset];
+            toTile.tileset = tilesetTranslation[toTile.tileset];
+
+            collisionTranslation[fromTile] = toTile;
+        }
+    }
+
+    /* Now apply that template to the game map */
+    Layer* destLayer = getLayer(destLayerName);
+    if (!destLayer)
+    {
+        destLayer = new Layer(destLayerName, mWidth * mHeight);
+        mLayers.push_back(destLayer);
+        std::cout<<"Created new layer "<<destLayerName<<std::endl;
+    }
+
+    for (std::vector<Layer*>::iterator layer = mLayers.begin();
+         layer != mLayers.end();
+         layer++)
+    {
+        if ((*layer)->getName() == destLayerName)
+            continue;
+
+        for (int xy = mWidth * mHeight -1; xy >= 0; xy--)
+        {
+            Tile& fromTile = (*layer)->at(xy);
+            Tile& toTile = destLayer->at(xy);
+            std::map<Tile,Tile>::iterator iteratedTile = collisionTranslation.find(fromTile);
+
+            if (iteratedTile != collisionTranslation.end())
+            {
+                toTile = (*iteratedTile).second;
+            }
+        }
+
+    }
+
+    return true;
+}
+
+
+
+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 (size_t 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 (size_t 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
+        /*
+        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 (mLayers.at(i)->getName()).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"));
+
+        free(base64Data);
+        free(binData);
+    }
+
+    //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;
+    }
+}
+
+Layer* Map::getLayer(std::string name)
+{
+    for (std::vector<Layer*>::iterator layer = mLayers.begin();
+         layer != mLayers.end();
+         layer++)
+    {
+        if ((*layer)->getName() == name)
+            return *layer;
+    }
+    return NULL;
+}
+
+Map::~Map()
+{
+    for (std::vector<Layer*>::iterator layer = mLayers.begin();
+         layer != mLayers.end();
+         layer++)
+    {
+         delete *layer;
+    }
+
+    for (std::vector<Tileset*>::iterator tileset = mTilesets.begin();
+         tileset != mTilesets.end();
+         tileset++)
+    {
+         delete *tileset;
+    }
+
+    xmlFreeDoc(mXmlDoc);
+}
diff --git a/tools/tmxcopy/map.hpp b/tools/tmxcopy/map.hpp
new file mode 100644
index 000000000..ff878811a
--- /dev/null
+++ b/tools/tmxcopy/map.hpp
@@ -0,0 +1,183 @@
+/*
+ *  TMXCopy
+ *  Copyright (C) 2007  Philipp Sehmisch
+ *  Copyright (C) 2009  Steve Cotton
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
+#include <libxml/parser.h>
+
+struct ConfigurationOptions
+{
+    /* When copying map layers, how to match source layer to
+     * destination layer.
+     *
+     * True: Pair the first layer to the first layer, the second
+     * to the second, etc.
+     *
+     * False: Pair up layers with matching names.
+     */
+    bool copyLayersByOrdinal;
+
+    /* Create extra layers in the target as necessary. */
+    bool createMissingLayers;
+};
+
+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
+                );
+    }
+
+    Tileset()
+    {
+    }
+
+    Tileset(const Tileset& src) :
+        imagefile(src.imagefile), firstgid(src.firstgid),
+        name(src.name),
+        tilewidth(src.tilewidth), tileheight(src.tileheight)
+    {
+    }
+
+};
+
+/**
+ * A tile in a layer of a map.
+ *
+ * With the exception of the emptyTile and empty() function,
+ * interpreting what this tile represents depends on the map it
+ * belongs to (specifically the ordering of that map's tilesets).
+ */
+struct Tile
+{
+    int tileset; // number of tileset
+    size_t index; // index in said tileset
+
+    bool empty()
+    {
+        return (tileset == -1);
+    }
+
+    /* This is to allow std::map<Tile,Tile> */
+    bool operator< (const Tile& b) const
+    {
+        return ((tileset < b.tileset) ||
+            ((tileset == b.tileset) && (index < b.index)));
+    }
+
+    bool operator!= (const Tile& b) const
+    {
+        return ((tileset != b.tileset) || (index != b.index));
+    }
+};
+
+typedef std::vector<Tile> LayerTiles;
+
+/* This represents an empty tile in the layer.
+ * Note that {0,0} would be the first tile in the first tileset.
+ */
+const Tile emptyTile = {-1, 0};
+
+class Layer
+{
+    public:
+        /* name - the name of the layer, as shown in Tiled
+         * tileCount - total number of tiles (width*height)
+         */
+        Layer(std::string name, LayerTiles::size_type tileCount)
+            : mTiles(tileCount, emptyTile),
+            mName (name)
+        {
+        }
+
+        std::string getName() { return mName; }
+        Tile& at(LayerTiles::size_type c) { return mTiles.at(c); }
+        Tile& getTile(int x, int y, int mapWidth) { return mTiles.at(x + y*mapWidth); }
+
+    private:
+        LayerTiles mTiles;
+        std::string mName;
+};
+
+class Map
+{
+    public:
+        Map(std::string filename);
+        ~Map();
+
+        /**
+         * Copies an area from srcMap, replacing its current contents.
+         */
+        bool overwrite(Map* srcMap,
+                    int srcX, int srcY, int srcWidth, int srcHeight,
+                    int destX, int destY,
+                    const ConfigurationOptions& config);
+
+        /**
+         * Fills an area of this map with random parts of the template.
+         * Currently, each layer of the template is treated as an object that
+         * should be copied in its entirity.
+         */
+        bool randomFill(Map* templateMap, const std::string& destLayerName,
+                    int destX, int destY, int destWidth, int destHeight,
+                    const ConfigurationOptions& config);
+
+        /**
+         * Translates a layer - using the template, generates collision from visible layers (for example).
+         * TODO - avoid confusion with the geometry term "translate"
+         */
+        bool translateAllLayers(Map* templateMap, const std::string& destLayerName,
+                    const ConfigurationOptions& config);
+
+        int save(std::string filename);
+
+        size_t getNumberOfLayers() { return mLayers.size(); }
+
+        Layer* getLayer(size_t num) { return mLayers.at(num); }
+        Layer* getLayer(std::string name);
+
+        std::vector<Tileset*>* getTilesets() { return &mTilesets; }
+
+        int getWidth() { return mWidth; }
+        int getHeight() { return mHeight; }
+
+    private:
+        std::map<int, int> addAndTranslateTilesets(const Map* srcMap);
+
+        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 000000000..d130edd60
--- /dev/null
+++ b/tools/tmxcopy/readme.txt
@@ -0,0 +1,104 @@
+=== TMX Map Tools ===
+
+A set of tools for manipulating TMX map files.
+
+After using any of these tools, load the map in Tiled and save it again; until this is done the game may not be able to load the file (see Bugs for an explanation).
+
+
+=== TMXCopy ===
+
+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 [-c] [-n] srcFile x y width height tgtFile x y [outfile]
+
+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. 
+
+
+Which layer gets copied to which:
+By default layers are copied to layers of the same name.  The -n option will make it copy by layer number instead.
+
+  mapA: Ground, Fringe, Over, Collision, Object
+  mapB: Ground, Fencing, Fringe, Over, Collision, Object
+  The default copies Ground->Ground, Fringe->Fringe, Over->Over, Collision->Collision (the object layer is not affected)
+  -n copies Ground->Ground, Fringe->Fencing, Over->Fringe, Collision->Over (mapB's collision and object layers are not affected)
+
+  mapA: Ground, Fringe, Over, Collision, Object
+  mapC: Ground, Fringe, Overhead, Collision, Object
+  The default quits with an error
+  -n copies Over->Overhead
+
+The -c option creates layers as needed.  Using it to copy mapB to mapA will add a Fencing layer to mapA.
+
+
+=== TMX Random Fill ===
+
+This is for generating big areas of woodland (or other things that want lots of randomly-placed patterns).
+
+Usage: tmx_random_fill mapFile destLayer x y width height templateFile [-o outfile]
+    -c create layers, if they don't already exist in the target
+    -o save results to outfile, instead of overwriting the original
+
+Fill a rectangular area of mapFile's layer 'destLayer' with a random selection from the templateFile.
+
+The template is a map where each layer is a pattern.  For example, to make a woodland:
+  Create a new 2x1 tile map (yes, this is tiny, and only the base of the tree will be visible).
+  Add the Woodland_x3 tileset, using the correct height (96 pixels).
+  Make a layer, add a tree.
+  Make a layer, add the second tree.
+  Make a layer, add the third tree.
+  Save this as template_trees.tmx
+  Run tmx_random_fill with the appropriate options (destLayer will be "Fringe")
+
+It will then randomly place trees, but only in places where they won't overlap with other things on that layer.  The size of the template map is the size of the area which must be empty in the destination layer.
+
+Running it several times (without specifying an output file) will add more objects.  After considering ways to specify the number of objects to add, I think the easiest is to just reload the map in Tiled each time until it looks right (you don't need to quit Tiled while running tmx_random_fill).
+
+
+=== TMX Collide / Translate ===
+
+A big woodland with lots of randomly-placed trees needs a complex collision layer, most of which can be generated from the visible layers.
+This tool does that automatic generation.
+
+It's not limited to adding collision tiles; it can be used for any task where tiles are added to one layer based on the tiles present in other layers.
+
+Usage: tmxcollide [-c] mapFile destLayer templateFile [-o outfile]
+    -c create layers, if they don't already exist in the target
+    -o save results to outfile, instead of overwriting the original
+
+To fill the collision layer, "destLayer" should be "Collision".
+
+As with TMX Random Fill, this tool takes a template map; for this tool it should have exactly two layers.
+  Upper layer: tiles to translate to (collision tiles)
+  Lower layer: tiles to translate from (visible tiles)
+Blank tiles in the lower layer will be ignored (put a blank in the upper layer too).
+
+
+=== Bugs (for all these programs) ===
+
+The programs work so far but there are still some minor problems:
+
+-Only tested for Mana-compilant maps. I don't guarantee that it works with Tiled maps that are made for other games and thus use different features.
+-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. 
+-All tilesets included in the srcFile (TMXCopy) or template (TMXRandomFill and TMXCollide) will be added to the output file, even if they aren't needed for the tiles that are added.
+-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.
diff --git a/tools/tmxcopy/tmx_random_fill.cpp b/tools/tmxcopy/tmx_random_fill.cpp
new file mode 100644
index 000000000..0039ff8b2
--- /dev/null
+++ b/tools/tmxcopy/tmx_random_fill.cpp
@@ -0,0 +1,115 @@
+/*
+ *  TMXRandomFill
+ *  Copyright (C) 2007  Philipp Sehmisch
+ *  Copyright (C) 2009  Steve Cotton
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <string>
+#include <unistd.h>
+
+#include "map.hpp"
+
+void printUsage()
+{
+    std::cerr<<"Usage: tmx_random_fill [-c] mapFile destLayer x y width height templateFile [-o outfile]"<<std::endl
+             <<"    -c create layers, if they don't already exist in the target"<<std::endl
+             <<"    -o save results to outfile, instead of overwriting the original"<<std::endl
+             <<std::endl
+             <<"Fill a rectangular area of mapFile's layer 'destLayer' with a random selection from the templateFile"<<std::endl
+             <<"See readme.txt for full documentation"<<std::endl;
+}
+
+int main(int argc, char * argv[] )
+{
+    ConfigurationOptions config = {0};
+    std::string outFile;
+
+    int opt;
+    while ((opt = getopt(argc, argv, "co:")) != -1)
+    {
+        switch (opt)
+        {
+            case 'c':
+                config.createMissingLayers = true;
+                break;
+            case 'o':
+                if (optarg)
+                {
+                    outFile = optarg;
+                } else {
+                    printUsage();
+                    return -1;
+                }
+                break;
+            case '?':
+                std::cerr<<"Unrecognized option"<<std::endl;
+                printUsage();
+                return -1;
+        }
+    }
+
+    if ((argc-optind) < 7)
+    {
+        std::cerr<<"Too few args"<<std::endl;
+        printUsage();
+        return -1;
+    }
+    if ((argc-optind) > 7)
+    {
+        std::cerr<<"Too many args"<<std::endl;
+        printUsage();
+        return -1;
+    }
+
+    std::string mapFile = argv[optind+0];
+    std::string destLayer = argv[optind+1];
+    int destX= atoi(argv[optind+2]);
+    int destY= atoi(argv[optind+3]);
+    int width= atoi(argv[optind+4]);
+    int height=atoi(argv[optind+5]);
+    std::string templateFile = argv[optind+6];
+    if (outFile.empty())
+    {
+        outFile = mapFile;
+    }
+
+    // plausibility check of command line options
+    if (height < 1 || width < 1 || destX < 0 || destY < 0)
+    {
+        std::cerr<<"Illegal coordinates!"<<std::endl;
+        printUsage();
+        return -1;
+    }
+
+    try
+    {
+        Map* mainMap = new Map(mapFile);
+        Map* templateMap = new Map(templateFile);
+        if (mainMap->randomFill(templateMap, destLayer, destX, destY, width, height, config))
+        {
+            mainMap->save(outFile);
+        } else {
+            return -1;
+        }
+        delete mainMap;
+        delete templateMap;
+    }
+    catch (int)
+    {
+        return -1;
+    }
+}
diff --git a/tools/tmxcopy/tmxcollide.cpp b/tools/tmxcopy/tmxcollide.cpp
new file mode 100644
index 000000000..75b0a6a27
--- /dev/null
+++ b/tools/tmxcopy/tmxcollide.cpp
@@ -0,0 +1,103 @@
+/*
+ *  TMXTranslate / TMXCollide
+ *  Copyright (C) 2007  Philipp Sehmisch
+ *  Copyright (C) 2009  Steve Cotton
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <string>
+#include <unistd.h>
+
+#include "map.hpp"
+
+void printUsage()
+{
+    std::cerr<<"Usage: tmxcollide [-c] mapFile destLayer templateFile [-o outfile]"<<std::endl
+             <<"    -c create layers, if they don't already exist in the target"<<std::endl
+             <<"    -o save results to outfile, instead of overwriting the original"<<std::endl
+             <<std::endl
+             <<"Using the template, translate visible layers to the collision layer"<<std::endl
+             <<"See readme.txt for full documentation"<<std::endl;
+}
+
+int main(int argc, char * argv[] )
+{
+    ConfigurationOptions config = {0};
+    std::string outFile;
+
+    int opt;
+    while ((opt = getopt(argc, argv, "co:")) != -1)
+    {
+        switch (opt)
+        {
+            case 'c':
+                config.createMissingLayers = true;
+                break;
+            case 'o':
+                if (optarg)
+                {
+                    outFile = optarg;
+                } else {
+                    printUsage();
+                    return -1;
+                }
+                break;
+            case '?':
+                std::cerr<<"Unrecognized option"<<std::endl;
+                printUsage();
+                return -1;
+        }
+    }
+
+    if ((argc-optind) < 3)
+    {
+        std::cerr<<"Too few args"<<std::endl;
+        printUsage();
+        return -1;
+    }
+    if ((argc-optind) > 3)
+    {
+        std::cerr<<"Too many args"<<std::endl;
+        printUsage();
+        return -1;
+    }
+
+    std::string mapFile = argv[optind+0];
+    std::string destLayer = argv[optind+1];
+    std::string templateFile = argv[optind+2];
+    if (outFile.empty())
+    {
+        outFile = mapFile;
+    }
+
+    try
+    {
+        Map* mainMap = new Map(mapFile);
+        Map* templateMap = new Map(templateFile);
+        if (mainMap->translateAllLayers(templateMap, destLayer, config))
+        {
+            mainMap->save(outFile);
+        } else {
+            return -1;
+        }
+        delete mainMap;
+        delete templateMap;
+    }
+    catch (int)
+    {
+        return -1;
+    }
+}
diff --git a/tools/tmxcopy/tmxcopy.cbp b/tools/tmxcopy/tmxcopy.cbp
new file mode 100644
index 000000000..237f6fdee
--- /dev/null
+++ b/tools/tmxcopy/tmxcopy.cbp
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="untitled" />
+		<Option pch_mode="0" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="default">
+				<Option output="TMXCopy.exe" prefix_auto="0" extension_auto="0" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Option projectResourceIncludeDirsRelation="1" />
+				<Linker>
+					<Add library="libxml2" />
+					<Add library="z" />
+				</Linker>
+			</Target>
+		</Build>
+		<VirtualTargets>
+			<Add alias="All" targets="default;" />
+		</VirtualTargets>
+		<Unit filename="base64.cpp" />
+		<Unit filename="base64.h" />
+		<Unit filename="main.cpp" />
+		<Unit filename="map.cpp" />
+		<Unit filename="map.hpp" />
+		<Unit filename="tostring.h" />
+		<Unit filename="xmlutils.cpp" />
+		<Unit filename="xmlutils.h" />
+		<Unit filename="zlibutils.cpp" />
+		<Unit filename="zlibutils.h" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>
diff --git a/tools/tmxcopy/tmxcopy.cpp b/tools/tmxcopy/tmxcopy.cpp
new file mode 100644
index 000000000..9c9655d71
--- /dev/null
+++ b/tools/tmxcopy/tmxcopy.cpp
@@ -0,0 +1,106 @@
+/*
+ *  TMXCopy
+ *  Copyright (C) 2007  Philipp Sehmisch
+ *  Copyright (C) 2009  Steve Cotton
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <string>
+#include <unistd.h>
+
+#include "map.hpp"
+
+void printUsage()
+{
+    std::cerr<<"Usage: tmxcopy [-c] [-n] srcFile x y width height tgtFile x y [outfile]"<<std::endl
+             <<"    -c create layers, if they don't already exist in the target"<<std::endl
+             <<"    -n copy layers by number, not name"<<std::endl;
+}
+
+int main(int argc, char * argv[] )
+{
+    ConfigurationOptions config = {0};
+    int opt;
+    while ((opt = getopt(argc, argv, "cn")) != -1)
+    {
+        switch (opt)
+        {
+            case 'c':
+                config.createMissingLayers = true;
+                break;
+            case 'n':
+                config.copyLayersByOrdinal = true;
+                break;
+            case '?':
+                std::cerr<<"Unrecognized option"<<std::endl;
+                printUsage();
+                return -1;
+        }
+    }
+
+    if ((argc-optind) < 8)
+    {
+        std::cerr<<"Too few args"<<std::endl;
+        printUsage();
+        return -1;
+    }
+    if ((argc-optind) > 9)
+    {
+        std::cerr<<"Too many args"<<std::endl;
+        printUsage();
+        return -1;
+    }
+
+    std::string srcFile = argv[optind+0];
+    int srcX= atoi(argv[optind+1]);
+    int srcY= atoi(argv[optind+2]);
+    int width= atoi(argv[optind+3]);
+    int height=atoi(argv[optind+4]);
+    std::string tgtFile = argv[optind+5];
+    int destX=atoi(argv[optind+6]);
+    int destY=atoi(argv[optind+7]);
+    std::string outFile = tgtFile;
+    if (argc == optind+9)
+    {
+        outFile = argv[optind+8];
+    }
+
+    // plausibility check of command line options
+    if (height < 1 || width < 1 || srcX < 0 || srcY < 0 || destX < 0 || destY < 0)
+    {
+        std::cerr<<"Illegal coordinates!"<<std::endl;
+        printUsage();
+        return -1;
+    }
+
+    try
+    {
+        Map* srcMap = new Map(srcFile);
+        Map* tgtMap = new Map(tgtFile);
+        if (tgtMap->overwrite(srcMap, srcX, srcY, width, height, destX, destY, config))
+        {
+            tgtMap->save(outFile);
+        } else {
+            return -1;
+        }
+        delete srcMap;
+        delete tgtMap;
+    }
+    catch (int)
+    {
+        return -1;
+    }
+}
diff --git a/tools/tmxcopy/tostring.h b/tools/tmxcopy/tostring.h
new file mode 100644
index 000000000..63c0a1a8c
--- /dev/null
+++ b/tools/tmxcopy/tostring.h
@@ -0,0 +1,35 @@
+/*
+ *  The Mana Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *
+ *  This file is part of The Mana Client.
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UTILS_TOSTRING_H
+#define 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 000000000..a4984a6a2
--- /dev/null
+++ b/tools/tmxcopy/xmlutils.cpp
@@ -0,0 +1,75 @@
+/*
+ *  The Mana Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *
+ *  This file is part of The Mana Client.
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#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 000000000..3d9c5d7a7
--- /dev/null
+++ b/tools/tmxcopy/xmlutils.h
@@ -0,0 +1,61 @@
+/*
+ *  The Mana Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *
+ *  This file is part of The Mana Client.
+ *
+ *  This program 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.
+ *
+ *  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 the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#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 000000000..39c19aeef
--- /dev/null
+++ b/tools/tmxcopy/zlibutils.cpp
@@ -0,0 +1,122 @@
+
+#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;
+}
+
+/*
+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 000000000..300c72ad9
--- /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);