Beispiel #1
0
    def __init__(self, layoutText):
        self.width = len(layoutText[0])
        self.height = len(layoutText)
        self.walls = Grid(self.width, self.height, False)
        self.food = Grid(self.width, self.height, False)
        self.capsules = []
        self.agentPositions = []

        self.numGhosts = 0
        self.numPacmen = 0

        # TODO If already has more than total, need to remove?
        # Should be fine

        # if fillRandom:
        #     # Randomly adds more ghosts and pacmen
        #     self.fillWithType(layoutText, numPacmen, 'P')
        #     self.fillWithType(layoutText, numGhosts, 'G')
        #
        #     if generateFood:
        #         numWalls = sum([line.count('%') for line in layoutText])
        #         numFood = (self.width * self.height - numWalls - numPacmen - numGhosts) * foodDensity
        #         numFood = int(numFood)
        #         self.fillWithType(layoutText, numFood, '.')

        self.processLayoutText(layoutText)
        self.layoutText = layoutText
        self.totalFood = len(self.food.asList())
Beispiel #2
0
    def drawWallandPositionBeliefs(self,
                                   known_map=None,
                                   possibleLocations=None,
                                   direction="North",
                                   visited_states_to_render=[],
                                   pacman_position=None):
        import random
        import __main__
        from graphicsUtils import draw_background, refresh
        known_walls, known_non_walls = self.get_known_walls_non_walls_from_known_map(
            known_map)
        wallGrid = Grid(self.problem.walls.width,
                        self.problem.walls.height,
                        initialValue=False)
        wallGrid.data = known_walls
        allTrueWallGrid = Grid(self.problem.walls.width,
                               self.problem.walls.height,
                               initialValue=True)

        # Recover list of non-wall coords:
        non_wall_coords = []
        for x in range(len(known_non_walls)):
            for y in range(len(known_non_walls[x])):
                if known_non_walls[x][y] == 1:
                    non_wall_coords.append((x, y))

        self.display.clearExpandedCells()  # Erase previous colors

        self.display.drawWalls(wallGrid, formatColor(.9, 0, 0),
                               allTrueWallGrid)
        self.display.colorCircleSquareCells(possibleLocations,
                                            square_cells=non_wall_coords,
                                            direction=direction,
                                            pacman_position=pacman_position)
        refresh()
Beispiel #3
0
 def __init__(self,
              layoutText=None,
              seed=None,
              width=None,
              height=None,
              vpi=False):
     if layoutText:
         self.width = len(layoutText[0])
         self.height = len(layoutText)
         self.walls = Grid(self.width, self.height, False)
         self.redWalls = Grid(self.width, self.height, False)
         self.blueWalls = Grid(self.width, self.height, False)
         self.food = Grid(self.width, self.height, False)
         self.capsules = []
         self.agentPositions = []
         self.numGhosts = 0
         self.processLayoutText(layoutText)
         self.layoutText = layoutText
         self.totalFood = len(self.food.asList())
     elif vpi:
         layoutText = generateVPIHuntersBoard(seed)
         self.__init__(layoutText)
     else:
         layoutText = generateRandomHuntersBoard(seed, width, height)
         self.__init__(layoutText)
Beispiel #4
0
 def __init__(self, layoutText):
     self.width = len(layoutText[0])
     self.height = len(layoutText)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     self.agentPositions = []
     self.numGhosts = 0
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
Beispiel #5
0
Datei: layout.py Projekt: fha/RL
 def __init__(self, layoutText):
     width = len(layoutText[0])
     height= len(layoutText)
     walls = Grid(width, height, False)
     food = Grid(width, height, False)
     capsules = []
     agentPositions = []
     numGhosts = 0
     Layout.__init__(self, width, height, walls, food, capsules, agentPositions, numGhosts)
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
Beispiel #6
0
 def __init__(self, layout_text):
     self.width = len(layout_text[0])
     self.height = len(layout_text)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     self.agent_positions = []
     self.num_ghosts = 0
     self.process_layout_text(layout_text)
     self.layout_text = layout_text
     self.total_food = len(self.food.as_list())
