From 3eeae12c498d1a4dbe969462d2ba841f77ee3ccb Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sun, 2 Jan 2011 01:48:38 +0200 Subject: Initial commit. This code based on mana client http://www.gitorious.org/mana/mana and my private repository. --- tools/tmxcopy/base64.cpp | 148 +++++++++ tools/tmxcopy/base64.h | 36 ++ tools/tmxcopy/map.cpp | 679 ++++++++++++++++++++++++++++++++++++++ tools/tmxcopy/map.hpp | 183 ++++++++++ tools/tmxcopy/readme.txt | 104 ++++++ tools/tmxcopy/tmx_random_fill.cpp | 115 +++++++ tools/tmxcopy/tmxcollide.cpp | 103 ++++++ tools/tmxcopy/tmxcopy.cbp | 39 +++ tools/tmxcopy/tmxcopy.cpp | 106 ++++++ tools/tmxcopy/tostring.h | 35 ++ tools/tmxcopy/xmlutils.cpp | 75 +++++ tools/tmxcopy/xmlutils.h | 61 ++++ tools/tmxcopy/zlibutils.cpp | 122 +++++++ tools/tmxcopy/zlibutils.h | 11 + 14 files changed, 1817 insertions(+) create mode 100644 tools/tmxcopy/base64.cpp create mode 100644 tools/tmxcopy/base64.h create mode 100644 tools/tmxcopy/map.cpp create mode 100644 tools/tmxcopy/map.hpp create mode 100644 tools/tmxcopy/readme.txt create mode 100644 tools/tmxcopy/tmx_random_fill.cpp create mode 100644 tools/tmxcopy/tmxcollide.cpp create mode 100644 tools/tmxcopy/tmxcopy.cbp create mode 100644 tools/tmxcopy/tmxcopy.cpp create mode 100644 tools/tmxcopy/tostring.h create mode 100644 tools/tmxcopy/xmlutils.cpp create mode 100644 tools/tmxcopy/xmlutils.h create mode 100644 tools/tmxcopy/zlibutils.cpp create mode 100644 tools/tmxcopy/zlibutils.h (limited to 'tools/tmxcopy') 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 +#include + +#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 + */ + + 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 . + */ + +#include +#include +#include + +#include +#include +#include +#include + +#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 "<name, BAD_CAST "map")) { + std::cerr<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, 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 "<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 "<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 "< Map::addAndTranslateTilesets(const Map* srcMap) +{ + std::map translation; + translation[-1] = -1; + std::vector* srcTilesets = const_cast(srcMap)->getTilesets(); + + for (std::vector::size_type a = 0; a < srcTilesets->size(); a++) + { + std::vector::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!"< srcMap->getHeight()) { + std::cerr<<"Error: Area exceeds lower map border of source map!"< mWidth) { + std::cerr<<"Error: Area exceeds right map border of target map!"< mHeight) { + std::cerr<<"Error: Area exceeds lower map border of target map!"<getNumberOfLayers() > mLayers.size()) { + std::cerr<<"Error: Source has more layers than target map"<getNumberOfLayers(); i++) + { + Layer* srcLayer = srcMap->getLayer(i); + Layer* destLayer = getLayer(srcLayer->getName()); + if (!destLayer) + { + std::cerr<<"Error: target map has no layer named \""<getName()<<"\""< 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 "<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!"< mWidth) + { + std::cerr<<"Error: Area exceeds right map border of target map!"< mHeight) + { + std::cerr<<"Error: Area exceeds lower map border of target map!"<getWidth()) + { + std::cerr<<"Error: Template is wider than target area"<getHeight()) + { + std::cerr<<"Error: Template is higher than target area"<getNumberOfLayers() == 0) + { + std::cerr<<"Error: Template has no layers"< translation = addAndTranslateTilesets(templateMap); + + + Layer* destLayer = getLayer(destLayerName); + if (!destLayer) + { + destLayer = new Layer(destLayerName, mWidth * mHeight); + mLayers.push_back(destLayer); + std::cout<<"Created new layer "< 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_ygetHeight(); loop_y++) + { + for (int loop_x=0; loop_xgetWidth(); 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_ygetHeight(); loop_y++) + { + for (int loop_x=0; loop_xgetWidth(); 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" <getNumberOfLayers() != 2) + { + std::cerr<<"Error: template should have exactly 2 layers"< tilesetTranslation = addAndTranslateTilesets(templateMap); + + //Lacking a better name, we'll say this is translating visible layers to collision + std::map 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 "<::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::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 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: "<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 "<::iterator layer = mLayers.begin(); + layer != mLayers.end(); + layer++) + { + if ((*layer)->getName() == name) + return *layer; + } + return NULL; +} + +Map::~Map() +{ + for (std::vector::iterator layer = mLayers.begin(); + layer != mLayers.end(); + layer++) + { + delete *layer; + } + + for (std::vector::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 . + */ + +#include +#include +#include +#include +#include + +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 */ + 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 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* getTilesets() { return &mTilesets; } + + int getWidth() { return mWidth; } + int getHeight() { return mHeight; } + + private: + std::map addAndTranslateTilesets(const Map* srcMap); + + std::vector mLayers; + + int mWidth; + int mHeight; + int mMaxGid; + + std::vector 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 . + */ + +#include +#include +#include + +#include "map.hpp" + +void printUsage() +{ + std::cerr<<"Usage: tmx_random_fill [-c] mapFile destLayer x y width height templateFile [-o outfile]"< 7) + { + std::cerr<<"Too many args"<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 . + */ + +#include +#include +#include + +#include "map.hpp" + +void printUsage() +{ + std::cerr<<"Usage: tmxcollide [-c] mapFile destLayer templateFile [-o outfile]"< 3) + { + std::cerr<<"Too many args"<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 @@ + + + + + + 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 . + */ + +#include +#include +#include + +#include "map.hpp" + +void printUsage() +{ + std::cerr<<"Usage: tmxcopy [-c] [-n] srcFile x y width height tgtFile x y [outfile]"< 9) + { + std::cerr<<"Too many args"<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 . + */ + +#ifndef UTILS_TOSTRING_H +#define UTILS_TOSTRING_H + +#include + +template +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 . + */ + +#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 . + */ + +#ifndef _XMLUTILS_H +#define _XMLUTILS_H + +#include + +#include + +/** + * 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 +#include +#include +#include + +/** + * 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); -- cgit v1.2.3-70-g09d2