def create_fleet(ai_settings, screen, miness): exmine = Mines(ai_settings, screen) exmine_height = exmine.rect.height for mines_number in range(ai_settings.mines_counter): exmine = Mines(ai_settings, screen) exmine.y = exmine_height + 2 * exmine_height * mines_number exmine.rect.y = exmine.y miness.add(exmine)
def solve_tiny(): puzzle = Mines( """ 2--- --1- -2-- ---1 """ ) puzzle.solve()
def __init__(self, board_size, num_mines): self.board_size = board_size self.num_mines = num_mines self.m = Mines(self.board_size, self.num_mines) self.grid = self.m.checkcell((0, 0)) self.m.showcurrent() self.sentence_list = [] self.unmarked = [] self.safe = set() self.safe_moves = []
def solve_small(): puzzle = Mines( """ --2-3- 2----- --24-3 1-34-- -----3 -3-3-- """ ) puzzle.solve()
def __init__(self, world): self.id = type(self).instance_num # const and public type(self).instance_num += 1 # TODO: switches and goals and hives self.spawner = Spawner(world) self.wall = Wall(world) self.mines = Mines(world) self.balls = Balls(world) self.elapsed_time = KahanSum() self.can_mutate = True
def run_game(): pygame.init() ai_settings = Settings() screen = pygame.display.set_mode( (ai_settings.screen_width, ai_settings.screen_height)) pygame.display.set_caption("Fish") fish = Fish(ai_settings, screen) mines = Mines(ai_settings, screen) stats = Gamestats(ai_settings) sb = Scoreboard(ai_settings, screen, stats) miness = Group() gf.create_fleet(ai_settings, screen, miness) play_button = Button(ai_settings, screen, "Play") pygame.mouse.set_visible(True) while True: gf.check_events(ai_settings, screen, stats, sb, play_button, fish, miness) gf.update_screen(ai_settings, screen, stats, sb, fish, mines, miness, play_button) if stats.game_active: fish.update() gf.update_miness(ai_settings, stats, sb, screen, fish, miness)
class PhysicsState: instance_num = 0 def update_ball_vels(self, ball_inputs): vels = [] ids = self.balls.get_ids() for ball_index in range(len(ids)): input_index = ids[ball_index] input = ball_inputs[input_index] # The AI needs to know everything that could possibly # affect the ball - that is, the whole const PhysicsState - # so pass `self`. # Also give a ball index to the input so the AI knows # which ball it's controlling. vel = input.calc_vel(ball_index, self) vels.append(vel) self.invalidate_public_data() self.balls.set_vels(vels) def get_nearest_ball_sqr_dist(self, pos): # TODO: `sqr_dist` should be shortest path distance. nearest_ball_pos, sqr_dist = get_nearest(pos, self.balls.get_poss()) return sqr_dist def can_add_mine(self, pos): is_collision = (self.wall.is_circle_collision(pos, self.mines.rad)) sqr_dist = self.get_nearest_ball_sqr_dist(pos) return self.spawner.can_add_mine(sqr_dist) and not is_collision def maybe_add_mine(self, mine_input): pos = mine_input.calc_pos(self) # const self self.invalidate_public_data() if not pos: return sqr_dist = self.get_nearest_ball_sqr_dist(pos) if not self.spawner.try_add_mine(pos, sqr_dist): # TODO: Notify of failure to spawn mine at `pos`. pass def maybe_spawn_mine(self): pos = self.spawner.try_take_live_mine() if pos is not None: self.mines.add(pos) # For SimplePhysicsState: # def move_mines_without_walls(self, dt): # Mines could be moved in parallel. # for i in range(0, len(self.mine_poss)): # self.update_mine_vel(i, self.ball_pos) # self.mine_poss[i] += vec_scale(self.mine_vels[i], dt) # Public (including constants): def reset(self, initial_wall_bitmap): assert(self.can_mutate) self.elapsed_time = KahanSum() # TODO: switches and goals and hives self.wall.reset(initial_wall_bitmap) self.spawner.reset() self.balls.reset() self.mines.reset() def __init__(self, world): self.id = type(self).instance_num # const and public type(self).instance_num += 1 # TODO: switches and goals and hives self.spawner = Spawner(world) self.wall = Wall(world) self.mines = Mines(world) self.balls = Balls(world) self.elapsed_time = KahanSum() self.can_mutate = True # `get_*` functions return constant values (including elements of lists). # If public data has been retrieved by, for example, calling # `physics_state.get_mines`, then it must be invalidated before # mutating the PhysicsState (for example, by calling `advance`). # After invalidation, `get_mines` must be called again for new data. def invalidate_public_data(self): self.can_mutate = True def get_elapsed_time(self): return self.elapsed_time.get() def get_mines(self): self.can_mutate = False return self.mines def get_balls(self): self.can_mutate = False return self.balls def get_spawner(self): self.can_mutate = False return self.spawner # Also constant - can't spawn mines. def get_wall(self): self.can_mutate = False return self.wall # TODO: switches, goals, hives def has_finished(self): arent_any_balls = (len(self.balls.get_poss()) == 0) are_all_goals_reached = False # TODO return arent_any_balls or are_all_goals_reached def toggle_invincible_balls(self): assert(self.can_mutate) self.balls.toggle_invincibility() def advance(self, mine_input, ball_inputs, dt): assert(self.can_mutate) if self.has_finished(): return False # Simulate spawner. self.spawner.advance(dt) self.maybe_spawn_mine() # Use inputs. self.update_ball_vels(ball_inputs) self.maybe_add_mine(mine_input) # Allow AI to prevent explosion. if self.spawner.is_exploding(): self.mines.explode() # Simulate balls. self.balls.advance(self.wall, dt) # Simulate mines. ball_poss = self.balls.get_poss() self.mines.advance(ball_poss, self.wall, dt) # Simulate ball-mine collisions. collisions = self.mines.find_ball_collisions(ball_poss, self.balls.rad) self.balls.update_collided(collisions) if any(collisions): print('time:\t' + str(self.get_elapsed_time())) # For debugging # Finish step. self.elapsed_time.add(dt) return True
class Solver2: def __init__(self, board_size, num_mines): self.board_size = board_size self.num_mines = num_mines self.m = Mines(self.board_size, self.num_mines) self.grid = self.m.checkcell((0, 0)) self.m.showcurrent() self.sentence_list = [] self.unmarked = [] self.safe = set() self.safe_moves = [] def sweep(self): self.__init_safe() self.__init_unmarked() # # before while loop # while not self.m.checkmines(): self.__build_knowledge() for s1 in self.sentence_list: for s2 in self.sentence_list: if s2.cells.issubset( s1.cells) and s2 != s1 and len(s2.cells) != 0: new_cells = s1.cells.difference(s2.cells) new_count = s1.count - s2.count new_sentence = Sentence(new_cells, new_count) if not self.sentence_list.__contains__(new_sentence): self.sentence_list.append(new_sentence) # sets all cells in sentences to mines that have equal values to their count for sen in self.sentence_list: cells_copy = sen.cells.copy() if sen.count == len(cells_copy): # self.sentence_list.remove(sen) for cell in cells_copy: sen.mark_mine(cell) for s in self.sentence_list: s.mark_mine(cell) if not set(self.m.flags).__contains__(cell): self.m.flags.append(cell) if sen.count == 0: for cell in cells_copy: if self.unmarked.__contains__(cell) and not set( self.m.flags).__contains__(cell): self.safe_moves.append(cell) sen.mark_safe(cell) for s in self.sentence_list: s.mark_safe(cell) if len(self.safe_moves) == 0: self.__make_random_move() #makes all the safe moves for m in self.safe_moves: self.__mark_safe(m) self.m.showcurrent() self.safe_moves = [] self.m.showcurrent() def __make_random_move(self): for i in range(self.board_size): for j in range(self.board_size): if self.grid[i][j] == ' ' and not set( self.m.flags).__contains__((i, j)): self.__mark_safe((i, j)) print("MARKING SAFE:", (i, j)) self.m.showcurrent() return def __mark_safe(self, cell): self.grid = self.m.checkcell(cell) self.safe.add(cell) self.unmarked.remove(cell) def __init_unmarked(self): for i in range(self.board_size): for j in range(self.board_size): if not self.grid[i][j].isnumeric() and not set( self.m.flags).__contains__((i, j)): self.unmarked.append((i, j)) def __init_safe(self): for i in range(self.board_size): for j in range(self.board_size): if self.grid[i][j].isnumeric(): self.safe.add((i, j)) def __build_knowledge(self): self.sentence_list = [] #goes through the grid and finds a number other than zero and creates a sentence from it for i in range(self.board_size): for j in range(self.board_size): added = False if self.grid[i][j] != "0" and self.grid[i][ j] != ' ' and not set(self.m.flags).__contains__( (i, j)): added = True tup = (i, j) c_value = int(self.grid[tup[0]][tup[1]]) adj_set = self.__get_adj_set(tup) new_sentence = Sentence(adj_set, c_value) self.sentence_list.append(new_sentence) if j == self.board_size - 1 and not added: break def __get_adj_set(self, tup): #creates a set of all empty adjacent cells of tup x = tup[0] y = tup[1] adj_set = set() if x - 1 >= 0 and y - 1 >= 0: top_left = self.grid[x - 1][y - 1] if top_left == ' ': adj_set.add((x - 1, y - 1)) if x - 1 >= 0: top_center = self.grid[x - 1][y] if top_center == ' ': adj_set.add((x - 1, y)) if x - 1 >= 0 and y + 1 <= self.board_size - 1: top_right = self.grid[x - 1][y + 1] if top_right == ' ': adj_set.add((x - 1, y + 1)) if y + 1 <= self.board_size - 1: middle_right = self.grid[x][y + 1] if middle_right == ' ': adj_set.add((x, y + 1)) if x + 1 <= self.board_size - 1 and y + 1 <= self.board_size - 1: bottom_right = self.grid[x + 1][y + 1] if bottom_right == ' ': adj_set.add((x + 1, y + 1)) if x + 1 <= self.board_size - 1: bottom_middle = self.grid[x + 1][y] if bottom_middle == ' ': adj_set.add((x + 1, y)) if x + 1 <= self.board_size - 1: bottom_left = self.grid[x + 1][y - 1] if bottom_left == ' ': adj_set.add((x + 1, y - 1)) if y - 1 >= 0: middle_left = self.grid[x][y - 1] if middle_left == ' ': adj_set.add((x, y - 1)) return adj_set
def main(): print("Field Test One\n") minefield = Mines() print(minefield) minefield.set_mines(6) minefield.place_mines() print(minefield) print("\nField Test Two\n") minefield = Mines('#', 8, 9) print(minefield) minefield.set_mines(8) minefield.place_mines() print(minefield)