Beispiel #7
0
 def __init__(self, layoutText):
     self.width = len(layoutText[0])
     self.height = len(layoutText)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     self.agentpacman_positions = []
     self.numGhosts = 0
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
     self.totalFood = len(self.food.asList())
Beispiel #8
0
 def __init__(self, layoutText):
   self.width = len(layoutText[0])
   self.height= len(layoutText)
   self.walls = Grid(self.width, self.height, False)
   self.block = Grid(self.width, self.height, False)
   self.items = []
   self.bomb = []
   self.agentPositions = []
   self.numAgents = 0
   self.processLayoutText(layoutText)
   self.layoutText = layoutText
Beispiel #9
0
    def setNewGame(self, height, width, n_mines):
        self.grid = Grid(height, width, n_mines)
        self.time_start = 0  #serve as a control variable too

        self.lab_n_flags["text"] = "0/{}".format(n_mines)
        self.lab_time["text"] = "00:00"
        self.lab_match.config(fg="#f1c232", text="WAITING")
        self.but_overagain.config(bg="#ffd966",
                                  text="Start over",
                                  state="disabled",
                                  disabledforeground="black",
                                  command=self.overAgain)
 def __init__(self, layoutText, maxGhosts):
     self.width = len(layoutText[0])
     self.height = len(layoutText)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     self.agentPositions = []
     self.numGhosts = 0
     self.maxGhosts = maxGhosts  # Total number of ghosts that game will have (limit on how many we want to display)
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
     self.totalFood = len(self.food.asList())
Beispiel #11
0
	def handle_general(self, cmd, args):
		if cmd == 'MSG':
			msg = deserialize(args, 'unicode')
			print 'MSG', self.client_id, self.nicks, repr(msg)
			self.bcast_cmd('MSG', serialize((self.client_id, msg), 'tuple', ['int', 'unicode']), not_to_self = False)
		elif cmd == 'CHALLENGE_CREATE':
			clients, map, players = deserialize(args, 'tuple', [['list', 'int'], 'str', ['list', 'Player']])
			if self.client_id in self.serv.challenges:
				self.die('Duplicate challenge')
			else:
				self.serv.challenges[self.client_id] = (map, set(clients), {self.client_id: players})
				self.mcast_cmd('CHALLENGE_CREATED', serialize((self.client_id, clients, map), 'tuple', ['int', ['list', 'int'], 'str']), self.serv.challenges[self.client_id][1])
		elif cmd == 'CHALLENGE_ACCEPT':
			client_id, players = deserialize(args, 'tuple', ['int', ['list', 'Player']])
			if self.challenge_valid(client_id):
				self.serv.challenges[client_id][2][self.client_id] = players
				self.mcast_cmd('CHALLENGE_ACCEPTED_BY', serialize((client_id, self.client_id), 'tuple', ['int', 'int']), self.serv.challenges[client_id][1])
				self.challenge_cancel_all(except_ = client_id)
				if self.serv.challenges[client_id][1] == set(self.serv.challenges[client_id][2]):
					players = [(cid, p) for cid, ps in self.serv.challenges[client_id][2].items() for p in ps]
					map, (width, height), spawns = load_map(self.serv.challenges[client_id][0])
					map = Grid(width, height, map)
					map.cell_size = (1, 1)
					map.x = map.y = 0
					game = Game(map, spawns, [])
					teams = [(p.name, None, p.team) for cid, p in players]
					spawns = game.get_spawnpoints(teams)
					class Dummy: pass
					main = Dummy()
					main.map = game.map
					main.res = None
					game.all_players = [GamePlayer(name, [(char, x, y, 0) for char, (x, y) in zip(characters, spawn)], main, None) for (name, remote, characters), spawn in zip(teams, spawns)]
					game.client_ids = self.serv.challenges[client_id][1]
					for client in self.serv.clients:
						if client.client_id not in self.serv.challenges[client_id][1]:
							continue
						client.game = game
					self.mcast_cmd('GAME_START', serialize((self.serv.challenges[client_id][0], spawns, players), 'tuple', ['str', ['list', 'list', ':coord'], ['list', 'tuple', ['int', 'Player']]]), self.serv.challenges[client_id][1])
		elif cmd == 'CHALLENGE_REJECT':
			client_id = deserialize(args, 'int')
			if self.challenge_valid(client_id):
				self.challenge_cancel(client_id, self.client_id)
		elif cmd == 'GAME_MOVE':
			p, c, t = deserialize(args, 'tuple', ['int', 'int', ':coord'])
			self.push_actions(self.game.move(self.game.all_players[p].all_characters[c], t))
		elif cmd == 'GAME_ATTACK':
			p, c, t = deserialize(args, 'tuple', ['int', 'int', ':coord'])
			self.push_actions(self.game.attack(self.game.all_players[p].all_characters[c], t))
		elif cmd == 'GAME_ENDTURN':
			self.push_actions(self.game.end_turn())
		else:
			self.die('Unknown command: ' + repr(cmd))
