def convertV1toV2(self, fileName):
        reader = MapReader()
        map = reader.readMap(fileName)
        if (not map):
            qWarning("Error at conversion of " + fileName + ":\n" +
                     reader.errorString())
            return

        for layer in map.layers():
            if (layer.name().lower().startswith("ruleset")):
                layer.setName("Input_set")
            elif (layer.name().lower().startswith("rulenotset")):
                layer.setName("InputNot_set")
            elif (layer.name().lower().startswith("ruleregions")):
                layer.setName("Regions")
            elif (layer.name().lower().startswith("rule")):
                newname = layer.name().right(layer.name().length() - 4)
                layer.setName("Output" + newname)
            else:
                qWarning(
                    QString("Warning at conversion of") + fileName +
                    QString("unused layers found"))

        writer = MapWriter()
        writer.writeMap(map.data(), fileName)
        map.tilesets().clear()
Beispiel #2
0
    def viewMap(self, fileName):
        del self.mRenderer
        self.mRenderer = None
        self.mScene.clear()
        self.centerOn(0, 0)
        reader = MapReader()
        self.mMap = reader.readMap(fileName)
        if (not self.mMap):
            qWarning("Error:"+reader.errorString())
            return False

        x = self.mMap.orientation()
        if x==Map.Orientation.Isometric:
            self.mRenderer = IsometricRenderer(self.mMap)
        elif x==Map.Orientation.Staggered:
            self.mRenderer = StaggeredRenderer(self.mMap)
        elif x==Map.Orientation.Hexagonal:
            self.mRenderer = HexagonalRenderer(self.mMap)
        else:
            self.mRenderer = OrthogonalRenderer(self.mMap)

        self.mScene.addItem(MapItem(self.mMap, self.mRenderer))
        return True
Beispiel #3
0
    def render(self, mapFileName, imageFileName):
        map = None
        renderer = None
        reader = MapReader()
        map = reader.readMap(mapFileName)
        if (not map):
            qWarning("Error while reading " + mapFileName + ":\n" +
                     reader.errorString())
            return 1

        x = map.orientation()
        if x == Map.Orientation.Isometric:
            renderer = IsometricRenderer(map)
        elif x == Map.Orientation.Staggered:
            renderer = StaggeredRenderer(map)
        elif x == Map.Orientation.Hexagonal:
            renderer = HexagonalRenderer(map)
        else:
            renderer = OrthogonalRenderer(map)

        if (self.mTileSize > 0):
            xScale = self.mTileSize / map.tileWidth()
            yScale = self.mTileSize / map.tileHeight()
        else:
            xScale = yScale = self.mScale

        mapSize = renderer.mapSize()
        margins = map.computeLayerOffsetMargins()
        mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
        mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())

        mapSize.setWidth(mapSize.width() * xScale)
        mapSize.setHeight(mapSize.height() * yScale)
        image = QImage(mapSize, QImage.Format_ARGB32)
        image.fill(Qt.transparent)
        painter = QPainter(image)
        if (xScale != 1.0 or yScale != 1.0):
            if (self.mUseAntiAliasing):
                painter.setRenderHints(QPainter.SmoothPixmapTransform
                                       | QPainter.Antialiasing)

            painter.setTransform(QTransform.fromScale(xScale, yScale))

        painter.translate(margins.left(), margins.top())

        # Perform a similar rendering than found in exportasimagedialog.py
        for layer in map.layers():
            if (not self.shouldDrawLayer(layer)):
                continue
            painter.setOpacity(layer.opacity())
            painter.translate(layer.offset())
            tileLayer = layer
            imageLayer = layer
            tp = type(layer)
            if tp == TileLayer:
                renderer.drawTileLayer(painter, tileLayer)
            elif tp == ImageLayer:
                renderer.drawImageLayer(painter, imageLayer)
            painter.translate(-layer.offset())
        painter.end()

        # Save image
        imageWriter = QImageWriter(imageFileName)
        if (not imageWriter.write(image)):
            qWarning("Error while writing " + imageFileName + ": " +
                     imageWriter.errorString())
            return 1

        return 0
Beispiel #4
0
    def render(self, mapFileName, imageFileName):
        map = None
        renderer = None
        reader = MapReader()
        map = reader.readMap(mapFileName)
        if (not map):
            qWarning("Error while reading " + mapFileName + ":\n" + reader.errorString())
            return 1

        x = map.orientation()
        if x==Map.Orientation.Isometric:
            renderer = IsometricRenderer(map)
        elif x==Map.Orientation.Staggered:
            renderer = StaggeredRenderer(map)
        elif x==Map.Orientation.Hexagonal:
            renderer = HexagonalRenderer(map)
        else:
            renderer = OrthogonalRenderer(map)

        if (self.mTileSize > 0):
            xScale = self.mTileSize / map.tileWidth()
            yScale = self.mTileSize / map.tileHeight()
        else:
            xScale = yScale = self.mScale

        mapSize = renderer.mapSize()
        margins = map.computeLayerOffsetMargins()
        mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
        mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
    
        mapSize.setWidth(mapSize.width()*xScale)
        mapSize.setHeight(mapSize.height()*yScale)
        image = QImage(mapSize, QImage.Format_ARGB32)
        image.fill(Qt.transparent)
        painter = QPainter(image)
        if (xScale != 1.0 or yScale != 1.0):
            if (self.mUseAntiAliasing):
                painter.setRenderHints(QPainter.SmoothPixmapTransform |
                                       QPainter.Antialiasing)

            painter.setTransform(QTransform.fromScale(xScale, yScale))

        painter.translate(margins.left(), margins.top())
        
        # Perform a similar rendering than found in exportasimagedialog.py
        for layer in map.layers():
            if (not self.shouldDrawLayer(layer)):
                continue
            painter.setOpacity(layer.opacity())
            painter.translate(layer.offset())
            tileLayer = layer
            imageLayer = layer
            tp = type(layer)
            if tp == TileLayer:
                renderer.drawTileLayer(painter, tileLayer)
            elif tp == ImageLayer:
                renderer.drawImageLayer(painter, imageLayer)
            painter.translate(-layer.offset())
        painter.end()
        
        # Save image
        imageWriter = QImageWriter(imageFileName)
        if (not imageWriter.write(image)):
            qWarning("Error while writing " + imageFileName + ": " + imageWriter.errorString())
            return 1
    
        return 0