diff --git a/astar.py b/astar.py
index 802abe5..1b2be0b 100644
--- a/astar.py
+++ b/astar.py
@@ -25,7 +25,7 @@ def _init_cells(self):
         for i in range(self.height):
             for j in range(self.width):
                 self.cells[(i,j)] = Cell(self.screen,(i*self.cell_size, j*self.cell_size),(self.cell_size,self.cell_size))
-    
+
     def _add_coords(self,a,b):
         return tuple(map(sum,zip(a,b)))
 
@@ -57,8 +57,12 @@ def _is_occupied(self,cell_coord):
             return False
 
     def _add_swamp(self, mouse_pos):
-        #insert swamp code here.
-        pass
+        swamp_coord = (mouse_pos[0]/50, mouse_pos[1]/50)
+        if self._is_occupied(swamp_coord):
+            if self.actors[swamp_coord].unremovable == False:
+                self.actors.pop(swamp_coord, None)
+        else:
+            self.actors[swamp_coord] = ObstacleTile(swamp_coord, self, './images/swamp.jpg', is_unpassable = False, terrain_cost = 3)
 
     def _add_lava(self, mouse_pos):
         lava_coord = (mouse_pos[0]/50, mouse_pos[1]/50)
@@ -91,14 +95,16 @@ def main_loop(self):
                 elif event.type is pygame.MOUSEBUTTONDOWN:
                     if self.add_tile_type == 'lava':
                         self._add_lava(event.pos)
-                    #insert swamp code here
+                    if self.add_tile_type == 'swamp':
+                        self._add_swamp(event.pos)
                 elif event.type is pygame.KEYDOWN:
                     if event.key == pygame.K_SPACE:
                         self.paul.run_astar(self.cake.cell_coordinates, self)
                         self.paul.get_path()
                     elif event.key == pygame.K_l:
                         self.add_tile_type = 'lava'
-                    #insert swamp code here
+                    elif event.key == pygame.K_s:
+                        self.add_tile_type = 'swamp'
 
 class Actor(object):
     def __init__(self, cell_coordinates, world, image_loc, unremovable = False, is_obstacle = True):
@@ -125,7 +131,7 @@ class ObstacleTile(Actor):
     def __init__(self, cell_coordinates, world, image_loc, terrain_cost=0, is_unpassable = True):
         super(ObstacleTile, self).__init__(cell_coordinates, world, image_loc, unremovable = False, is_obstacle = is_unpassable)
         self.terrain_cost = terrain_cost
-        
+
 class Cell():
     def __init__(self, draw_screen, coordinates, dimensions):
         self.draw_screen = draw_screen
@@ -143,9 +149,9 @@ def f_cost(self):
 
     def draw(self):
         COST_TO_DRAW = ''
-        #COST_TO_DRAW = self.g_cost
+        COST_TO_DRAW = self.g_cost
         #COST_TO_DRAW = self.h_cost
-        #COST_TO_DRAW = self.f_cost
+        # COST_TO_DRAW = self.f_cost
         line_width = 2
         rect = pygame.Rect((self.coordinates[0],self.coordinates[1]),(self.dimensions[0],self.dimensions[1]))
         pygame.draw.rect(self.draw_screen, self.color, rect, line_width)
@@ -167,8 +173,9 @@ def get_h_cost(self, coord_a,coord_b):
     def get_open_adj_coords(self, coords):
         """returns list of valid coords that are adjacent to the argument, open, and not in the closed list."""
         #modify directions and costs as needed
-        directions = [(1,0),(0,1),(-1,0),(0,-1)]
-        costs = [1,1,1,1]
+        directions = [(1,0),(0,1),(-1,0),(0,-1),(1,1),(-1,1),(-1,-1),(1,-1),
+        (2,0),(0,2),(-2,0),(0,2)]
+        costs = [1,1,1,1,3,3,3,3,8,8,8,8]
         adj_coords = map(lambda d: self.world._add_coords(coords,d), directions)
         for i, coord in enumerate(adj_coords):
             costs[i] += self.world.get_terrain_cost(coord)
@@ -226,7 +233,7 @@ def run_astar(self, destination_coord, world):
             walkable_open_coords, costs = self.get_open_adj_coords(coord_s)
             for idx,coord in enumerate(walkable_open_coords):
                 cell = self.cells[coord]
-                g_cost = cell_s.g_cost + costs[idx] 
+                g_cost = cell_s.g_cost + costs[idx]
                 h_cost = self.get_h_cost(coord, destination_coord)
                 f_cost = g_cost + h_cost
                 if coord in self.open_list:
diff --git a/diagonal_example.png b/diagonal_example.png
new file mode 100644
index 0000000..e256c22
Binary files /dev/null and b/diagonal_example.png differ
diff --git a/explanations.txt b/explanations.txt
new file mode 100644
index 0000000..a2b5e19
--- /dev/null
+++ b/explanations.txt
@@ -0,0 +1,3 @@
+diagonal: While the diagonal move costs 3, the path around to avoid using the diagonal move is much longer.
+
+jump,swamp: Actually all the situations I built have the same explanation. There's another way in each case, but it costs much more. In the swamp case, the actor moves out of the swamp immediately, when it stops being necessary.
diff --git a/jump_example.png b/jump_example.png
new file mode 100644
index 0000000..50d0172
Binary files /dev/null and b/jump_example.png differ
diff --git a/swamp_example.png b/swamp_example.png
new file mode 100644
index 0000000..d8ac3d4
Binary files /dev/null and b/swamp_example.png differ