Beispiel #12
0
 def __init__(self, layoutText):
     """
     Initialize the layout display the user has chosen.
     """
     self.width = len(layoutText[0])
     self.height = len(layoutText)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     self.agentPositions = []
     self.numGhosts = 0
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
Beispiel #13
0
 def __init__(self, layoutText):
     self.width = len(layoutText[0])
     self.height= len(layoutText)
     self.walls = Grid(self.width, self.height, 0)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     self.agentPositions = [] ## TODO: (True, pos) if its pacman, (False, pos) otherwise
     self.MyPacmanPos = (0,0)
     self.numGhosts = 0
     self.numEnemyPacmans = 0
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
     self.totalFood = len(self.food.asList())
Beispiel #14
0
def load(grid_id):
    "Load game state from examples"
    difficulty = request.args['difficulty']

    if grid_id not in grid_data or grid_data[grid_id] == None:
        return 'invalid id', 403

    grid = Grid(load_from=grid_data[grid_id])
    grid.read_file(f'examples/{grid.box_len}/{difficulty}.txt')

    grid_data[grid_id] = repr(grid)
    save_data()

    return 'loaded'
Beispiel #15
0
 def __init__(self, layoutText, srv):
     self.server = srv
     self.width = len(layoutText[0])
     self.height = len(layoutText)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     # self.allCapsules = []
     self._hiddenCapsule = []
     self.agentPositions = []
     self.numGhosts = 0
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
     self.totalFood = len(self.food.asList())
    def __init__(self, startingGameState):
        """
        Stores the walls, pacman's starting position and corners.
        """
        self.walls = startingGameState.getWalls()
        self.startingPosition = startingGameState.getPacmanPosition()
        print(self.startingPosition)
        top, right = self.walls.height - 2, self.walls.width - 2

        self.corners = ((1, 1), (1, top), (right, 1), (right, top)
                        )  # corner position as of (x,y)

        self.mapping = {
            (1, 1): [1, 0],
            (1, top): [0, 0],
            (right, 1): [1, 1],
            (right, top): [0, 1]
        }
        for corner in self.corners:
            if not startingGameState.hasFood(*corner):
                print('Warning: no food in corner ' + str(corner))
        self._expanded = 0
        # Number of search nodes expanded
        # Please add any code here which you would like to use
        # in initializing the problem
        "*** YOUR CODE HERE ***"

        self.start = (self.startingPosition, Grid(2, 2, False))
        self.walls = startingGameState.getWalls()
        self.startingGameState = startingGameState
        self.heuristicInfo = {
        }  # A dictionary for the heuristic to store information
