diff --git a/assets/loot_gold.png b/assets/loot_gold.png
index 0a63be4..9dfb384 100644
Binary files a/assets/loot_gold.png and b/assets/loot_gold.png differ
diff --git a/assets/loot_pile.png b/assets/loot_pile.png
index dfef212..445cede 100644
Binary files a/assets/loot_pile.png and b/assets/loot_pile.png differ
diff --git a/palette.png b/palette.png
index a405d36..9a864c1 100644
Binary files a/palette.png and b/palette.png differ
diff --git a/src/game.py b/src/game.py
index b02eb15..673255f 100644
--- a/src/game.py
+++ b/src/game.py
@@ -93,13 +93,14 @@ while 1:
                     # Only render tile if on-screen
                     if pos[0] + scaledsize[0] >= 0 and pos[0] <= winsize[0] and \
                             pos[1] + scaledsize[1] >= 0 and pos[1] <= winsize[1]:
+                        tile.on_step(dtime, map, player)
                         screen.blit(pygame.transform.scale(texture, [math.floor(scaledsize[0]), math.ceil(scaledsize[1])]), pos)
 
                 # DEBUG
                 # text = arial.render(str(int(x)) + ", " + str(int(y)), False, (255, 255, 255))
                 # screen.blit(text, [x * 64 - (player.pos.x * round(SCALE * METER)) + camera[0], y * 64 - (player.pos.y * round(SCALE * METER)) + camera[1]])
 
-                if not player_rendered and z == 1 and y == round(player.pos.y + player.sprite.get_rect()[3] / METER):
+                if not player_rendered and z == 1 and y == math.ceil(player.pos.y + 1 + player.sprite.get_rect()[3] / METER):
                     # Draw player
                     screen.blit(pygame.transform.scale(player.sprite.texture.frame, [round(SCALE * player.sprite.texture.width), round(SCALE * player.sprite.texture.height)]), camera)
                     player_rendered = True
diff --git a/src/loot.py b/src/loot.py
index 023fd31..d080f38 100644
--- a/src/loot.py
+++ b/src/loot.py
@@ -2,17 +2,27 @@ import random
 import time
 import math
 
-MSIZE = 80
-
 def rand(*args):
     random.seed(time.clock())
     return random.randint(*args)
 
 class Placer():
     loot = [
-        ["loot_gold", 30],
-        ["loot_pile", 5]
+        ["loot:coins", 5],
+        ["loot:pile", 30],
     ]
 
     def populate(self, map):
-        map["tiles"].append()
+        if not map.generator:
+            return
+
+        for room in map.generator.rooms:
+            if rand(0, 2) != 0: # 1 in 3 chance of no loot
+                for y in range(1, room.height - 2):
+                    for x in range(1, room.width - 1):
+                        placed = False
+                        for loot in self.loot:
+                            if not placed and rand(1, loot[1]) == 1: # 1 in n chance of placing
+                                map.set_tile(room.x + x, room.y + y, 1, loot[0])
+                                placed = True
+
diff --git a/src/map.py b/src/map.py
index 8b15d1d..b717c88 100644
--- a/src/map.py
+++ b/src/map.py
@@ -1,6 +1,6 @@
 import pygame
 import json, math
-from . import assets, dungeon, loot
+from . import assets, dungeon, loot, tiles
 from .tiles import Tile
 from .vector import Vector
 
@@ -17,10 +17,11 @@ class Map:
     def generate(self):
         self.generator = dungeon.Generator(80)
         self.generator.generate(self)
-        # self.placer = loot.Placer()
-        # self.map = self.placer.populate(self.map)
+        self.placer = loot.Placer()
+        self.placer.populate(self)
 
     def collides(self, pos, rect):
+        # Player position handling really needs to be reworked ...
         METER = self.METER
         cx = pos.x + (rect[0] / METER)
         cy = pos.y + (rect[1] / METER)
@@ -47,8 +48,10 @@ class Map:
         for _ in range(len(self.map[z][y]), x + 1):
             self.map[z][y].append(None)
 
-        if name != "":
-            self.map[z][y][x] = Tile(name)
+        if not name:
+            self.map[z][y][x] = None
+        elif tiles.registered_tiles[name]:
+            self.map[z][y][x] = Tile(name, (x, y, z))
 
     def get_tile(self, x, y, z):
         try:
diff --git a/src/register.py b/src/register.py
index ed544b3..09340a8 100644
--- a/src/register.py
+++ b/src/register.py
@@ -1,6 +1,7 @@
 from . import tiles
+from .vector import Vector
 
-tiles.register_tile("map:cobble", {
+tiles.register_tile("map:floor", {
     "textures": ["floor.png"],
 })
 
@@ -31,10 +32,26 @@ tiles.register_tile("map:wall_corner_outer", {
     ],
 })
 
+def pick_up(self, dtime, map, player):
+    METER = map.METER
+    rect = player.sprite.get_rect()
+    cx = player.pos.x + (rect[0] / METER)
+    cy = player.pos.y + (rect[1] / METER)
+
+    cw = cx + (rect[2] / METER)
+    ch = cy + (rect[3] / METER)
+
+    if cw >= self.pos[0] and cx <= (self.pos[0] + 1) and ch >= self.pos[1] and cy <= (self.pos[1] + 1):
+        map.set_tile(*self.pos, None)
+
 tiles.register_tile("loot:coins", {
     "textures": ["loot_gold.png"],
+    "solid": False,
+    "on_step": pick_up
 })
 
 tiles.register_tile("loot:pile", {
     "textures": ["loot_pile.png"],
+    "solid": False,
+    "on_step": pick_up
 })
diff --git a/src/tiles.py b/src/tiles.py
index bb44ca2..b00f75f 100644
--- a/src/tiles.py
+++ b/src/tiles.py
@@ -28,10 +28,13 @@ class Tile:
     solid = True
     rotation = 0
 
-    def __init__(self, name):
+    def __init__(self, name, pos):
         self.name = name
+        self.pos = pos
         for key in registered_tiles[name]:
-            self.__dict__[key] = registered_tiles[name][key]
+            value = registered_tiles[name][key]
+            if not callable(value):
+                setattr(self, key, value)
 
     def get(self, key):
         try:
@@ -41,9 +44,13 @@ class Tile:
 
     def set_rotation(self, rot):
         self.rotation = rot
-    
+
     def get_rotation(self):
         return self.rotation
 
     def is_solid(self):
         return self.get("solid") == True
+    
+    def on_step(self, dtime, map, player):
+        if "on_step" in registered_tiles[self.name]:
+            registered_tiles[self.name]["on_step"](self, dtime, map, player)