def test_validate(self):
teemap = Teemap()
self.assertRaises(MapError, teemap.validate)
group = items.Group()
group.layers.append(items.TileLayer(game=True))
teemap.groups.append(group)
self.assertTrue(teemap.validate())
group.layers.append(items.TileLayer(game=True))
self.assertRaises(MapError, teemap.validate)
def test_validate(self):
teemap = Teemap()
self.assertRaises(MapError, teemap.validate)
group = items.Group()
group.layers.append(items.TileLayer(game=True))
teemap.groups.append(group)
self.assertTrue(teemap.validate())
group.layers.append(items.TileLayer(game=True))
self.assertRaises(MapError, teemap.validate)
def main(argv):
map_path = argv[1]
result_path = argv[2]
t = Teemap(map_path)
result = {}
frontlayer = None # Works thanks to hack in tml
for group in t.groups:
if group.name == 'Game':
for layer in group.layers:
if type(layer) == TileLayer and layer.name == 'Front':
frontlayer = layer
break
add(result, gameTiles, t.gamelayer)
add(result, frontTiles, frontlayer)
# These don't seem to be working
#add(result, switchTiles, switchlayer)
#add(result, speedupTiles, t.speeduplayer)
#add(result, teleTiles, t.telelayer)
with open(result_path, 'wb') as out:
out.write(msgpack.packb(t.gamelayer.width))
out.write(msgpack.packb(t.gamelayer.height))
out.write(msgpack.packb(result))
def main(argv):
map_path = argv[1]
t = Teemap(map_path)
frontlayer = None # Works thanks to hack in tml
for group in t.groups:
if group.name == 'Game':
for layer in group.layers:
if type(layer) == TileLayer and layer.name == 'Front':
frontlayer = layer
break
for tile in t.gamelayer.tiles:
if not IsValidGameTile(tile.index):
print(map_path)
return
if frontlayer != None:
for tile in frontlayer.tiles:
if not IsValidFrontTile(tile.index):
print(map_path)
return
def retrieve_map_details(map_id):
"""
WARNING!
This task is CPU/(and highly) RAM expensive.
Checks for presence of specified tiles, counts some of them
and at the end takes a beautiful photo of the map.
Thanks for your help, erdbeere!
"""
logger = retrieve_map_details.get_logger()
try:
map_obj = Map.objects.get(pk=map_id)
except Map.DoesNotExist:
logger.error("[M- ] Map not found (pk={0}).".format(map_id))
return False
try:
# I actually can use that! Thanks, erd!
teemap = Teemap(map_obj.map_file.path)
logger.info('[M-{0}] Loaded "{1}" map.'.format(map_id, map_obj.name))
except IndexError:
logger.error('[M-{0}] Couldn\'t load "{1}" map'.format(map_id, map_obj.name))
has_unhookables = has_deathtiles = None
shield_count = heart_count = grenade_count = None
else:
has_unhookables = has_deathtiles = has_teleporters = has_speedups = False
shield_count = heart_count = grenade_count = 0
logger.info("Counting map items...")
for tile in teemap.gamelayer.tiles:
if tile.index == indexes.DEATHTILE:
has_deathtiles = True
elif tile.index == indexes.UNHOOKABLE:
has_unhookables = True
elif tile.index == indexes.SHIELD:
shield_count += 1
elif tile.index == indexes.HEART:
heart_count += 1
elif tile.index == indexes.GRENADE:
grenade_count += 1
if teemap.telelayer:
has_teleporters = True
if teemap.speeduplayer:
has_speedups = True
# DISABLED due to huge (counted in GiBs) memory usage
# logger.info("Rendering map screenshot.")
# map_image = teemap.render(gamelayer_on_top=True)
# map_image.save('{0}images/maps/full/{1}.png'.format(settings.MEDIA_ROOT,
# map_obj.name))
# logger.info("Finished rendering map screenshot.")
# map_obj.has_image = True
map_obj.has_unhookables = has_unhookables
map_obj.has_deathtiles = has_deathtiles
map_obj.has_teleporters = has_teleporters
map_obj.has_speedups = has_speedups
map_map_types = map_obj.map_types.filter(slug="fastcap-no-weapons")
if not map_map_types:
map_obj.shield_count = shield_count
map_obj.heart_count = heart_count
map_obj.grenade_count = grenade_count
logger.info("Finished counting map items.")
logger.info("Generating map CRC...")
map_obj.map_file.open()
map_obj.crc = "{0:x}".format(crc32(map_obj.map_file.read()) & 0xffffffff)
map_obj.map_file.close()
map_obj.save()
map_map_types = map_obj.map_types.filter(slug="fastcap")
if map_map_types:
logger.info("Creating a non-weapon twin...")
new_map, created = Map.objects.get_or_create(
name="{0}-no-weapons".format(map_obj.name),
defaults={
"author": map_obj.author,
"added_by": map_obj.added_by,
"map_file": map_obj.map_file,
"crc": map_obj.crc,
"has_unhookables": has_unhookables,
"has_deathtiles": has_deathtiles,
},
)
if not created:
logger.info("Oh, it already exists! Updating...")
new_map.author = map_obj.author
new_map.added_by = map_obj.added_by
new_map.map_file = map_obj.map_file
new_map.crc = map_obj.crc
new_map.has_unhookables = has_unhookables
new_map.has_deathtiles = has_deathtiles
new_map.save()
else:
new_map.map_types.add(MapType.objects.get(slug="fastcap-no-weapons"))
new_map.map_types.add(*map_obj.map_types.exclude(slug="fastcap"))
new_map.save()
logger.info('[M-{0}] Finished processing "{1}" map.'.format(map_id, map_obj.name))
'super_start': 105,
'jetpack_start': 106,
'nph_start': 107,
# Tele layer
'tele_in': 26,
'tele_out': 27,
'tele_in_evil': 10,
'tele_in_weapon': 14,
'tele_in_hook': 15,
'jump': 7,
}
inTiles = ['tele_in', 'tele_in_evil', 'tele_in_weapon', 'tele_in_hook']
map_path = sys.argv[1]
t = Teemap(map_path)
pickups = {
'begin': 0,
'end': 0,
'npc_end': 0,
'super_end': 0,
'jetpack_end': 0,
'nph_end': 0,
'npc_start': 0,
'super_start': 0,
'jetpack_start': 0,
'nph_start': 0,
}
telePickups = {
'tele_in': [],
def make_map_img(imgfile, mapfile):
twmap = Teemap("dummy")
img2map(Image.open(imgfile).convert("RGB"), twmap.gamelayer, twmap.layers[2])
twmap.save(mapfile)
def make_map_txt(txtfile, mapfile):
twmap = Teemap("dummy")
txt2map(open(txtfile, "r"), twmap.gamelayer, twmap.layers[2])
twmap.save(mapfile)
t.index = rgb2tile(txt2rgb(c))
tilelayer.set_tile(x, y, t)
t.index = rgb2game(txt2rgb(c))
gamelayer.set_tile(x, y, t)
x += 1
#
def make_map_txt(txtfile, mapfile):
twmap = Teemap("dummy")
txt2map(open(txtfile, "r"), twmap.gamelayer, twmap.layers[2])
twmap.save(mapfile)
#
def make_map_img(imgfile, mapfile):
twmap = Teemap("dummy")
img2map(Image.open(imgfile).convert("RGB"), twmap.gamelayer, twmap.layers[2])
twmap.save(mapfile)
#
if __name__ == "__main__":
if sys.argv[1][-4:] == ".txt":
make_map_txt(sys.argv[1], sys.argv[2])
elif sys.argv[1][-4:] == ".map":
map2img(Teemap(sys.argv[1]).gamelayer).save(sys.argv[2])
else:
make_map_img(sys.argv[1], sys.argv[2])
#twmap2 = Teemap("yoko")
#mm = map2img(twmap2.gamelayer)
#mm.save("outgame.png")
#mm = map2img(twmap2.layers[2])
#mm.save("outtile.png")
def setUp(self):
os.mkdir("test_tmp")
self.teemap = Teemap("test_maps/vanilla")
class TestTeemap(unittest.TestCase):
def setUp(self):
os.mkdir("test_tmp")
self.teemap = Teemap("test_maps/vanilla")
def tearDown(self):
if os.path.isdir("test_tmp"):
shutil.rmtree("test_tmp")
def test_load(self):
pass
# with warnings.catch_warnings(record=True) as w:
# warnings.simplefilter('always')
# Teemap('tml/test_maps/vanilla')
# self.assertEqual(len(w), 1)
# self.assertTrue(issubclass(w[0].category, UserWarning))
# self.assertIn(str(w[0].message), 'External image „test2“ does not exist')
# assert Teemap('tml/maps/dm1.map')
# assert Teemap('tml/maps/dm1')
def test_groups(self):
self.assertEqual(len(self.teemap.groups), 7)
names = [None, None, "Game", "NamedGroup", None, None, "OtherGroup"]
for i, group in enumerate(self.teemap.groups):
self.assertEqual(group.name, names[i])
def test_layers(self):
self.assertEqual(len(self.teemap.layers), 6)
for i, num in enumerate([1, 2, 1, 0, 2, 0, 0]):
self.assertEqual(len(self.teemap.groups[i].layers), num)
self.assertIs(self.teemap.groups[0].layers[0], self.teemap.layers[0])
self.assertIs(self.teemap.groups[1].layers[0], self.teemap.layers[1])
self.assertIs(self.teemap.groups[1].layers[1], self.teemap.layers[2])
self.assertIs(self.teemap.groups[2].layers[0], self.teemap.layers[3])
self.assertIs(self.teemap.groups[4].layers[0], self.teemap.layers[4])
self.assertIs(self.teemap.groups[4].layers[1], self.teemap.layers[5])
names = ["TestQuads", "Quads", "TestTiles", "Game", None, "LastTiles"]
types = [
"quadlayer",
"quadlayer",
"tilelayer",
"tilelayer",
"tilelayer",
"tilelayer",
]
for i, layer in enumerate(self.teemap.layers):
self.assertEqual(layer.type, types[i])
self.assertEqual(layer.name, names[i])
for layer in self.teemap.layers:
if layer.type == "tilelayer":
if layer.name == "TestTiles":
self.assertEqual(layer.width, 5)
self.assertEqual(layer.height, 3)
else:
self.assertEqual(layer.width, 50)
self.assertEqual(layer.height, 50)
self.assertIs(self.teemap.layers[3], self.teemap.gamelayer)
def test_envelopes(self):
self.assertEqual(len(self.teemap.envelopes), 2)
self.assertEqual(self.teemap.envelopes[0].name, "PosEnv")
self.assertEqual(self.teemap.envelopes[1].name, "ColorEnv")
def test_envpoints(self):
self.assertEqual(len(self.teemap.envpoints), 9)
self.assertEqual(len(self.teemap.envelopes[0].envpoints), 4)
self.assertEqual(len(self.teemap.envelopes[1].envpoints), 5)
for i, envpoint in enumerate(self.teemap.envelopes[0].envpoints):
self.assertIs(envpoint, self.teemap.envpoints[i])
for i, envpoint in enumerate(self.teemap.envelopes[1].envpoints):
self.assertIs(envpoint, self.teemap.envpoints[i + 4])
def test_images(self):
images = [None, "grass_main", "grass_main", None, "grass_main", "test"]
for i, layer in enumerate(self.teemap.layers):
if images[i] is None:
self.assertIs(layer.image_id, -1)
else:
self.assertEqual(self.teemap.images[layer.image_id].name, images[i])
self.assertIs(self.teemap.layers[2].image_id, 0)
self.assertIs(self.teemap.layers[4].image_id, 0)
self.assertIs(self.teemap.layers[5].image_id, 1)
self.assertTrue(self.teemap.images[0].external)
self.assertFalse(self.teemap.images[1].external)
self.assertTrue(self.teemap.images[2].external)
self.teemap.images[0].save("test_tmp/grass_main.png")
self.teemap.images[1].save("test_tmp/test.png")
self.assertRaises(ValueError, self.teemap.images[2].save, "tests/test_tmp/test2.png")
self.assertTrue(
filecmp.cmp("test_tmp/grass_main.png", "../tml/mapres/grass_main.png")
)
self.assertTrue(filecmp.cmp("test_tmp/test.png", "test_mapres/test.png"))
def test_tiles(self):
layer = self.teemap.layers[2]
tiles = layer.tiles
self.assertEqual(len(tiles), 15)
# XXX: wouldn't be coordinates in layer make more sense?
for i, tile in enumerate(tiles[:5]):
self.assertEqual(tile.index, i)
self.assertEqual(tile.coords, (i, 0))
for tile in tiles[5:10]:
self.assertEqual(tile.index, 0)
self.assertEqual(tile.coords, (0, 0))
for i, tile in enumerate(tiles[10:]):
self.assertEqual(tile.index, i + 251)
self.assertEqual(tile.coords, (11 + i, 15))
flags = [
{"rotation": False, "hflip": True, "vflip": False},
{"rotation": False, "hflip": False, "vflip": True},
{"rotation": False, "hflip": True, "vflip": True},
{"rotation": True, "hflip": True, "vflip": True},
{"rotation": True, "hflip": False, "vflip": False},
{"rotation": False, "hflip": False, "vflip": False},
]
for i, tile in enumerate(tiles[:6]):
self.assertEqual(tile.flags, flags[i])
def test_quads(self):
self.assertEqual(len(self.teemap.layers[0].quads), 1)
self.assertEqual(len(self.teemap.layers[1].quads), 2)
pos_envs = [-1, -1, 0]
pos_env_offsets = [0, 0, 0]
color_envs = [-1, -1, 1]
color_env_offsets = [0, 0, 0]
points = [
[
(-800000, -600000),
(800000, -600000),
(-800000, 600000),
(800000, 600000),
(32768, 32768),
],
[
(329099, 208820),
(608709, 162163),
(304402, 515873),
(773381, 589973),
(361867, 241588),
],
[
(-194633, 306165),
(-13007, 301225),
(-286028, 556954),
(-13007, 492731),
(-111637, 400134),
],
]
texcoords = [
[(0, 0), (1024, 0), (0, 1024), (1024, 1024)],
[(0, 0), (1024, 0), (0, 1024), (1024, 1024)],
[(2215, -1076), (3204, -1076), (2215, 946), (3204, 946)],
]
quads = []
for layer in self.teemap.layers:
if layer.type == "quadlayer":
quads.extend(layer.quads)
for i, quad in enumerate(quads):
self.assertEqual(quad.pos_env, pos_envs[i])
self.assertEqual(quad.pos_env_offset, pos_env_offsets[i])
self.assertEqual(quad.color_env, color_envs[i])
self.assertEqual(quad.color_env_offset, color_env_offsets[i])
self.assertEqual(quad.texcoords, texcoords[i])
self.assertEqual(quad.points, points[i])
def test_envpoints(self):
times = [0, 722, 835, 2062, 0, 99, 643, 861, 1000]
curvetypes = [4, 0, 4, 1, 1, 1, 1, 1, 1]
values = [
[0, 0, 0, 0],
[0, 0, 207678, 9600],
[0, 0, 213958, 9600],
[0, 0, -3105, 0],
[1, 1, 1, 767],
[1, 355, 514, 843],
[1, 289, 995, 959],
[824, 143, 86, 597],
[1, 1, 1, 1],
]
for i, envpoint in enumerate(self.teemap.envpoints):
self.assertEqual(envpoint.time, times[i])
self.assertEqual(envpoint.curvetype, curvetypes[i])
self.assertEqual(envpoint.values, values[i])
def test_save(self):
self.teemap.save("test_tmp/copy.map")
self.teemap.save("test_tmp/copy2")
self.assertTrue(filecmp.cmp("test_maps/vanilla.map", "test_tmp/copy.map"))
self.assertTrue(filecmp.cmp("test_maps/vanilla.map", "test_tmp/copy2.map"))
def test_validate(self):
teemap = Teemap()
self.assertRaises(MapError, teemap.validate)
group = items.Group()
group.layers.append(items.TileLayer(game=True))
teemap.groups.append(group)
self.assertTrue(teemap.validate())
group.layers.append(items.TileLayer(game=True))
self.assertRaises(MapError, teemap.validate)
def setUp(self):
os.mkdir("test_tmp")
self.teemap = Teemap("test_maps/vanilla")
class TestTeemap(unittest.TestCase):
def setUp(self):
os.mkdir("test_tmp")
self.teemap = Teemap("test_maps/vanilla")
def tearDown(self):
if os.path.isdir("test_tmp"):
shutil.rmtree("test_tmp")
def test_load(self):
pass
# with warnings.catch_warnings(record=True) as w:
# warnings.simplefilter('always')
# Teemap('tml/test_maps/vanilla')
# self.assertEqual(len(w), 1)
# self.assertTrue(issubclass(w[0].category, UserWarning))
# self.assertIn(str(w[0].message), 'External image „test2“ does not exist')
# assert Teemap('tml/maps/dm1.map')
# assert Teemap('tml/maps/dm1')
def test_groups(self):
self.assertEqual(len(self.teemap.groups), 7)
names = [None, None, "Game", "NamedGroup", None, None, "OtherGroup"]
for i, group in enumerate(self.teemap.groups):
self.assertEqual(group.name, names[i])
def test_layers(self):
self.assertEqual(len(self.teemap.layers), 6)
for i, num in enumerate([1, 2, 1, 0, 2, 0, 0]):
self.assertEqual(len(self.teemap.groups[i].layers), num)
self.assertIs(self.teemap.groups[0].layers[0], self.teemap.layers[0])
self.assertIs(self.teemap.groups[1].layers[0], self.teemap.layers[1])
self.assertIs(self.teemap.groups[1].layers[1], self.teemap.layers[2])
self.assertIs(self.teemap.groups[2].layers[0], self.teemap.layers[3])
self.assertIs(self.teemap.groups[4].layers[0], self.teemap.layers[4])
self.assertIs(self.teemap.groups[4].layers[1], self.teemap.layers[5])
names = ["TestQuads", "Quads", "TestTiles", "Game", None, "LastTiles"]
types = [
"quadlayer",
"quadlayer",
"tilelayer",
"tilelayer",
"tilelayer",
"tilelayer",
]
for i, layer in enumerate(self.teemap.layers):
self.assertEqual(layer.type, types[i])
self.assertEqual(layer.name, names[i])
for layer in self.teemap.layers:
if layer.type == "tilelayer":
if layer.name == "TestTiles":
self.assertEqual(layer.width, 5)
self.assertEqual(layer.height, 3)
else:
self.assertEqual(layer.width, 50)
self.assertEqual(layer.height, 50)
self.assertIs(self.teemap.layers[3], self.teemap.gamelayer)
def test_envelopes(self):
self.assertEqual(len(self.teemap.envelopes), 2)
self.assertEqual(self.teemap.envelopes[0].name, "PosEnv")
self.assertEqual(self.teemap.envelopes[1].name, "ColorEnv")
def test_envpoints(self):
self.assertEqual(len(self.teemap.envpoints), 9)
self.assertEqual(len(self.teemap.envelopes[0].envpoints), 4)
self.assertEqual(len(self.teemap.envelopes[1].envpoints), 5)
for i, envpoint in enumerate(self.teemap.envelopes[0].envpoints):
self.assertIs(envpoint, self.teemap.envpoints[i])
for i, envpoint in enumerate(self.teemap.envelopes[1].envpoints):
self.assertIs(envpoint, self.teemap.envpoints[i + 4])
def test_images(self):
images = [None, "grass_main", "grass_main", None, "grass_main", "test"]
for i, layer in enumerate(self.teemap.layers):
if images[i] is None:
self.assertIs(layer.image_id, -1)
else:
self.assertEqual(self.teemap.images[layer.image_id].name,
images[i])
self.assertIs(self.teemap.layers[2].image_id, 0)
self.assertIs(self.teemap.layers[4].image_id, 0)
self.assertIs(self.teemap.layers[5].image_id, 1)
self.assertTrue(self.teemap.images[0].external)
self.assertFalse(self.teemap.images[1].external)
self.assertTrue(self.teemap.images[2].external)
self.teemap.images[0].save("test_tmp/grass_main.png")
self.teemap.images[1].save("test_tmp/test.png")
self.assertRaises(ValueError, self.teemap.images[2].save,
"tests/test_tmp/test2.png")
self.assertTrue(
filecmp.cmp("test_tmp/grass_main.png",
"../tml/mapres/grass_main.png"))
self.assertTrue(
filecmp.cmp("test_tmp/test.png", "test_mapres/test.png"))
def test_tiles(self):
layer = self.teemap.layers[2]
tiles = layer.tiles
self.assertEqual(len(tiles), 15)
# XXX: wouldn't be coordinates in layer make more sense?
for i, tile in enumerate(tiles[:5]):
self.assertEqual(tile.index, i)
self.assertEqual(tile.coords, (i, 0))
for tile in tiles[5:10]:
self.assertEqual(tile.index, 0)
self.assertEqual(tile.coords, (0, 0))
for i, tile in enumerate(tiles[10:]):
self.assertEqual(tile.index, i + 251)
self.assertEqual(tile.coords, (11 + i, 15))
flags = [
{
"rotation": False,
"hflip": True,
"vflip": False
},
{
"rotation": False,
"hflip": False,
"vflip": True
},
{
"rotation": False,
"hflip": True,
"vflip": True
},
{
"rotation": True,
"hflip": True,
"vflip": True
},
{
"rotation": True,
"hflip": False,
"vflip": False
},
{
"rotation": False,
"hflip": False,
"vflip": False
},
]
for i, tile in enumerate(tiles[:6]):
self.assertEqual(tile.flags, flags[i])
def test_quads(self):
self.assertEqual(len(self.teemap.layers[0].quads), 1)
self.assertEqual(len(self.teemap.layers[1].quads), 2)
pos_envs = [-1, -1, 0]
pos_env_offsets = [0, 0, 0]
color_envs = [-1, -1, 1]
color_env_offsets = [0, 0, 0]
points = [
[
(-800000, -600000),
(800000, -600000),
(-800000, 600000),
(800000, 600000),
(32768, 32768),
],
[
(329099, 208820),
(608709, 162163),
(304402, 515873),
(773381, 589973),
(361867, 241588),
],
[
(-194633, 306165),
(-13007, 301225),
(-286028, 556954),
(-13007, 492731),
(-111637, 400134),
],
]
texcoords = [
[(0, 0), (1024, 0), (0, 1024), (1024, 1024)],
[(0, 0), (1024, 0), (0, 1024), (1024, 1024)],
[(2215, -1076), (3204, -1076), (2215, 946), (3204, 946)],
]
quads = []
for layer in self.teemap.layers:
if layer.type == "quadlayer":
quads.extend(layer.quads)
for i, quad in enumerate(quads):
self.assertEqual(quad.pos_env, pos_envs[i])
self.assertEqual(quad.pos_env_offset, pos_env_offsets[i])
self.assertEqual(quad.color_env, color_envs[i])
self.assertEqual(quad.color_env_offset, color_env_offsets[i])
self.assertEqual(quad.texcoords, texcoords[i])
self.assertEqual(quad.points, points[i])
def test_envpoints(self):
times = [0, 722, 835, 2062, 0, 99, 643, 861, 1000]
curvetypes = [4, 0, 4, 1, 1, 1, 1, 1, 1]
values = [
[0, 0, 0, 0],
[0, 0, 207678, 9600],
[0, 0, 213958, 9600],
[0, 0, -3105, 0],
[1, 1, 1, 767],
[1, 355, 514, 843],
[1, 289, 995, 959],
[824, 143, 86, 597],
[1, 1, 1, 1],
]
for i, envpoint in enumerate(self.teemap.envpoints):
self.assertEqual(envpoint.time, times[i])
self.assertEqual(envpoint.curvetype, curvetypes[i])
self.assertEqual(envpoint.values, values[i])
def test_save(self):
self.teemap.save("test_tmp/copy.map")
self.teemap.save("test_tmp/copy2")
self.assertTrue(
filecmp.cmp("test_maps/vanilla.map", "test_tmp/copy.map"))
self.assertTrue(
filecmp.cmp("test_maps/vanilla.map", "test_tmp/copy2.map"))
def test_validate(self):
teemap = Teemap()
self.assertRaises(MapError, teemap.validate)
group = items.Group()
group.layers.append(items.TileLayer(game=True))
teemap.groups.append(group)
self.assertTrue(teemap.validate())
group.layers.append(items.TileLayer(game=True))
self.assertRaises(MapError, teemap.validate)
import os
from tml.tml import Teemap
from tml.constants import TML_DIR, TILEINDEX
from tml.items import Layer, TileLayer, TileManager, Tile
print(TML_DIR)
map_path = os.sep.join([TML_DIR, '/maps/dm1'])
t = Teemap(map_path)
pickups = {
'shotgun': 0,
'grenade': 0,
'rifle': 0,
'ninja': 0,
'health': 0,
'armor': 0,
'solid': 0,
'air': 0,
'death': 0,
'nohook': 0,
}
for tile in t.gamelayer.tiles:
for key, value in pickups.iteritems():
if tile.index == TILEINDEX[key]:
pickups[key] += 1
for k, v in pickups.iteritems():
print '{value:3}x {key}'.format(value=v, key=k)
t.gamelayer.tiles[0] = Tile(3) # set first tile x/y 0/0 to unhook