Beispiel #17
0
    def evaluationFunction(self, currentGameState: GameState, action: str) -> float:
        """
        Design a better evaluation function here.

        The evaluation function takes in the current and proposed successor
        GameStates (pacman.py) and returns a number, where higher numbers are better.

        The code below extracts some useful information from the state, like the
        remaining food (newFood) and Pacman position after moving (newPos).
        newScaredTimes holds the number of moves that each ghost will remain
        scared because of Pacman having eaten a power pellet.

        Print out these variables to see what you're getting, then combine them
        to create a masterful evaluation function.
        """
        # Useful information you can extract from a GameState (pacman.py)
        successorGameState = currentGameState.generatePacmanSuccessor(action)
        walls = successorGameState.getWalls()
        width = walls.width
        height = walls.height
        newPos = successorGameState.getPacmanPosition()
        newFood = successorGameState.getFood()
        newGhostStates = successorGameState.getGhostStates()
        newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]

        "*** YOUR CODE HERE ***"
        ghosts = Grid(width, height)
        for i in range(len(newGhostStates)):
            if newScaredTimes[i] <= 0:
                x, y = newGhostStates[i].getPosition()
                ghosts[int(x)][int(y)] = True

        queue = util.Queue()
        queue.push((newPos, 0))
        visited = set()
        shortest = float('inf')
        ghosts_dis = []
        while not queue.isEmpty():
            cur, dis = queue.pop()
            x, y = cur
            if in_range(cur, width, height) and not walls[x][y] and cur not in visited:
                visited.add(cur)
                if newFood[x][y]:
                    shortest = min(dis, shortest)
                if ghosts[x][y]:
                    ghosts_dis.append(dis)
                for d in DIRECTIONS:
                    queue.push(((x + d[0], y + d[1]), dis + 1))
        if shortest == float('inf'):
            shortest = 0
            
        score = successorGameState.getScore()
        def d(x):
            if x == 0:
                return float('inf')
            return 9 / (x**2)
        score -= shortest + sum(map(d, ghosts_dis))
        if action == 'Stop':
            score -= 10
        return score
Beispiel #18
0
def _ghost_cost(_ghosts: List[AgentState], pos: Tuple[int, int], walls: Grid):
    width = walls.width
    height = walls.height

    ghosts = Grid(width, height)
    for i in range(len(_ghosts)):
        x, y = _ghosts[i].getPosition()
        ghosts[int(x)][int(y)] = _ghosts[i].scaredTimer

    queue = util.Queue()
    queue.push((pos, 0))
    visited = set()
    ghosts_dis = []
    s_ghosts_dis = []
    while not queue.isEmpty():
        cur, dis = queue.pop()
        x, y = cur
        if in_range(cur, width, height) and not walls[x][y] and cur not in visited:
            visited.add(cur)
            if ghosts[x][y] != False:
                if ghosts[x][y] <= 0:
                    ghosts_dis.append(dis)
                else:
                    s_ghosts_dis.append((dis, ghosts[x][y]))
                    pass
            for d in DIRECTIONS:
                queue.push(((x + d[0], y + d[1]), dis + 1))
    return ghosts_dis, s_ghosts_dis
Beispiel #19
0
 def initializeVisibilityMatrix(self):
     global VISIBILITY_MATRIX_CACHE
     if reduce(str.__add__, self.layoutText) not in VISIBILITY_MATRIX_CACHE:
         from game import Directions
         vecs = [(-0.5, 0), (0.5, 0), (0, -0.5), (0, 0.5)]
         dirs = [
             Directions.NORTH, Directions.SOUTH, Directions.WEST,
             Directions.EAST
         ]
         vis = Grid(
             self.width, self.height, {
                 Directions.NORTH: set(),
                 Directions.SOUTH: set(),
                 Directions.EAST: set(),
                 Directions.WEST: set(),
                 Directions.STOP: set()
             })
         for x in range(self.width):
             for y in range(self.height):
                 if self.walls[x][y] == False:
                     for vec, direction in zip(vecs, dirs):
                         dx, dy = vec
                         nextx, nexty = x + dx, y + dy
                         while (nextx + nexty) != int(nextx) + int(
                                 nexty) or not self.walls[int(nextx)][int(
                                     nexty)]:
                             vis[x][y][direction].add((nextx, nexty))
                             nextx, nexty = x + dx, y + dy
         self.visibility = vis
         VISIBILITY_MATRIX_CACHE[reduce(str.__add__, self.layoutText)] = vis
     else:
         self.visibility = VISIBILITY_MATRIX_CACHE[reduce(
             str.__add__, self.layoutText)]
