def main():
mapfile = sys.argv[1] if len(sys.argv) >= 2 else 'pokegold-spaceworld.map'
filename = sys.argv[2] if len(sys.argv) >= 3 else 'mask.w1024.2bpp'
num_banks = 0x40
bank_mask = 0x3FFF
bank_size = 0x4000 # bytes
r = MapReader()
with open(mapfile, 'r', encoding='utf-8') as f:
l = f.readlines()
r.read_map_data(l)
default_bank_data = {'sections': [], 'used': 0, 'slack': bank_size}
with open(filename, 'wb') as f:
for bank in range(num_banks):
hits = bytearray([0x00] * bank_size)
data = r.bank_data['rom bank'].get(bank, default_bank_data)
for s in data['sections']:
if s['beg'] > s['end']:
continue
if s['beg'] == 0x0000 and s['end'] > 0xFFFF:
# https://github.com/gbdev/rgbds/issues/515
continue
beg = s['beg'] & bank_mask
end = s['end'] & bank_mask
for i in range(beg, end + 1):
hits[i] = 0xFF
f.write(hits)
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()
def upload(request):
if request.method == 'POST':
file = request.FILES['file']
if request.user.is_authenticated():
user = request.user
else:
user = None
try:
reader = MapReader(file, user=user)
_map = reader.read()
except GeocodingError as error:
return redirect('/error', error.value)
value = request.POST.get("action")
if value == "Download":
response = HttpResponse(
unicode(_map), content_type="text/csv")
response['Content-Disposition'] = 'inline; filename = output.csv'
return response
else:
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
return HttpResponseRedirect('maps/' + str(_map.id))
else:
form = UploadFileForm()
return render(request, 'latlong/index.html', {'form': form})
def main():
print_bank = 'none'
mapfile = 'pokecrystal11.map'
if len(sys.argv) >= 2 and sys.argv[1].startswith('BANK='):
print_bank = sys.argv[1].split('=', 1)[-1]
if len(sys.argv) >= 3:
mapfile = sys.argv[2]
elif len(sys.argv) >= 3 and sys.argv[2].startswith('BANK='):
print_bank = sys.argv[2].split('=', 1)[-1]
mapfile = sys.argv[1]
if print_bank not in {'all', 'none'}:
try:
if print_bank.startswith('0x') or print_bank.startswith('0X'):
print_bank = int(print_bank[2:], 16)
else:
print_bank = int(print_bank)
except ValueError:
error = 'Error: invalid BANK: %s' % print_bank
if print_bank.isalnum():
error += ' (did you mean: 0x%s?)' % print_bank
print(error, file=sys.stderr)
sys.exit(1)
num_banks = 0x80
bank_size = 0x4000 # bytes
total_size = num_banks * bank_size
r = MapReader()
with open(mapfile, 'r', encoding='utf-8') as f:
l = f.readlines()
r.read_map_data(l)
free_space = 0
per_bank = []
default_bank_data = {'sections': [], 'used': 0, 'slack': bank_size}
for bank in range(num_banks):
bank_data = r.bank_data['ROM0 bank'] if bank == 0 else r.bank_data[
'ROMX bank']
data = bank_data.get(bank, default_bank_data)
used = data['used']
slack = data['slack']
per_bank.append((used, slack))
free_space += slack
print('Free space: %d/%d (%.2f%%)' %
(free_space, total_size, free_space * 100.0 / total_size))
if print_bank != 'none':
print()
print('bank, used, free')
for bank in range(num_banks):
used, slack = per_bank[bank]
if print_bank in {'all', bank}:
print('$%02X, %d, %d' % (bank, used, slack))
def main():
mapfile = sys.argv[1] if len(sys.argv) >= 2 else 'pokegold-spaceworld.map'
filename = sys.argv[2] if len(sys.argv) >= 3 else 'coverage.png'
num_banks = 0x40
bank_mask = 0x3FFF
bank_size = 0x4000 # bytes
bpp = 8 # bytes per pixel
height = 256 # pixels
assert bank_size % bpp == 0 and (bank_size // bpp) % height == 0
pixels_per_bank = bank_size // bpp # 2048 pixels
bank_width = pixels_per_bank // height # 8 pixels
width = bank_width * num_banks # 1024 pixels
r = MapReader()
with open(mapfile, 'r', encoding='utf-8') as f:
l = f.readlines()
r.read_map_data(l)
hit_data = []
default_bank_data = {'sections': [], 'used': 0, 'slack': bank_size}
for bank in range(num_banks):
hits = [0] * pixels_per_bank
data = r.bank_data['rom bank'].get(bank, default_bank_data)
for s in data['sections']:
if s['beg'] > s['end']:
continue
if s['beg'] == 0x0000 and s['end'] > 0xFFFF:
# https://github.com/gbdev/rgbds/issues/515
continue
beg = s['beg'] & bank_mask
end = s['end'] & bank_mask
for i in range(beg, end + 1):
hits[i // bpp] += 1
hit_data.append(hits)
pixels = [[(0xFF, 0xFF, 0xFF)] * width for _ in range(height)]
for bank, hits in enumerate(hit_data):
hue = 0 if not bank else 210 if bank % 2 else 270
for i, h in enumerate(hits):
y = i // bank_width
x = i % bank_width + bank * bank_width
hls = (hue / 360.0, 1.0 - (h / bpp * (100 - 15)) / 100.0, 1.0)
rgb = tuple(int(c * 255) for c in hls_to_rgb(*hls))
pixels[y][x] = rgb
png_data = [tuple(c for pixel in row for c in pixel) for row in pixels]
with open(filename, 'wb') as f:
w = png.Writer(width, height)
w.write(f, png_data)
def automappingRuleFileVersion(self, fileName):
reader = MapReader()
map = reader.readMap(fileName)
if (not map):
return self.versionNotAMap()
# version 1 check
hasonlyruleprefix = True
for layer in map.layers():
if (not layer.name().lower().startswith("rule")):
hasonlyruleprefix = False
if (hasonlyruleprefix):
return self.version1()
# version 2 check
hasrule = False
hasoutput = False
hasregion = False
allused = True
for layer in map.layers():
isunused = True
if (layer.name().lower().startswith("input")):
hasrule = True
isunused = False
if (layer.name().lower().startswith("output")):
hasoutput = True
isunused = False
if (layer.name().lower() == "regions"):
hasregion = True
isunused = False
if (isunused):
allused = False
if (allused and hasoutput and hasregion and hasrule):
return self.version2()
return self.versionUnknown()
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
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
dest="num_banks",
required=True,
type=lambda x: int(x, 0))
args = ap.parse_args()
bank_mask = 0x3FFF
bank_size = 0x4000 # bytes
width = 256 # pixels per row
bpp = 8 # bytes per pixel
rom_size = args.num_banks * bank_size # bytes
height = (args.num_banks * bank_size +
(width * bpp - 1)) // (width * bpp) # pixels
rows_per_bank = bank_size // (width * bpp)
r = MapReader()
with open(args.mapfile, 'r', encoding="utf-8") as f:
l = f.readlines()
r.read_map_data(l)
hit_data = [[0] * width for _ in range(height)]
default_bank_data = {'sections': [], 'used': 0, 'slack': bank_size}
for bank in range(args.num_banks):
data = r.bank_data['ROM Bank'].get(bank, default_bank_data)
for s in data['sections']:
beg = (s['beg'] & bank_mask) + bank * bank_size
end = (s['end'] & bank_mask) + bank * bank_size
y_beg = beg // (width * bpp)
x_beg = (beg % (width * bpp)) // bpp
y_end = end // (width * bpp)
x_end = (end % (width * bpp)) // bpp
def main(argv):
a = TiledApplication(argv)
a.setOrganizationDomain("mapeditor.org")
a.setApplicationName("Tiled")
a.setApplicationVersion("0.14.2")
if sys.platform == 'darwin':
a.setAttribute(Qt.AA_DontShowIconsInMenus)
# Enable support for highres images (added in Qt 5.1, but off by default)
a.setAttribute(Qt.AA_UseHighDpiPixmaps)
if sys.platform != 'win32':
baseName = QApplication.style().objectName()
if (baseName == "windows"):
# Avoid Windows 95 style at all cost
if (QStyleFactory.keys().contains("Fusion")):
baseName = "fusion" # Qt5
else: # Qt4
# e.g. if we are running on a KDE4 desktop
desktopEnvironment = qgetenv("DESKTOP_SESSION")
if (desktopEnvironment == "kde"):
baseName = "plastique"
else:
baseName = "cleanlooks"
a.setStyle(QStyleFactory.create(baseName))
languageManager = LanguageManager.instance()
languageManager.installTranslators()
commandLine = CommandLineHandler()
if (not commandLine.parse(QCoreApplication.arguments())):
return 0
if (commandLine.quit):
return 0
if (commandLine.disableOpenGL):
preferences.Preferences.instance().setUseOpenGL(False)
PluginManager.instance().loadPlugins()
if (commandLine.exportMap):
# Get the path to the source file and target file
if (commandLine.filesToOpen().length() < 2):
qWarning(QCoreApplication.translate("Command line", "Export syntax is --export-map [format] "))
return 1
index = 0
if commandLine.filesToOpen().length() > 2:
filter = commandLine.filesToOpen().at(index)
index += 1
else:
filter = None
sourceFile = commandLine.filesToOpen().at(index)
index += 1
targetFile = commandLine.filesToOpen().at(index)
index += 1
chosenFormat = None
formats = PluginManager.objects()
if filter:
# Find the map format supporting the given filter
for format in formats:
if not format.hasCapabilities(MapFormat.Write):
continue
if format.nameFilter().lower()==filter.lower():
chosenFormat = format
break
if not chosenFormat:
qWarning(QCoreApplication.translate("Command line", "Format not recognized (see --export-formats)"))
return 1
else:
# Find the map format based on target file extension
suffix = QFileInfo(targetFile).completeSuffix()
for format in formats:
if not format.hasCapabilities(MapFormat.Write):
continue
if suffix.lower() in format.nameFilter().lower():
if chosenFormat:
qWarning(QCoreApplication.translate("Command line", "Non-unique file extension. Can't determine correct export format."))
return 1
chosenFormat = format
if not chosenFormat:
qWarning(QCoreApplication.translate("Command line", "No exporter found for target file."))
return 1
# Load the source file
reader = MapReader()
map = reader.readMap(sourceFile)
if (not map):
qWarning(QCoreApplication.translate("Command line", "Failed to load source map."))
return 1
# Write out the file
success = chosenFormat.write(map.data(), targetFile)
if (not success):
qWarning(QCoreApplication.translate("Command line", "Failed to export map to target file."))
return 1
return 0
w = MainWindow()
w.show()
a.fileOpenRequest.connect(w.openFile)
if (not commandLine.filesToOpen().isEmpty()):
for fileName in commandLine.filesToOpen():
w.openFile(fileName)
elif preferences.Preferences.instance().openLastFilesOnStartup():
w.openLastFiles()
return a.exec()
def main(argv):
a = TiledApplication(argv)
a.setOrganizationDomain("mapeditor.org")
a.setApplicationName("Tiled")
a.setApplicationVersion("0.14.2")
if sys.platform == 'darwin':
a.setAttribute(Qt.AA_DontShowIconsInMenus)
# Enable support for highres images (added in Qt 5.1, but off by default)
a.setAttribute(Qt.AA_UseHighDpiPixmaps)
if sys.platform != 'win32':
baseName = QApplication.style().objectName()
if (baseName == "windows"):
# Avoid Windows 95 style at all cost
if (QStyleFactory.keys().contains("Fusion")):
baseName = "fusion" # Qt5
else: # Qt4
# e.g. if we are running on a KDE4 desktop
desktopEnvironment = qgetenv("DESKTOP_SESSION")
if (desktopEnvironment == "kde"):
baseName = "plastique"
else:
baseName = "cleanlooks"
a.setStyle(QStyleFactory.create(baseName))
languageManager = LanguageManager.instance()
languageManager.installTranslators()
commandLine = CommandLineHandler()
if (not commandLine.parse(QCoreApplication.arguments())):
return 0
if (commandLine.quit):
return 0
if (commandLine.disableOpenGL):
preferences.Preferences.instance().setUseOpenGL(False)
PluginManager.instance().loadPlugins()
if (commandLine.exportMap):
# Get the path to the source file and target file
if (commandLine.filesToOpen().length() < 2):
qWarning(
QCoreApplication.translate(
"Command line", "Export syntax is --export-map [format] "))
return 1
index = 0
if commandLine.filesToOpen().length() > 2:
filter = commandLine.filesToOpen().at(index)
index += 1
else:
filter = None
sourceFile = commandLine.filesToOpen().at(index)
index += 1
targetFile = commandLine.filesToOpen().at(index)
index += 1
chosenFormat = None
formats = PluginManager.objects()
if filter:
# Find the map format supporting the given filter
for format in formats:
if not format.hasCapabilities(MapFormat.Write):
continue
if format.nameFilter().lower() == filter.lower():
chosenFormat = format
break
if not chosenFormat:
qWarning(
QCoreApplication.translate(
"Command line",
"Format not recognized (see --export-formats)"))
return 1
else:
# Find the map format based on target file extension
suffix = QFileInfo(targetFile).completeSuffix()
for format in formats:
if not format.hasCapabilities(MapFormat.Write):
continue
if suffix.lower() in format.nameFilter().lower():
if chosenFormat:
qWarning(
QCoreApplication.translate(
"Command line",
"Non-unique file extension. Can't determine correct export format."
))
return 1
chosenFormat = format
if not chosenFormat:
qWarning(
QCoreApplication.translate(
"Command line", "No exporter found for target file."))
return 1
# Load the source file
reader = MapReader()
map = reader.readMap(sourceFile)
if (not map):
qWarning(
QCoreApplication.translate("Command line",
"Failed to load source map."))
return 1
# Write out the file
success = chosenFormat.write(map.data(), targetFile)
if (not success):
qWarning(
QCoreApplication.translate(
"Command line", "Failed to export map to target file."))
return 1
return 0
w = MainWindow()
w.show()
a.fileOpenRequest.connect(w.openFile)
if (not commandLine.filesToOpen().isEmpty()):
for fileName in commandLine.filesToOpen():
w.openFile(fileName)
elif preferences.Preferences.instance().openLastFilesOnStartup():
w.openLastFiles()
return a.exec()
ap.add_argument('-o', dest='filename', default='coverage.png')
ap.add_argument('-m', dest='mapfile', required=True)
ap.add_argument('-b', dest='num_banks', required=True, type=lambda x: int(x, 0))
args = ap.parse_args()
bank_mask = 0x3FFF
bank_size = 0x4000 # bytes
width = 256 # pixels per row
bpp = 8 # bytes per pixel
romname = args.romname
rom_size = args.num_banks * bank_size # bytes
height = (args.num_banks * bank_size + (width * bpp - 1)) // (width * bpp) # pixels
rows_per_bank = bank_size // (width * bpp)
r = MapReader()
with open(args.mapfile, 'r', encoding= 'utf-8') as f:
l = f.readlines()
r.read_map_data(l)
default_bank_data = {'sections': [], 'used': 0, 'slack': bank_size}
filler = [0x00, 0xFF]
if (romname is not None):
with open(romname, 'rb') as f:
for rb in range(0, args.num_banks):
data = r.bank_data['ROM Bank'].get(rb, default_bank_data)
bank = f.read(bank_size)
if (bank[bank_size - 1] in filler):
fill = bank[bank_size - 1]
for i in reversed(range(-1, bank_size - 1)):
import sys
from mapreader import MapReader
if len(sys.argv) < 2:
print("No params")
sys.exit(1)
print("Opening", sys.argv[1])
reader = MapReader(sys.argv[1])
reader.load_map()
reader.normalize()
reader.divide_entities()
for entity in reader.entity_content:
parsed = reader.parse_entity(entity)
print("-----------------------------")
print(parsed)
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