Finished pathing toolbox

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:

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.