Beispiel #20
0
 def __init__(self, startingGameState):
     """
     Stores the walls, pacman's starting position and corners.
     """
     self.walls = startingGameState.getWalls()
     self.startingPosition = startingGameState.getPacmanPosition()
     top, right = self.walls.height - 2, self.walls.width - 2
     self.corners = ((1, 1), (1, top), (right, 1), (right, top))
     for corner in self.corners:
         if not startingGameState.hasFood(*corner):
             print('Warning: no food in corner ' + str(corner))
     self._expanded = 0  # DO NOT CHANGE; Number of search nodes expanded
     # Please add any code here which you would like to use
     # in initializing the problem
     self._visited, self._visitedlist = {}, []  # DO NOT CHANGE
     cor = Grid(right + 1,
                top + 1)  #a grid for the corners, just like the foodgrid#
     for x in range(0, right + 1):
         for y in range(0, top + 1):
             cor[x][y] = False
     for corner in self.corners:
         x = corner[0]
         y = corner[1]
         cor[x][y] = True
     self.start = (startingGameState.getPacmanPosition(), cor)
Beispiel #21
0
 def __init__(self):
     pygame.init()
     pygame.display.set_caption("Grid World")
     self.clock = pygame.time.Clock()
     self.last_tick = pygame.time.get_ticks()
     self.screen_res = [400, 470]
     self.font = pygame.font.SysFont("Calibri", 16)
     self.screen = pygame.display.set_mode(self.screen_res,
                                           pygame.HWSURFACE, 32)
     self.show_checked = True
     self.quit = False
     self.type = "dfs"
     self.grid = Grid(True)
     self.ai = AI(self.grid, self.type)
     self.run = False
     self.pause = False
Beispiel #22
0
 def initializeVisibilityMatrix(self):
     """
     Create the visibility matrix of what"s on the display.
     """
     global vismatcache
     if reduce(str.__add__, self.layoutText) not in vismatcache:
         from game import Directions
         vecs = [(-0.5, 0), (0.5, 0), (0, -0.5), (0, 0.5)]
         dirs = [
             Directions.NORTH, Directions.SOUTH, Directions.WEST,
             Directions.EAST
         ]
         vis = Grid(
             self.width, self.height, {
                 Directions.NORTH: set(),
                 Directions.SOUTH: set(),
                 Directions.EAST: set(),
                 Directions.WEST: set(),
                 Directions.STOP: set()
             })
         for x in range(self.width):
             for y in range(self.height):
                 if self.walls[x][y] == False:
                     for vec, direction in zip(vecs, dirs):
                         dx, dy = vec
                         nextx, nexty = x + dx, y + dy
                         while (nextx + nexty) != int(nextx) + int(
                                 nexty) or not self.walls[int(nextx)][int(
                                     nexty)]:
                             vis[x][y][direction].add((nextx, nexty))
                             nextx, nexty = x + dx, y + dy
             self.visibility = vis
             vismatcache[reduce(str.__add__, self.layoutText)] = vis
     else:
         self.visibility = vismatcache[reduce(str.__add__, self.layoutText)]
Beispiel #23
0
def load():
    box_len = get_box_len()

    difficulties = {1: 'easy', 2: 'medium', 3: 'hard', 4: 'harder'}

    print('Pick a difficulty to solve:')
    print('  1. Easy')
    print('  2. Medium')
    print('  3. Hard')
    print('  4. Harder')
    difficulty = difficulties[int(input())]

    choice = f'examples/{box_len}/{difficulty}.txt'
    grid = Grid(box_len)
    grid.read_file(choice)
    return grid
 def __init__(self, layoutText):
     #here
     
     self.width = len(layoutText[0])
     self.height= len(layoutText)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     # Here
     global portal
     portal =[]
     self.portal = Grid(self.width,self.height,False)
     self.capsules = []
     self.agentPositions = []
     self.numGhosts = 0
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
     self.totalFood = len(self.food.asList())
Beispiel #25
0
 def test_set_initial_state(self):
     initial_state = [
         [True, True],
         [True, True]
     ]
     test_grid = Grid(2, initial_state)
     for y in range(2):
         for x in range(2):
             assert test_grid.diagram[y][x].alive is True
Beispiel #26
0
def enter():
    box_len = get_box_len()
    grid = Grid(box_len)

    for row in range(box_len * box_len):
        for col in range(box_len * box_len):
            print(grid)
            val = input(f'Value for ({row + 1}, {col + 1}): ') or 0
            try:
                val = int(val)
            except ValueError:
                val = ord(val.upper()) - 55
            grid.get_cell(row, col).value = val

    if not grid.is_valid():
        print('invalid board')
        exit()
    return grid
Beispiel #27
0
	def __init__(self, layoutText, numAgents = 2):
		self.width = len(layoutText[0])
		self.height = len(layoutText)
		self.obstacles = Grid(self.width, self.height, False)
		self.agentPositions = []
		self.numPursuers = 0
		self.numAgents = numAgents
		self.processLayoutText(layoutText)
		self.layoutText = layoutText
Beispiel #28
0
def main():
    world = World(
        Grid(3, [[False, False, False], [True, True, True],
                 [False, False, False]]))
    for i in range(100):
        world.tick()
    for event in world.history:
        for row in event.display():
            print(" ".join(row))
        print("\n")
 def __init__(self, layoutText):
     self.width = len(layoutText[0])
     self.height = len(layoutText)
     self.racetrack = Grid(self.width, self.height, False)
     self.startStates = []
     self.finishStates = []
     self.agentPositions = []
     self.possibleAgentPositions = []
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
Beispiel #30
0
def new():
    "Start a new game and register a new id"
    grid_id = str(len(grid_data))
    size = int(request.args['size'])
    grid = Grid(size)

    grid_data[grid_id] = repr(grid)
    save_data()

    return grid_id
Beispiel #31
0
def halfGrid(grid, red):
    halfway = grid.width // 2
    halfgrid = Grid(grid.width, grid.height, False)
    if red: xrange = range(halfway)
    else: xrange = range(halfway, grid.width)

    for y in range(grid.height):
        for x in xrange:
            if grid[x][y]: halfgrid[x][y] = True

    return halfgrid
Beispiel #32
0
 def __init__(self, layoutText):
     self.width = len(layoutText[0])
     self.height= len(layoutText)
     self.walls = Grid(self.width, self.height, False)
     self.food = Grid(self.width, self.height, False)
     self.capsules = []
     self.agentPositions = []
     self.numGhosts = 0
     self.processLayoutText(layoutText)
     self.layoutText = layoutText
     self.totalFood = len(self.food.asList())
Beispiel #33
0
def test_shift_left():
    grid = Grid()
    assert(grid.shift_left([2, 0, 0, 0]) == [2, 0, 0, 0])
    assert(grid.shift_left([0, 0, 0, 2]) == [2, 0, 0, 0])
    assert(grid.shift_left([2, 2, 0, 0]) == [4, 0, 0, 0])
    assert(grid.shift_left([2, 0, 2, 0]) == [4, 0, 0, 0])
    assert(grid.shift_left([2, 0, 0, 2]) == [4, 0, 0, 0])
    assert(grid.shift_left([0, 0, 2, 2]) == [4, 0, 0, 0])
    assert(grid.shift_left([2, 2, 2, 0]) == [4, 2, 0, 0])
    assert(grid.shift_left([2, 4, 0, 0]) == [2, 4, 0, 0])
    assert(grid.shift_left([0, 0, 2, 4]) == [2, 4, 0, 0])
    assert(grid.shift_left([2, 2, 2, 2]) == [4, 4, 0, 0])
    assert(grid.shift_left([4, 4, 4, 4]) == [8, 8, 0, 0])
    assert(grid.shift_left([2, 0, 4, 4]) == [2, 8, 0, 0])
    assert(grid.shift_left([2, 2, 0, 2]) == [4, 2, 0, 0])
    assert(grid.shift_left([2, 2, 4, 4]) == [4, 8, 0, 0])
    assert(grid.shift_left([8, 8, 4, 2]) == [16, 4, 2, 0])
    print "Left tests passed."
Beispiel #34
0
def test_shift_right():
    grid = Grid()
    assert(grid.shift_right([2, 0, 0, 0]) == [0, 0, 0, 2])
    assert(grid.shift_right([2, 2, 0, 0]) == [0, 0, 0, 4])
    assert(grid.shift_right([2, 0, 2, 0]) == [0, 0, 0, 4])
    assert(grid.shift_right([2, 0, 0, 2]) == [0, 0, 0, 4])
    assert(grid.shift_right([0, 0, 2, 2]) == [0, 0, 0, 4])
    assert(grid.shift_right([2, 4, 0, 0]) == [0, 0, 2, 4])
    assert(grid.shift_right([2, 2, 2, 2]) == [0, 0, 4, 4])
    assert(grid.shift_right([4, 4, 4, 4]) == [0, 0, 8, 8])
    assert(grid.shift_right([2, 0, 4, 4]) == [0, 0, 2, 8])
    assert(grid.shift_right([2, 2, 0, 2]) == [0, 0, 2, 4])
    assert(grid.shift_right([2, 2, 4, 4]) == [0, 0, 4, 8])
    assert(grid.shift_right([8, 8, 4, 2]) == [0, 16, 4, 2])
    print "Right tests passed."
Beispiel #35
0
 def __init__(self, parent, image_repository):
     super(Board, self).__init__(parent)
     self.started = True
     self.paused = False
     self.image_repository = image_repository
     self.config = Config.get()
     self.size = 50
     self.grid = Grid.random(self.config.properties['board_width'], self.config.properties['board_height'],
                             self.config.properties['rock_count'], self.config.properties['diamond_count'])
     self.game_state = GameState(self.grid, self.grid.cells[1][1], self)
     for x in range(self.grid.width):
         for y in range(self.grid.height):
             self.grid.cells[x][y].game_state = self.game_state
     self.initUI()
     self.timer = QtCore.QTimer()
     self.timer.timeout.connect(self.update_game)
     self.timer.start(100)
Beispiel #36
0
 def __init__(self, layoutText=None, seed=None, width=None, height=None, vpi=False):
     if layoutText:
         self.width = len(layoutText[0])
         self.height= len(layoutText)
         self.walls = Grid(self.width, self.height, False)
         self.redWalls = Grid(self.width, self.height, False)
         self.blueWalls = Grid(self.width, self.height, False)
         self.food = Grid(self.width, self.height, False)
         self.capsules = []
         self.agentPositions = []
         self.numGhosts = 0
         self.processLayoutText(layoutText)
         self.layoutText = layoutText
         self.totalFood = len(self.food.asList())
     elif vpi:
         layoutText = generateVPIHuntersBoard(seed)
         self.__init__(layoutText)
     else:
         layoutText = generateRandomHuntersBoard(seed, width, height)
         self.__init__(layoutText)
Beispiel #37
0
class Layout:
    """
    A Layout manages the static information about the game board.
    """

    def __init__(self, layoutText):
        self.width = len(layoutText[0])
        self.height= len(layoutText)
        self.walls = Grid(self.width, self.height, False)
        self.food = Grid(self.width, self.height, False)
        self.capsules = []
        self.agentPositions = []
        self.numGhosts = 0
        self.processLayoutText(layoutText)
        self.layoutText = layoutText
        self.totalFood = len(self.food.asList())
        # self.initializeVisibilityMatrix()

    def getNumGhosts(self):
        return self.numGhosts

    def initializeVisibilityMatrix(self):
        global VISIBILITY_MATRIX_CACHE
        if reduce(str.__add__, self.layoutText) not in VISIBILITY_MATRIX_CACHE:
            from game import Directions
            vecs = [(-0.5,0), (0.5,0),(0,-0.5),(0,0.5)]
            dirs = [Directions.NORTH, Directions.SOUTH, Directions.WEST, Directions.EAST]
            vis = Grid(self.width, self.height, {Directions.NORTH:set(), Directions.SOUTH:set(), Directions.EAST:set(), Directions.WEST:set(), Directions.STOP:set()})
            for x in range(self.width):
                for y in range(self.height):
                    if self.walls[x][y] == False:
                        for vec, direction in zip(vecs, dirs):
                            dx, dy = vec
                            nextx, nexty = x + dx, y + dy
                            while (nextx + nexty) != int(nextx) + int(nexty) or not self.walls[int(nextx)][int(nexty)] :
                                vis[x][y][direction].add((nextx, nexty))
                                nextx, nexty = x + dx, y + dy
            self.visibility = vis
            VISIBILITY_MATRIX_CACHE[reduce(str.__add__, self.layoutText)] = vis
        else:
            self.visibility = VISIBILITY_MATRIX_CACHE[reduce(str.__add__, self.layoutText)]

    def isWall(self, pos):
        x, col = pos
        return self.walls[x][col]

    def getRandomLegalPosition(self):
        x = random.choice(range(self.width))
        y = random.choice(range(self.height))
        while self.isWall( (x, y) ):
            x = random.choice(range(self.width))
            y = random.choice(range(self.height))
        return (x,y)

    def getRandomCorner(self):
        poses = [(1,1), (1, self.height - 2), (self.width - 2, 1), (self.width - 2, self.height - 2)]
        return random.choice(poses)

    def getFurthestCorner(self, pacPos):
        poses = [(1,1), (1, self.height - 2), (self.width - 2, 1), (self.width - 2, self.height - 2)]
        dist, pos = max([(manhattanDistance(p, pacPos), p) for p in poses])
        return pos

    def isVisibleFrom(self, ghostPos, pacPos, pacDirection):
        row, col = [int(x) for x in pacPos]
        return ghostPos in self.visibility[row][col][pacDirection]

    def __str__(self):
        return "\n".join(self.layoutText)

    def deepCopy(self):
        return Layout(self.layoutText[:])

    def processLayoutText(self, layoutText):
        """
        Coordinates are flipped from the input format to the (x,y) convention here

        The shape of the maze.  Each character
        represents a different type of object.
         % - Wall
         . - Food
         o - Capsule
         G - Ghost
         P - Pacman
        Other characters are ignored.
        """
        maxY = self.height - 1
        for y in range(self.height):
            for x in range(self.width):
                layoutChar = layoutText[maxY - y][x]
                self.processLayoutChar(x, y, layoutChar)
        self.agentPositions.sort()
        self.agentPositions = [ ( i == 0, pos) for i, pos in self.agentPositions]

    def processLayoutChar(self, x, y, layoutChar):
        if layoutChar == '%':
            self.walls[x][y] = True
        elif layoutChar == '.':
            self.food[x][y] = True
        elif layoutChar == 'o':
            self.capsules.append((x, y))
        elif layoutChar == 'P':
            self.agentPositions.append( (0, (x, y) ) )
        elif layoutChar in ['G']:
            self.agentPositions.append( (1, (x, y) ) )
            self.numGhosts += 1
        elif layoutChar in  ['1', '2', '3', '4']:
            self.agentPositions.append( (int(layoutChar), (x,y)))
            self.numGhosts += 1