Exemplo n.º 1
0
def initialize_graphics(instance):
    from PySide import QtGui, QtCore

    #Calculates points to be visualized, stores as "ambushes" which are visualized.
    def calculatePOIS(points=[]):
        results = points
        if points == None:
            for x in range(2):
                p = instance.level.findRandomFreePositionInBox(
                    instance.level.area)
                o = Vector2(random.uniform(-0.5, 0.5),
                            random.uniform(-0.5, 0.5)).normalized()
                results.append(p)
        instance.ambushes = []
        instance.ambushes = results

    calculatePOIS()

    def drawPreWorld(visualizer):
        brightest = max([
            instance.visibilities.pixel(i, j)
            for i, j in itertools.product(range(88), range(50))
        ])

        for i, j in itertools.product(range(88), range(50)):
            n = instance.terrain[j][i]
            if n:
                if instance.mode == instance.MODE_VISIBILITY:
                    d = instance.visibilities.pixel(i,
                                                    j) * 255 / (brightest + 1)
            else:
                d = 32
            visualizer.drawPixel((i, j), QtGui.qRgb(d, d, d))

    def drawPreBots(visualizer):
        for p in instance.ambushes:
            visualizer.drawCircle(p, QtGui.qRgb(255, 255, 0), 5)

    def keyPressed(e):
        if e.key() == QtCore.Qt.Key_Space:
            instance.mode = 1 - instance.mode

    #Main logic #!!!! REQUIRES INSTANCE TO HAVE GRAPH
    instance.mode = instance.MODE_VISIBILITY
    instance.visualizer = VisualizerApplication(instance)

    instance.visualizer.setDrawHookPreWorld(drawPreWorld)
    instance.visualizer.setDrawHookPreBots(drawPreBots)
    instance.visualizer.setKeyboardHook(keyPressed)

    #Coloration based on score in an 88 by 50 pixel grid?
    #Grid squares are set with setPixel(xcoord, ycoord, intRepresentingDarkness)
    instance.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
    instance.visibilities.fill(0)

    def evaluate(position, orientation, callback):
        return 1
Exemplo n.º 2
0
    def initialize(self):
        self.makeGraph()

        self.graph.add_node("enemy_base")
        self.positions["enemy_base"] = None
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight=1.0)

        self.graph.add_node("base")
        self.positions["base"] = None
        start, finish = self.level.botSpawnAreas[self.game.team.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i], weight=1.0)

        self.node_EnemyFlagIndex = self.getNodeIndex(
            self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(
            self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph,
                                source="enemy_base",
                                target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph,
                                source=self.node_EnemyFlagIndex,
                                target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        self.positions["enemy_base_to_flag"] = None
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score"
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        self.positions["enemy_flag_to_score"] = None
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
        self.positions["enemy_base_to_score"] = None
        # for vertex in vb2s:
        #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(
            self.graph, self.node_EnemyFlagToScoreIndex)

        self.graph.remove_node("base")
        self.graph.remove_node("enemy_base")
        self.graph.remove_node(self.node_EnemyBaseToFlagIndex)
        self.graph.remove_node(self.node_EnemyFlagToScoreIndex)
        self.graph.remove_node(self.node_EnemyBaseToScoreIndex)

        self.updateEdgeWeights()

        self.paths = {b: None for b in self.game.team.members}

        self.visualizer = VisualizerApplication(self)
        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setDrawHookEnd(self.drawEnd)
Exemplo n.º 3
0
class SneakingCommander(Commander):
    def initialize(self):
        self.makeGraph()

        self.graph.add_node("enemy_base")
        self.positions["enemy_base"] = None
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight=1.0)

        self.graph.add_node("base")
        self.positions["base"] = None
        start, finish = self.level.botSpawnAreas[self.game.team.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i], weight=1.0)

        self.node_EnemyFlagIndex = self.getNodeIndex(
            self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(
            self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph,
                                source="enemy_base",
                                target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph,
                                source=self.node_EnemyFlagIndex,
                                target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        self.positions["enemy_base_to_flag"] = None
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score"
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        self.positions["enemy_flag_to_score"] = None
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
        self.positions["enemy_base_to_score"] = None
        # for vertex in vb2s:
        #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(
            self.graph, self.node_EnemyFlagToScoreIndex)

        self.graph.remove_node("base")
        self.graph.remove_node("enemy_base")
        self.graph.remove_node(self.node_EnemyBaseToFlagIndex)
        self.graph.remove_node(self.node_EnemyFlagToScoreIndex)
        self.graph.remove_node(self.node_EnemyBaseToScoreIndex)

        self.updateEdgeWeights()

        self.paths = {b: None for b in self.game.team.members}

        self.visualizer = VisualizerApplication(self)
        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setDrawHookEnd(self.drawEnd)
        # self.visualizer.setKeyboardHook(self.keyboard)

    def getDistance(self, x, y):
        n = self.terrain[y][x]
        if n:
            return self.distances[n]
        else:
            return 0.0

    def shutdown(self):
        self.visualizer.quit()
        del self.visualizer

    def makeGraph(self):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        g = nx.Graph(directed=False, map_height=height, map_width=width)
        #self.positions = g.new_vertex_property('vector<float>')
        #self.weights = g.new_edge_property('float')

        #g.vertex_properties['pos'] = self.positions
        #g.edge_properties['weight'] = self.weights

        self.terrain = []
        self.positions = {}
        for j in range(0, height):
            row = []
            for i in range(0, width):
                if blocks[i][j] == 0:
                    g.add_node(i + j * width,
                               position=(float(i) + 0.5, float(j) + 0.5))
                    self.positions[i + j * width] = Vector2(
                        float(i) + 0.5,
                        float(j) + 0.5)
                    row.append(i + j * width)
                else:
                    row.append(None)
            self.terrain.append(row)

        for i, j in itertools.product(range(0, width), range(0, height)):
            p = self.terrain[j][i]
            if not p: continue

            if i < width - 1:
                q = self.terrain[j][i + 1]
                if q:
                    e = g.add_edge(p, q, weight=1.0)

            if j < height - 1:
                r = self.terrain[j + 1][i]
                if r:
                    e = g.add_edge(p, r, weight=1.0)

        self.graph = g

    def getNodeIndex(self, position):
        i = int(position.x)
        j = int(position.y)
        width = self.graph.graph["map_width"]
        return i + j * width

    def updateEdgeWeights(self):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        # update the weights in the graph based on the distance to the shortest path between the enemy flag and enemy score location

        for j in range(0, height):
            for i in range(0, width - 1):
                a = self.terrain[j][i]
                b = self.terrain[j][i + 1]
                if a and b:
                    w = max(255 - 4 * (self.distances[a] + self.distances[b]),
                            0)
                    self.graph[a][b]['weight'] = w

        for j in range(0, height - 1):
            for i in range(0, width):
                a = self.terrain[j][i]
                b = self.terrain[j + 1][i]
                if a and b:
                    w = max(255 - 4 * (self.distances[a] + self.distances[b]),
                            0)
                    self.graph[a][b]['weight'] = w

    def tick(self):
        for bot in self.game.bots_alive:
            if bot.state == BotInfo.STATE_IDLE:
                if not bot.flag:
                    # go to flag
                    dst = self.game.enemyTeam.flag.position
                    message = 'go to flag'
                else:
                    # go home
                    dst = self.game.team.flagScoreLocation
                    message = 'go home'

                # calculate the shortest path between the bot and the target using our weights
                srcIndex = self.getNodeIndex(bot.position)
                dstIndex = self.getNodeIndex(dst)
                pathNodes = nx.shortest_path(self.graph, srcIndex, dstIndex,
                                             'weight')

                pathLength = len(pathNodes)
                if pathLength > 0:
                    path = [
                        self.positions[p] for p in pathNodes
                        if self.positions[p]
                    ]
                    if len(path) > 0:
                        orderPath = path[::10]
                        orderPath.append(
                            path[-1]
                        )  # take every 10th point including last point
                        self.issue(commands.Move,
                                   bot,
                                   orderPath,
                                   description=message)
                        self.paths[
                            bot] = path  # store the path for visualization

        self.visualizer.tick()

    def drawPreWorld(self, visualizer):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        furthest = max(
            [self.distances[n] for n in itertools.chain(*self.terrain) if n])

        for i, j in itertools.product(range(width), range(height)):
            # average weights of edges connected to this node
            sum, count = 0, 0
            node = self.terrain[j][i]
            if node:
                for offset in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
                    ni, nj = i + offset[0], j + offset[1]
                    if ni < 0 or ni >= width or nj < 0 or nj >= height:
                        continue
                    neighbour = self.terrain[nj][ni]
                    if neighbour:
                        sum, count = sum + self.graph[node][neighbour][
                            'weight'], count + 1
            if count:
                d = sum / count
            else:
                d = 32

            if self.level.blockHeights[i][j] == 1:
                visualizer.drawPixel((i, j), QtGui.qRgb(196, 196, 196))
            elif self.level.blockHeights[i][j] >= 2:
                visualizer.drawPixel((i, j), QtGui.qRgb(64, 64, 64))
            else:
                visualizer.drawPixel((i, j), QtGui.qRgb(d, d, d))

    def drawPreBots(self, visualizer):
        for name, bot in self.game.bots.items():
            if bot.position is None:
                continue

            if 'Red' in name:
                color = QtGui.qRgb(255, 0, 0)
                pathColor = QtGui.qRgb(127, 0, 0)
            else:
                color = QtGui.qRgb(0, 0, 255)
                pathColor = QtGui.qRgb(0, 0, 127)

            if bot.health <= 0.0:
                color = QtGui.qRgb(0, 0, 0)

            if (bot.health > 0) and (bot in self.paths) and self.paths[bot]:
                path = self.paths[bot]
                pLast = bot.position
                for p in path:
                    visualizer.drawPixel((int(p.x), int(p.y)),
                                         QtGui.qRgb(255, 255, 0))
                    # visualizer.drawRay(pLast, p, color)
                    pLast = p

    def drawEnd(self, visualizer):
        pass
Exemplo n.º 4
0
    def initialize(self):
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()
        
        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight = 1.0)            


        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i],weight = 1.0)            


        self.node_EnemyFlagIndex = self.getNodeIndex(self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph, source=self.node_EnemyFlagIndex, target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        path = vb2f+vf2s
        edgesinpath=zip(path[0:],path[1:])        
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            orientation = (next_position - position).normalized()

            def visible(p):
                delta = (p-position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)

        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [self.game.team.flag.position, self.game.enemyTeam.flag.position,
                  self.game.team.flagScoreLocation, self.game.enemyTeam.flagScoreLocation] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            n = self.terrain[j][i]
            if not n: continue
            
            position = Vector2(*self.graph.node[n]["position"])
            def visible(p):
                delta = (p-position)
                l = delta.length()
                return l <= 15.0

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)


        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex, vertex, weight = 1.0)
        
        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score" 
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex, vertex, weight = 1.0)
        
        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
       # for vertex in vb2s:
       #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyFlagToScoreIndex)
        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes()
Exemplo n.º 5
0
class AmbushCommander(Commander):
    """
        Display current state and predictions on the screen in a PyQT application.
    """
    MODE_VISIBILITY = 0 
    MODE_TRAVELLING = 1

    def drawPreWorld(self, visualizer):
       furthest = max([self.distances[n] for n in itertools.chain(*self.terrain) if n])
       brightest = max([self.visibilities.pixel(i,j) for i, j in itertools.product(range(88), range(50))])
        
        # visible = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        # visible.fill(0)

       for i, j in itertools.product(range(88), range(50)):            
            n = self.terrain[j][i]
            if n:
                if self.mode == self.MODE_TRAVELLING:
                    d = self.distances[n] * 255.0 / furthest
                if self.mode == self.MODE_VISIBILITY:
                    d = self.visibilities.pixel(i,j) * 255 / brightest
            else:                
                d = 32
            visualizer.drawPixel((i, j), QtGui.qRgb(d,d,d))
                
    def drawPreBots(self, visualizer):
        for p, _ in self.ambushes:
            visualizer.drawCircle(p, QtGui.qRgb(255,255,0), 0.5)
            
    def keyPressed(self, e):
        if e.key() == QtCore.Qt.Key_Space:
            self.mode = 1 - self.mode

    def initialize(self):
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()
        
        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight = 1.0)            


        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i],weight = 1.0)            


        self.node_EnemyFlagIndex = self.getNodeIndex(self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph, source=self.node_EnemyFlagIndex, target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        path = vb2f+vf2s
        edgesinpath=zip(path[0:],path[1:])        
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            orientation = (next_position - position).normalized()

            def visible(p):
                delta = (p-position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)

        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [self.game.team.flag.position, self.game.enemyTeam.flag.position,
                  self.game.team.flagScoreLocation, self.game.enemyTeam.flagScoreLocation] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            n = self.terrain[j][i]
            if not n: continue
            
            position = Vector2(*self.graph.node[n]["position"])
            def visible(p):
                delta = (p-position)
                l = delta.length()
                return l <= 15.0

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)


        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex, vertex, weight = 1.0)
        
        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score" 
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex, vertex, weight = 1.0)
        
        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
       # for vertex in vb2s:
       #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyFlagToScoreIndex)
        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes()

    def evaluate(self, position, orientation, callback):
        cells = []
        w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
        w.compute(position)

        def visible(p):
            delta = (p-position)
            l = delta.length()
            if l > 15.0:
                return False
            if l < 2.5:
                return True
            delta /= l
            return orientation.dotProduct(delta) > 0.9238

        total = 0.0
        for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
            total += callback(x,y)
        return total

    def findNearby(self, results, candidate, distance = 2.0):
        d = distance * distance
        s, (position, _) = candidate
        for _, (p, _) in results:
            if (p-position).squaredLength() < d:
                return True            
        return False

    def replaceInList(self, candidate, results, maximum = 40):
        results.append(candidate)

        if len(results) < 50:
            return

        copy = results[:]
        copy.sort(key=lambda s: -s[0])

        results[:] = []

        for i, c in enumerate(copy):
            if not self.findNearby(results, c):
                results.append(c)
            if len(results) >= maximum:
                break

    def calculateAmbushes(self):        
        results = []
        for i in range(2000):  # NOTE: you must feed in better pre-selected positions (eg near boxes) to get good results with this number of iterations.
            if (i%1000)==0: print >>sys.stderr, '.',
            p = self.level.findRandomFreePositionInBox(self.level.area)
            o = Vector2(random.uniform(-0.5, 0.5), random.uniform(-0.5, 0.5)).normalized()

            s = self.evaluate(p, o, lambda x, y: 25.0-square(self.getDistance(x, y))) - square(self.visibilities.pixel(int(p.x), int(p.y)) * 5.0)
            self.replaceInList((s, (p,o)), results)

        self.ambushes = [r for _, r in results]

    def getSituation(self):
        result = None
        score = 0.0
        for i in range(10):
            p = self.level.findRandomFreePositionInBox(self.level.area)
            o = Vector2(random.uniform(-0.5, 0.5), random.uniform(-0.5, 0.5)).normalized()
            s = self.evaluate(p, o, lambda x, y: 15.0-self.getDistance(x, y))
                # - self.getDistance(int(p.x), int(p.y)) * 100 
            if s > score or result == None:
                result = (p, o)
                score = s
        print score
        return result

    def getDistance(self, x, y):
        n = self.terrain[y][x]
        if n:
            return self.distances[n]
        else:
            return 0.0

    def tick(self):
        for e in self.game.match.combatEvents[self.index:]:
            if e.type != gameinfo.MatchCombatEvent.TYPE_RESPAWN:
                continue
            if e.subject in self.queue:
                del self.queue[e.subject] 
        self.index = len(self.game.match.combatEvents)

        for bot in self.game.bots_available:
            if bot in self.queue:
                p, o = self.queue[bot]
                if (bot.position-p).length() < 1.0:
                    self.issue(commands.Defend, bot, o)
                    continue
            else:
                p, o = random.choice(self.ambushes)
                self.queue[bot] = (p, o)
            
            self.issue(commands.Charge, bot, p)
        
        self.visualizer.tick()

    def shutdown(self):
        self.visualizer.quit()
        del self.visualizer

    def makeGraph(self):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        g = nx.Graph(directed=False, map_height = height, map_width = width)
        #self.positions = g.new_vertex_property('vector<float>')
        #self.weights = g.new_edge_property('float')
    
        #g.vertex_properties['pos'] = self.positions
        #g.edge_properties['weight'] = self.weights
    
        self.terrain = []
        for j in range(0, height):
            row = []
            for i in range(0,width):
                if blocks[i][j] == 0:
                    g.add_node(i+j*width, position = (float(i)+0.5, float(j)+0.5) )
                    row.append(i+j*width)
                else:
                    row.append(None)
            self.terrain.append(row)
        
        for i, j in itertools.product(range(0, width), range(0, height)):
            p = self.terrain[j][i]
            if not p: continue
    
            if i < width-1:
                q = self.terrain[j][i+1]
                if q:
                    e = g.add_edge(p, q, weight = 1.0)
    
            if j < height-1:
                r = self.terrain[j+1][i]
                if r:
                    e = g.add_edge(p, r, weight = 1.0)
    
        self.graph = g



    def getNodeIndex(self, position):
        i = int(position.x)
        j = int(position.y)
        width = self.graph.graph["map_width"]
        return i+j*width
Exemplo n.º 6
0
    def initialize(self):
        self.makeGraph()
        
        self.graph.add_node("enemy_base")
        self.positions["enemy_base"] = None
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight = 1.0)

        self.graph.add_node("base")
        self.positions["base"] = None
        start, finish = self.level.botSpawnAreas[self.game.team.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i], weight = 1.0)

        self.node_EnemyFlagIndex = self.getNodeIndex(self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph, source=self.node_EnemyFlagIndex, target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        self.positions["enemy_base_to_flag"] = None
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex, vertex, weight = 1.0)
        
        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score" 
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        self.positions["enemy_flag_to_score"] = None
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex, vertex, weight = 1.0)
        
        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
        self.positions["enemy_base_to_score"] = None
       # for vertex in vb2s:
       #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyFlagToScoreIndex)

        self.graph.remove_node("base")
        self.graph.remove_node("enemy_base")
        self.graph.remove_node(self.node_EnemyBaseToFlagIndex)
        self.graph.remove_node(self.node_EnemyFlagToScoreIndex)
        self.graph.remove_node(self.node_EnemyBaseToScoreIndex)

        self.updateEdgeWeights()

        self.paths = {b: None for b in self.game.team.members}

        self.visualizer = VisualizerApplication(self)
        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setDrawHookEnd(self.drawEnd)
Exemplo n.º 7
0
class SneakingCommander(Commander):

    def initialize(self):
        self.makeGraph()
        
        self.graph.add_node("enemy_base")
        self.positions["enemy_base"] = None
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight = 1.0)

        self.graph.add_node("base")
        self.positions["base"] = None
        start, finish = self.level.botSpawnAreas[self.game.team.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i], weight = 1.0)

        self.node_EnemyFlagIndex = self.getNodeIndex(self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph, source=self.node_EnemyFlagIndex, target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        self.positions["enemy_base_to_flag"] = None
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex, vertex, weight = 1.0)
        
        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score" 
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        self.positions["enemy_flag_to_score"] = None
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex, vertex, weight = 1.0)
        
        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
        self.positions["enemy_base_to_score"] = None
       # for vertex in vb2s:
       #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyFlagToScoreIndex)

        self.graph.remove_node("base")
        self.graph.remove_node("enemy_base")
        self.graph.remove_node(self.node_EnemyBaseToFlagIndex)
        self.graph.remove_node(self.node_EnemyFlagToScoreIndex)
        self.graph.remove_node(self.node_EnemyBaseToScoreIndex)

        self.updateEdgeWeights()

        self.paths = {b: None for b in self.game.team.members}

        self.visualizer = VisualizerApplication(self)
        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setDrawHookEnd(self.drawEnd)
        # self.visualizer.setKeyboardHook(self.keyboard)

    def getDistance(self, x, y):
        n = self.terrain[y][x]
        if n:
            return self.distances[n]
        else:
            return 0.0



    def shutdown(self):
        self.visualizer.quit()
        del self.visualizer


    def makeGraph(self):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        g = nx.Graph(directed=False, map_height = height, map_width = width)
        #self.positions = g.new_vertex_property('vector<float>')
        #self.weights = g.new_edge_property('float')
    
        #g.vertex_properties['pos'] = self.positions
        #g.edge_properties['weight'] = self.weights
    
        self.terrain = []
        self.positions = {}
        for j in range(0, height):
            row = []
            for i in range(0,width):
                if blocks[i][j] == 0:
                    g.add_node(i+j*width, position = (float(i)+0.5, float(j)+0.5) )
                    self.positions[i+j*width] = Vector2(float(i) + 0.5, float(j) + 0.5)
                    row.append(i+j*width)
                else:
                    row.append(None)
            self.terrain.append(row)
        
        for i, j in itertools.product(range(0, width), range(0, height)):
            p = self.terrain[j][i]
            if not p: continue
    
            if i < width-1:
                q = self.terrain[j][i+1]
                if q:
                    e = g.add_edge(p, q, weight = 1.0)
    
            if j < height-1:
                r = self.terrain[j+1][i]
                if r:
                    e = g.add_edge(p, r, weight = 1.0)
    
        self.graph = g

    def getNodeIndex(self, position):
        i = int(position.x)
        j = int(position.y)
        width = self.graph.graph["map_width"]
        return i+j*width


    def updateEdgeWeights(self):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        # update the weights in the graph based on the distance to the shortest path between the enemy flag and enemy score location

        for j in range(0, height):
            for i in range(0, width -1):
                a = self.terrain[j][i]
                b = self.terrain[j][i+1]
                if a and b:
                    w = max(255 - 4*(self.distances[a] + self.distances[b]), 0)
                    self.graph[a][b]['weight'] = w

        for j in range(0, height-1):
            for i in range(0, width):
                a = self.terrain[j][i]
                b = self.terrain[j+1][i]
                if a and b:
                    w = max(255 - 4*(self.distances[a] + self.distances[b]), 0)
                    self.graph[a][b]['weight'] = w


    def tick(self):
        for bot in self.game.bots_alive:
            if bot.state == BotInfo.STATE_IDLE:
                if not bot.flag:
                    # go to flag
                    dst = self.game.enemyTeam.flag.position
                    message = 'go to flag'
                else:
                    # go home
                    dst = self.game.team.flagScoreLocation
                    message = 'go home'

                # calculate the shortest path between the bot and the target using our weights
                srcIndex = self.getNodeIndex(bot.position)
                dstIndex = self.getNodeIndex(dst)
                pathNodes = nx.shortest_path(self.graph, srcIndex, dstIndex, 'weight')

                pathLength = len(pathNodes)
                if pathLength > 0:
                    path = [self.positions[p] for p in pathNodes if self.positions[p]]
                    if len(path) > 0:
                        orderPath = path[::10]
                        orderPath.append(path[-1]) # take every 10th point including last point
                        self.issue(commands.Move, bot, orderPath, description = message) 
                        self.paths[bot] = path    # store the path for visualization

        self.visualizer.tick()

    def drawPreWorld(self, visualizer):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        furthest = max([self.distances[n] for n in itertools.chain(*self.terrain) if n])

        for i, j in itertools.product(range(width), range(height)):            
            # average weights of edges connected to this node
            sum, count = 0, 0
            node = self.terrain[j][i]
            if node:
                for offset in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
                    ni, nj = i + offset[0], j + offset[1]
                    if ni < 0 or ni >= width or nj < 0 or nj >= height:
                        continue
                    neighbour = self.terrain[nj][ni]
                    if neighbour:
                        sum, count = sum + self.graph[node][neighbour]['weight'], count + 1
            if count:
                d = sum / count
            else:
                d = 32

            if self.level.blockHeights[i][j] == 1:
                visualizer.drawPixel((i, j), QtGui.qRgb(196, 196, 196))
            elif self.level.blockHeights[i][j] >= 2:            
                visualizer.drawPixel((i, j), QtGui.qRgb(64, 64, 64))
            else:
                visualizer.drawPixel((i, j), QtGui.qRgb(d,d,d))
                

    def drawPreBots(self, visualizer):
        for name, bot in self.game.bots.items():
            if bot.position is None:
                continue
            
            if 'Red' in name:
                color = QtGui.qRgb(255,0,0)
                pathColor = QtGui.qRgb(127,0,0)
            else:
                color = QtGui.qRgb(0,0,255)
                pathColor = QtGui.qRgb(0,0,127)
                
            if bot.health <= 0.0:
                color = QtGui.qRgb(0,0,0)

            if (bot.health > 0) and (bot in self.paths) and self.paths[bot]:
                path = self.paths[bot]
                pLast = bot.position
                for p in path:
                    visualizer.drawPixel((int(p.x), int(p.y)), QtGui.qRgb(255,255,0))
                    # visualizer.drawRay(pLast, p, color)
                    pLast = p

    def drawEnd(self, visualizer):
        pass
Exemplo n.º 8
0
    def initialize(self):
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()

        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight=1.0)

        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i], weight=1.0)

        self.node_EnemyFlagIndex = self.getNodeIndex(
            self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(
            self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph,
                                source="enemy_base",
                                target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph,
                                source=self.node_EnemyFlagIndex,
                                target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        path = vb2f + vf2s
        edgesinpath = zip(path[0:], path[1:])
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            orientation = (next_position - position).normalized()

            def visible(p):
                delta = (p - position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1,
                     lambda x, y: cells.append((x, y)))
            w.compute(position)

            for x, y in [
                    c for c in cells
                    if visible(Vector2(c[0] + 0.5, c[1] + 0.5))
            ]:
                self.visibilities.setPixel(x, y,
                                           self.visibilities.pixel(x, y) + 1)

        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [
            self.game.team.flag.position, self.game.enemyTeam.flag.position,
            self.game.team.flagScoreLocation,
            self.game.enemyTeam.flagScoreLocation
        ] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            n = self.terrain[j][i]
            if not n: continue

            position = Vector2(*self.graph.node[n]["position"])

            def visible(p):
                delta = (p - position)
                l = delta.length()
                return l <= 15.0

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1,
                     lambda x, y: cells.append((x, y)))
            w.compute(position)

            for x, y in [
                    c for c in cells
                    if visible(Vector2(c[0] + 0.5, c[1] + 0.5))
            ]:
                self.visibilities.setPixel(x, y,
                                           self.visibilities.pixel(x, y) + 1)

        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score"
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
        # for vertex in vb2s:
        #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(
            self.graph, self.node_EnemyFlagToScoreIndex)
        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes()
Exemplo n.º 9
0
class AmbushCommander(Commander):
    """
        Display current state and predictions on the screen in a PyQT application.
    """
    MODE_VISIBILITY = 0
    MODE_TRAVELLING = 1

    def drawPreWorld(self, visualizer):
        furthest = max(
            [self.distances[n] for n in itertools.chain(*self.terrain) if n])
        brightest = max([
            self.visibilities.pixel(i, j)
            for i, j in itertools.product(range(88), range(50))
        ])

        # visible = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        # visible.fill(0)

        for i, j in itertools.product(range(88), range(50)):
            n = self.terrain[j][i]
            if n:
                if self.mode == self.MODE_TRAVELLING:
                    d = self.distances[n] * 255.0 / furthest
                if self.mode == self.MODE_VISIBILITY:
                    d = self.visibilities.pixel(i, j) * 255 / brightest
            else:
                d = 32
            visualizer.drawPixel((i, j), QtGui.qRgb(d, d, d))

    def drawPreBots(self, visualizer):
        for p, _ in self.ambushes:
            visualizer.drawCircle(p, QtGui.qRgb(255, 255, 0), 0.5)

    def keyPressed(self, e):
        if e.key() == QtCore.Qt.Key_Space:
            self.mode = 1 - self.mode

    def initialize(self):
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()

        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight=1.0)

        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i], weight=1.0)

        self.node_EnemyFlagIndex = self.getNodeIndex(
            self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(
            self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph,
                                source="enemy_base",
                                target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph,
                                source=self.node_EnemyFlagIndex,
                                target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        path = vb2f + vf2s
        edgesinpath = zip(path[0:], path[1:])
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            orientation = (next_position - position).normalized()

            def visible(p):
                delta = (p - position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1,
                     lambda x, y: cells.append((x, y)))
            w.compute(position)

            for x, y in [
                    c for c in cells
                    if visible(Vector2(c[0] + 0.5, c[1] + 0.5))
            ]:
                self.visibilities.setPixel(x, y,
                                           self.visibilities.pixel(x, y) + 1)

        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [
            self.game.team.flag.position, self.game.enemyTeam.flag.position,
            self.game.team.flagScoreLocation,
            self.game.enemyTeam.flagScoreLocation
        ] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            n = self.terrain[j][i]
            if not n: continue

            position = Vector2(*self.graph.node[n]["position"])

            def visible(p):
                delta = (p - position)
                l = delta.length()
                return l <= 15.0

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1,
                     lambda x, y: cells.append((x, y)))
            w.compute(position)

            for x, y in [
                    c for c in cells
                    if visible(Vector2(c[0] + 0.5, c[1] + 0.5))
            ]:
                self.visibilities.setPixel(x, y,
                                           self.visibilities.pixel(x, y) + 1)

        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score"
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
        # for vertex in vb2s:
        #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)
        self.distances = nx.single_source_shortest_path_length(
            self.graph, self.node_EnemyFlagToScoreIndex)
        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes()

    def evaluate(self, position, orientation, callback):
        cells = []
        w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1,
                 lambda x, y: cells.append((x, y)))
        w.compute(position)

        def visible(p):
            delta = (p - position)
            l = delta.length()
            if l > 15.0:
                return False
            if l < 2.5:
                return True
            delta /= l
            return orientation.dotProduct(delta) > 0.9238

        total = 0.0
        for x, y in [
                c for c in cells if visible(Vector2(c[0] + 0.5, c[1] + 0.5))
        ]:
            total += callback(x, y)
        return total

    def findNearby(self, results, candidate, distance=2.0):
        d = distance * distance
        s, (position, _) = candidate
        for _, (p, _) in results:
            if (p - position).squaredLength() < d:
                return True
        return False

    def replaceInList(self, candidate, results, maximum=40):
        results.append(candidate)

        if len(results) < 50:
            return

        copy = results[:]
        copy.sort(key=lambda s: -s[0])

        results[:] = []

        for i, c in enumerate(copy):
            if not self.findNearby(results, c):
                results.append(c)
            if len(results) >= maximum:
                break

    def calculateAmbushes(self):
        results = []
        for i in range(
                500
        ):  # NOTE: you must feed in better pre-selected positions (eg near boxes) to get good results with this number of iterations.
            if (i % 1000) == 0: print >> sys.stderr, '.',
            p = self.level.findRandomFreePositionInBox(self.level.area)
            o = Vector2(random.uniform(-0.5, 0.5),
                        random.uniform(-0.5, 0.5)).normalized()

            s = self.evaluate(
                p, o,
                lambda x, y: 25.0 - square(self.getDistance(x, y))) - square(
                    self.visibilities.pixel(int(p.x), int(p.y)) * 5.0)
            self.replaceInList((s, (p, o)), results)

        self.ambushes = [r for _, r in results]

    def getSituation(self):
        result = None
        score = 0.0
        for i in range(10):
            p = self.level.findRandomFreePositionInBox(self.level.area)
            o = Vector2(random.uniform(-0.5, 0.5),
                        random.uniform(-0.5, 0.5)).normalized()
            s = self.evaluate(p, o, lambda x, y: 15.0 - self.getDistance(x, y))
            # - self.getDistance(int(p.x), int(p.y)) * 100
            if s > score or result == None:
                result = (p, o)
                score = s
        print score
        return result

    def getDistance(self, x, y):
        n = self.terrain[y][x]
        if n:
            return self.distances[n]
        else:
            return 0.0

    def tick(self):
        for e in self.game.match.combatEvents[self.index:]:
            if e.type != gameinfo.MatchCombatEvent.TYPE_RESPAWN:
                continue
            if e.subject in self.queue:
                del self.queue[e.subject]
        self.index = len(self.game.match.combatEvents)

        for bot in self.game.bots_available:
            if bot in self.queue:
                p, o = self.queue[bot]
                if (bot.position - p).length() < 1.0:
                    self.issue(commands.Defend, bot, o)
                    continue
            else:
                p, o = random.choice(self.ambushes)
                self.queue[bot] = (p, o)

            self.issue(commands.Charge, bot, p)

        self.visualizer.tick()

    def shutdown(self):
        self.visualizer.quit()
        del self.visualizer

    def makeGraph(self):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        g = nx.Graph(directed=False, map_height=height, map_width=width)
        #self.positions = g.new_vertex_property('vector<float>')
        #self.weights = g.new_edge_property('float')

        #g.vertex_properties['pos'] = self.positions
        #g.edge_properties['weight'] = self.weights

        self.terrain = []
        for j in range(0, height):
            row = []
            for i in range(0, width):
                if blocks[i][j] == 0:
                    g.add_node(i + j * width,
                               position=(float(i) + 0.5, float(j) + 0.5))
                    row.append(i + j * width)
                else:
                    row.append(None)
            self.terrain.append(row)

        for i, j in itertools.product(range(0, width), range(0, height)):
            p = self.terrain[j][i]
            if not p: continue

            if i < width - 1:
                q = self.terrain[j][i + 1]
                if q:
                    e = g.add_edge(p, q, weight=1.0)

            if j < height - 1:
                r = self.terrain[j + 1][i]
                if r:
                    e = g.add_edge(p, r, weight=1.0)

        self.graph = g

    def getNodeIndex(self, position):
        i = int(position.x)
        j = int(position.y)
        width = self.graph.graph["map_width"]
        return i + j * width
Exemplo n.º 10
0
    def initialize(self):
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()

        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight=1.0)

        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]
        for i, j in itertools.product(range(int(start.x), int(finish.x)),
                                      range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i], weight=1.0)

        self.node_EnemyFlagIndex = self.getNodeIndex(
            self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(
            self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph,
                                source="enemy_base",
                                target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph,
                                source=self.node_EnemyFlagIndex,
                                target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        #Coloration based on score in an 88 by 50 pixel grid?
        #Grid squares are set with setPixel(xcoord, ycoord, intRepresentingDarkness)
        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        #Path from enemy base to flag to scoring position.
        path = vb2f + vf2s
        #Zip returns a list of 0-nth tuples using ith items from each iterable.
        #Each represents two graph node indexes, or an edge along the path.
        edgesinpath = zip(path[0:], path[1:])
        #Vt is the start node index, vf is the end note index.
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            #Facing vector of the move on the graph.
            orientation = (next_position - position).normalized()

            #TODO swap to actual vector/sight range visibility calc.
            def visible(p):
                delta = (p - position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            #List of points that are visible from a designated point.
            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1,
                     lambda x, y: cells.append((x, y)))
            w.compute(position)

            #Increment the visibility int of each point that it has visibility to and sees by one.
            for x, y in [
                    c for c in cells
                    if visible(Vector2(c[0] + 0.5, c[1] + 0.5))
            ]:
                self.visibilities.setPixel(x, y,
                                           self.visibilities.pixel(x, y) + 1)

        #A bunch of points along the paths are added into a big list of positions.
        #This piece of code makes squares very close to the path even higher, and create a bit of spread around the path.
        #Otherwise it is the same as the previous big chunk save a simpler visibility calculus.
        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [
            self.game.team.flag.position, self.game.enemyTeam.flag.position,
            self.game.team.flagScoreLocation,
            self.game.enemyTeam.flagScoreLocation
        ] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            #Yields node index for each list coordinate pair.
            n = self.terrain[j][i]
            if not n: continue

            position = Vector2(*self.graph.node[n]["position"])

            def visible(p):
                delta = (p - position)
                l = delta.length()
                return l <= 15.0

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1,
                     lambda x, y: cells.append((x, y)))
            w.compute(position)

            for x, y in [
                    c for c in cells
                    if visible(Vector2(c[0] + 0.5, c[1] + 0.5))
            ]:
                self.visibilities.setPixel(x, y,
                                           self.visibilities.pixel(x, y) + 1)

        #Add weighted edges to graph
        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score"
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex,
                                vertex,
                                weight=1.0)

        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)

        #Calculate shortest path to enemy flag from each point.
        self.distances = nx.single_source_shortest_path_length(
            self.graph, self.node_EnemyFlagToScoreIndex)

        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes()
Exemplo n.º 11
0
    def initialize(self):
        self.midEnemySpawn = self.game.enemyTeam.botSpawnArea[0].midPoint(self.game.enemyTeam.botSpawnArea[1])
        visited, self.islandEdges, islandOuter = [], [], []
        for x in range(0, len(self.level.blockHeights)):
            for y in range(0, len(self.level.blockHeights[x])):
                _, edges, island = self.recurseNeighbours(x, y, visited)
                if edges:
                    self.islandEdges.append(edges)
                    islandOuter.append(island)
        blocked = [item for sublist in islandOuter for item in sublist]
        #blockedOrSpawn = blocked[:]
        spawn = []
        for x in range(int(self.game.enemyTeam.botSpawnArea[0].x), int(self.game.enemyTeam.botSpawnArea[1].x)):
            for y in range(int(self.game.enemyTeam.botSpawnArea[0].y), int(self.game.enemyTeam.botSpawnArea[1].y)):
                spawn.append(Vector2(x, y))
        
        self.campLines = []
        for island in self.islandEdges:
            for coord, orientation in island:
                if orientation is self.TOPLEFT:
                    self.campLines.append((coord, Vector2(-self.level.firingDistance / 1.0283968, 0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.BOTTOMLEFT:
                    self.campLines.append((coord, Vector2(-self.level.firingDistance / -1.0283968, -0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.LEFTUP:
                    self.campLines.append((coord, Vector2(0.24 * self.level.firingDistance / 1.0283968, -self.level.firingDistance / 1.0283968)))
                elif orientation is self.RIGHTUP:
                    self.campLines.append((coord, Vector2(-0.24 * self.level.firingDistance / 1.0283968, -self.level.firingDistance / 1.0283968)))
                elif orientation is self.TOPRIGHT:
                    self.campLines.append((coord, Vector2(self.level.firingDistance / 1.0283968, 0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.BOTTOMRIGHT:
                    self.campLines.append((coord, Vector2(self.level.firingDistance / 1.0283968, -0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.LEFTDOWN:
                    self.campLines.append((coord, Vector2(0.24 * self.level.firingDistance / 1.0283968, self.level.firingDistance / 1.0283968)))
                elif orientation is self.RIGHTDOWN:
                    self.campLines.append((coord, Vector2(-0.24 * self.level.firingDistance / 1.0283968, self.level.firingDistance / 1.0283968)))
        sys.stdout.write(str(self.campLines) + '\n')
        self.deadlines = dict()
        for i in range(len(self.islandEdges)):
            for coord, orientation in self.islandEdges[i]:
                if orientation is self.TOPLEFT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - self.level.firingDistance / 1.0283968, coord.y + 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.BOTTOMLEFT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - self.level.firingDistance / -1.0283968, coord.y - 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.LEFTUP:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + 0.24 * self.level.firingDistance / 1.0283968, coord.y - self.level.firingDistance / 1.0283968))
                elif orientation is self.RIGHTUP:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - 0.24 * self.level.firingDistance / 1.0283968, coord.y - self.level.firingDistance / 1.0283968))
                elif orientation is self.TOPRIGHT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + self.level.firingDistance / 1.0283968, coord.y + 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.BOTTOMRIGHT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + self.level.firingDistance / 1.0283968, coord.y - 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.LEFTDOWN:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + 0.24 * self.level.firingDistance / 1.0283968, coord.y + self.level.firingDistance / 1.0283968))
                elif orientation is self.RIGHTDOWN:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - 0.24 * self.level.firingDistance / 1.0283968, coord.y + self.level.firingDistance / 1.0283968))
                
        sys.stdout.write(str(self.deadlines) + '\n')
        pointsAndLinesByEdge = dict()
        try:
            self.recursePaths(self.midEnemySpawn, blocked, self.deadlines, [], pointsAndLinesByEdge)
        except RuntimeError as e:
            sys.stdout.write(str(e) + '\n')
        self.spawnCamplines = set()
        for edge, pls in pointsAndLinesByEdge.iteritems():
            for _, contact in pls:
                self.spawnCamplines.add((self.level.findNearestFreePosition(edge), contact))
        sys.stdout.write('\n' + str(self.spawnCamplines))
        
        self.spawnCampers = []
        for cl in self.spawnCamplines:
            self.spawnCampers.append([[], cl])
        
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()
        
        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight = 1.0)            


        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i],weight = 1.0)            


        self.node_EnemyFlagIndex = self.getNodeIndex(self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph, source=self.node_EnemyFlagIndex, target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        path = vb2f+vf2s
        #path = vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        edgesinpath=zip(path[0:],path[1:])        
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            orientation = (next_position - position).normalized()

            def visible(p):
                delta = (p-position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)

        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [self.game.team.flag.position, self.game.enemyTeam.flag.position,
                  self.game.team.flagScoreLocation, self.game.enemyTeam.flagScoreLocation] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            n = self.terrain[j][i]
            if not n: continue
            
            position = Vector2(*self.graph.node[n]["position"])
            def visible(p):
                delta = (p-position)
                l = delta.length()
                return l <= 15.0

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)


        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex, vertex, weight = 1.0)
        
        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score" 
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex, vertex, weight = 1.0)
        
        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
       # for vertex in vb2s:
       #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)"""
        self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyFlagToScoreIndex)
        #self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyBaseToFlagIndex)
        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes(self.campLines)
        self.aliveEnemies = 0
Exemplo n.º 12
0
class AmbushCommander(Commander):
    """
        Display current state and predictions on the screen in a PyQT application.
    """
    MODE_VISIBILITY = 0 
    MODE_TRAVELLING = 1
    
    LEFTUP = 0
    LEFTDOWN = 1
    RIGHTUP = 2
    RIGHTDOWN = 3
    TOPLEFT = 4
    TOPRIGHT = 5
    BOTTOMLEFT = 6
    BOTTOMRIGHT = 7
    
    def angledVector(self, vec, angle):
        normalAngle = angle + math.atan2(vec.y, vec.x)
        return Vector2(math.cos(normalAngle), math.sin(normalAngle))
    
    def feq(self, f, s):
        return math.fabs(f - s) < 0.00000001
    
    def veq(self, f, s):
        return self.feq(f.x, s.x) and self.feq(f.y, s.y)
    
    def lineEq(self, start, end, x, y):
        return (end.y - start.y) * x + (start.x - end.x) * y + end.x * start.y - start.x * end.y
    
    def intersects(self, start, end, p, length = 0):
        if length is 0:
            length = start.distance(end)
        if p.distance(start) <= length and p.distance(end) <= length:
            topLeft = self.lineEq(start, end, p.x, p.y)
            topRight = self.lineEq(start, end, p.x + 1, p.y)
            bottomRight = self.lineEq(start, end, p.x + 1, p.y + 1)
            bottomLeft = self.lineEq(start, end, p.x, p.y + 1)
            if self.feq(topLeft, 0) or self.feq(topRight, 0) or self.feq(bottomRight, 0) or self.feq(bottomLeft, 0) or not ((topLeft > 0) is (topRight > 0) is (bottomRight > 0) is (bottomLeft > 0)):
                return True
        return False
    
    def lineIntersection(self, start1, end1, start2, end2):
        denom = ((end1.x - start1.x) * (end2.y - start2.y)) - ((end1.y - start1.y) * (end2.x - start2.x))
 
        if denom is 0:
            return None

        numer = ((start1.y - start2.y) * (end2.x - start2.x)) - ((start1.x - start2.x) * (end2.y - start2.y));
    
        r = numer / denom;
    
        numer2 = ((start1.y - start2.y) * (end1.x - start1.x)) - ((start1.x - start2.x) * (end1.y - start1.y));
    
        s = numer2 / denom;
    
        if r < 0 or r > 1 or s < 0 or s > 1:
            return None
        
        return Vector2(start1.x + (r * (end1.x - start1.x)), start1.y + (r * (end1.y - start1.y)))

    def intersectsWhere(self, start, end, p):
        intersections = []
        intersection = self.lineIntersection(start, end, p, Vector2(p.x + 1, p.y))
        if intersection:
            intersections.append(intersection)
        intersection = self.lineIntersection(start, end, p, Vector2(p.x, p.y + 1))
        if intersection:
            intersections.append(intersection)
        intersection = self.lineIntersection(start, end, Vector2(p.x + 1, p.y), Vector2(p.x + 1, p.y + 1))
        if intersection:
            intersections.append(intersection)
        intersection = self.lineIntersection(start, end, Vector2(p.x, p.y + 1), Vector2(p.x + 1, p.y + 1))
        if intersection:
            intersections.append(intersection)
        
        if not intersections:
            return None
        else:
            return sorted(intersections, key = lambda f: f.distance(start))[0]
    
    def whoBlocks(self, blocked, start, end, length = 0):
        for p in blocked:
            if self.intersects(start, end, p, length):
                return p
        return None
    
    def whoBlocksWhere(self, blocked, start, end):
        for p in blocked:
            intersection = self.intersectsWhere(start, end, p)
            if intersection:
                return intersection
        return None
    
    def freeLoS(self, blocked, start, end):
        return not self.whoBlocks(blocked, start, end)
                        
    def recurseNeighbours(self, x, y, visited):
        if x >= 0 and x < self.level.width and y >= 0 and y < self.level.height:
            if self.level.blockHeights[x][y] < 2:
                return False, set(), set()
            elif not Vector2(x, y) in visited:
                visited.append(Vector2(x, y))
                nEdges, island = set(), set()
                topLeft, topRight, bottomLeft, bottomRight, top, left, right, bottom = True, True, True, True, True, True, True, True
                for i in range(-1, 2):
                    for j in range(-1, 2):
                        if not (i is 0 and j is 0):
                            isBlocked, neighbourRes, islandRes = self.recurseNeighbours(x + i, y + j, visited)
                            nEdges |= neighbourRes
                            island |= islandRes
                            if isBlocked:
                                if i is -1:
                                    if j is 0:
                                        topLeft, bottomLeft, left = False, False, False
                                    elif j is -1:
                                        topLeft = False
                                    else:
                                        bottomLeft = False
                                elif i is 0:
                                    if j is -1:
                                        topLeft, topRight, top = False, False, False
                                    else:
                                        bottomLeft, bottomRight, bottom = False, False, False
                                else:
                                    if j is 0:
                                        topRight, bottomRight, right = False, False, False
                                    elif j is -1:
                                        topRight = False
                                    else:
                                        bottomRight = False
                    
                if topLeft:
                    if x - 0.25 > 0 and y + 1 < self.level.height:
                        nEdges.add((Vector2(x - 0.25, y + 1), self.LEFTUP))
                    if x + 1 < self.level.width and y - 0.25 > 0:
                        nEdges.add((Vector2(x + 1, y - 0.25), self.TOPLEFT))
                if bottomLeft:
                    if x - 0.25 > 0:
                        nEdges.add((Vector2(x - 0.25, y), self.LEFTDOWN))
                    if x + 1 < self.level.width and y + 1.25 < self.level.height:
                        nEdges.add((Vector2(x + 1, y + 1.25), self.BOTTOMLEFT))
                if topRight:
                    if x + 1.25 < self.level.width and y + 1 < self.level.height:
                        nEdges.add((Vector2(x + 1.25, y + 1), self.RIGHTUP))
                    if y - 0.25 > 0:
                        nEdges.add((Vector2(x, y - 0.25), self.TOPRIGHT))
                if bottomRight:
                    if x + 1.25 < self.level.width:
                        nEdges.add((Vector2(x + 1.25, y), self.RIGHTDOWN))
                    if y + 1.25 < self.level.height:
                        nEdges.add((Vector2(x, y + 1.25), self.BOTTOMRIGHT))
                    
                if top or bottom or right or left:
                    island.add(Vector2(x, y))
                            
                return True, nEdges, island
            else:
                return True, set(), set()
        else:
            return True, set(), set()
                        
    def recursePaths(self, p, blocked, deadlines, visited = [], pointsAndLinesByEdge = dict()):
        if p.x >= 0 and p.y >= 0 and p.x < self.level.width and p.y < self.level.height and not p in visited:
            visited.append(p)
            for block in blocked:
                if p.x >= block.x and p.x <= block.x + 1 and p.y >= block.y and p.y <= block.y + 1:
                    return
            for edge, contacts in deadlines.iteritems():
                for contact in contacts:
                    """line = (edge, contact)
                    if p.distance(line[0]) <= line[0].distance(line[1]) and p.distance(line[1]) <= line[0].distance(line[1]) and not (self.veq(line[0], p) or self.veq(line[1], p)):
                        topLeft = self.lineEq(line, p.x, p.y)
                        topRight = self.lineEq(line, p.x + 1, p.y)
                        bottomRight = self.lineEq(line, p.x + 1, p.y + 1)
                        bottomLeft = self.lineEq(line, p.x, p.y + 1)
                        if self.feq(topLeft, 0) or self.feq(topRight, 0) or self.feq(bottomRight, 0) or self.feq(bottomLeft, 0) or not ((topLeft > 0) is (topRight > 0) is (bottomRight > 0) is (bottomLeft > 0)):"""
                    if self.intersects(edge, contact, p):
                        if edge in pointsAndLinesByEdge:
                            pointsAndLinesByEdge[edge].append((p, contact))
                        else:
                            pointsAndLinesByEdge[edge] = [(p, contact)]
                        return
            recalc= []
            for edge in deadlines.keys():
                if p.distance(edge) <= self.level.firingDistance and not self.whoBlocks(blocked, p, edge):
                    sys.stdout.write('removed: ' + str(p) + ' '  + str(edge) + '\n')
                    del deadlines[edge]
                    if edge in pointsAndLinesByEdge:
                        for pointAndLine in pointsAndLinesByEdge[edge]:
                            recalc.append(pointAndLine[0])
                            visited.remove(pointAndLine[0])
                        del pointsAndLinesByEdge[edge]
            for re in recalc:
                self.recursePaths(re, blocked, deadlines, visited, pointsAndLinesByEdge)
                    
            
            
            self.recursePaths(Vector2(p.x - 1, p.y), blocked, deadlines, visited, pointsAndLinesByEdge)
            self.recursePaths(Vector2(p.x, p.y - 1), blocked, deadlines, visited, pointsAndLinesByEdge)
            self.recursePaths(Vector2(p.x + 1, p.y), blocked, deadlines, visited, pointsAndLinesByEdge)
            self.recursePaths(Vector2(p.x, p.y + 1), blocked, deadlines, visited, pointsAndLinesByEdge)
                        
    def newDeadline(self, edge, contact):
        if edge in self.deadlines:
            self.deadlines[edge].add(contact)
        else:
            self.deadlines[edge] = set([contact])
            
    def deadlineFromLine(self, blocked, spawn, start, end):
        intersect = self.whoBlocksWhere(blocked, start, end)
        spawnIntersect = self.whoBlocks(spawn, start, end)
        if intersect and (not spawnIntersect or spawnIntersect.distance(start) > intersect.distance(start)):
            self.newDeadline(start, intersect)
        else:
            intersect = self.lineIntersection(start, end, Vector2(0, 0), Vector2(0, self.level.height))
            if intersect and (not spawnIntersect or spawnIntersect.distance(start) > intersect.distance(start)):
                self.newDeadline(start, intersect)
            else:
                intersect = self.lineIntersection(start, end, Vector2(0, 0), Vector2(self.level.width, 0))
                if intersect and (not spawnIntersect or spawnIntersect.distance(start) > intersect.distance(start)):
                    self.newDeadline(start, intersect)
                else:
                    intersect = self.lineIntersection(start, end, Vector2(0, self.level.height), Vector2(self.level.width, self.level.height))
                    if intersect and (not spawnIntersect or spawnIntersect.distance(start) > intersect.distance(start)):
                        self.newDeadline(start, intersect)
                    else:
                        intersect = self.lineIntersection(start, end, Vector2(self.level.width, 0), Vector2(self.level.width, self.level.height))
                        if intersect and (not spawnIntersect or spawnIntersect.distance(start) > intersect.distance(start)):
                            self.newDeadline(start, intersect)
    
    def drawPreWorld(self, visualizer):
       furthest = max([self.distances[n] for n in itertools.chain(*self.terrain) if n])
       brightest = max([self.visibilities.pixel(i,j) for i, j in itertools.product(range(88), range(50))])
        
        # visible = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        # visible.fill(0)

       for i, j in itertools.product(range(88), range(50)):            
            n = self.terrain[j][i]
            if n:
                if self.mode == self.MODE_TRAVELLING:
                    d = self.distances[n] * 255.0 / furthest
                if self.mode == self.MODE_VISIBILITY:
                    d = self.visibilities.pixel(i,j) * 255 / brightest
            else:                
                d = 32
            visualizer.drawPixel((i, j), QtGui.qRgb(d,d,d))
                
    def drawPreBots(self, visualizer):
        for p, o in self.ambushes:
            visualizer.drawCircle(p, QtGui.qRgb(255,255,0), 0.5)
            visualizer.drawRay(p, o, QtGui.qRgb(255,0,0))
        for island in self.islandEdges:
            for p, _ in island:
                visualizer.drawCircle(p, QtGui.qRgb(255,0,0), 0.5)
            
    def keyPressed(self, e):
        if e.key() == QtCore.Qt.Key_Space:
            self.mode = 1 - self.mode

    def initialize(self):
        self.midEnemySpawn = self.game.enemyTeam.botSpawnArea[0].midPoint(self.game.enemyTeam.botSpawnArea[1])
        visited, self.islandEdges, islandOuter = [], [], []
        for x in range(0, len(self.level.blockHeights)):
            for y in range(0, len(self.level.blockHeights[x])):
                _, edges, island = self.recurseNeighbours(x, y, visited)
                if edges:
                    self.islandEdges.append(edges)
                    islandOuter.append(island)
        blocked = [item for sublist in islandOuter for item in sublist]
        #blockedOrSpawn = blocked[:]
        spawn = []
        for x in range(int(self.game.enemyTeam.botSpawnArea[0].x), int(self.game.enemyTeam.botSpawnArea[1].x)):
            for y in range(int(self.game.enemyTeam.botSpawnArea[0].y), int(self.game.enemyTeam.botSpawnArea[1].y)):
                spawn.append(Vector2(x, y))
        
        self.campLines = []
        for island in self.islandEdges:
            for coord, orientation in island:
                if orientation is self.TOPLEFT:
                    self.campLines.append((coord, Vector2(-self.level.firingDistance / 1.0283968, 0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.BOTTOMLEFT:
                    self.campLines.append((coord, Vector2(-self.level.firingDistance / -1.0283968, -0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.LEFTUP:
                    self.campLines.append((coord, Vector2(0.24 * self.level.firingDistance / 1.0283968, -self.level.firingDistance / 1.0283968)))
                elif orientation is self.RIGHTUP:
                    self.campLines.append((coord, Vector2(-0.24 * self.level.firingDistance / 1.0283968, -self.level.firingDistance / 1.0283968)))
                elif orientation is self.TOPRIGHT:
                    self.campLines.append((coord, Vector2(self.level.firingDistance / 1.0283968, 0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.BOTTOMRIGHT:
                    self.campLines.append((coord, Vector2(self.level.firingDistance / 1.0283968, -0.24 * self.level.firingDistance / 1.0283968)))
                elif orientation is self.LEFTDOWN:
                    self.campLines.append((coord, Vector2(0.24 * self.level.firingDistance / 1.0283968, self.level.firingDistance / 1.0283968)))
                elif orientation is self.RIGHTDOWN:
                    self.campLines.append((coord, Vector2(-0.24 * self.level.firingDistance / 1.0283968, self.level.firingDistance / 1.0283968)))
        sys.stdout.write(str(self.campLines) + '\n')
        self.deadlines = dict()
        for i in range(len(self.islandEdges)):
            for coord, orientation in self.islandEdges[i]:
                if orientation is self.TOPLEFT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - self.level.firingDistance / 1.0283968, coord.y + 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.BOTTOMLEFT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - self.level.firingDistance / -1.0283968, coord.y - 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.LEFTUP:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + 0.24 * self.level.firingDistance / 1.0283968, coord.y - self.level.firingDistance / 1.0283968))
                elif orientation is self.RIGHTUP:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - 0.24 * self.level.firingDistance / 1.0283968, coord.y - self.level.firingDistance / 1.0283968))
                elif orientation is self.TOPRIGHT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + self.level.firingDistance / 1.0283968, coord.y + 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.BOTTOMRIGHT:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + self.level.firingDistance / 1.0283968, coord.y - 0.24 * self.level.firingDistance / 1.0283968))
                elif orientation is self.LEFTDOWN:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x + 0.24 * self.level.firingDistance / 1.0283968, coord.y + self.level.firingDistance / 1.0283968))
                elif orientation is self.RIGHTDOWN:
                    self.deadlineFromLine(blocked, spawn, coord, Vector2(coord.x - 0.24 * self.level.firingDistance / 1.0283968, coord.y + self.level.firingDistance / 1.0283968))
                
        sys.stdout.write(str(self.deadlines) + '\n')
        pointsAndLinesByEdge = dict()
        try:
            self.recursePaths(self.midEnemySpawn, blocked, self.deadlines, [], pointsAndLinesByEdge)
        except RuntimeError as e:
            sys.stdout.write(str(e) + '\n')
        self.spawnCamplines = set()
        for edge, pls in pointsAndLinesByEdge.iteritems():
            for _, contact in pls:
                self.spawnCamplines.add((self.level.findNearestFreePosition(edge), contact))
        sys.stdout.write('\n' + str(self.spawnCamplines))
        
        self.spawnCampers = []
        for cl in self.spawnCamplines:
            self.spawnCampers.append([[], cl])
        
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()
        
        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight = 1.0)            


        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i],weight = 1.0)            


        self.node_EnemyFlagIndex = self.getNodeIndex(self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph, source=self.node_EnemyFlagIndex, target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        path = vb2f+vf2s
        #path = vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        edgesinpath=zip(path[0:],path[1:])        
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            orientation = (next_position - position).normalized()

            def visible(p):
                delta = (p-position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)

        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [self.game.team.flag.position, self.game.enemyTeam.flag.position,
                  self.game.team.flagScoreLocation, self.game.enemyTeam.flagScoreLocation] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            n = self.terrain[j][i]
            if not n: continue
            
            position = Vector2(*self.graph.node[n]["position"])
            def visible(p):
                delta = (p-position)
                l = delta.length()
                return l <= 15.0

            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)


        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex, vertex, weight = 1.0)
        
        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score" 
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex, vertex, weight = 1.0)
        
        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)
       # for vertex in vb2s:
       #     self.graph.add_edge(self.node_EnemyBaseToScoreIndex, vertex, weight = 1.0)

        ## node = self.makeNode(self.game.enemyTeam.flag.position)"""
        self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyFlagToScoreIndex)
        #self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyBaseToFlagIndex)
        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes(self.campLines)
        self.aliveEnemies = 0

    def evaluate(self, position, orientation, callback):
        cells = []
        w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
        w.compute(position)

        def visible(p):
            delta = (p-position)
            l = delta.length()
            if l > 15.0:
                return False
            if l < 2.5:
                return True
            delta /= l
            return orientation.dotProduct(delta) > 0.9238

        total = 0.0
        for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
            total += callback(x,y)
        return total

    def findNearby(self, results, candidate, distance = 2.0):
        d = distance * distance
        s, (position, _) = candidate
        for _, (p, _) in results:
            if (p-position).squaredLength() < d:
                return True            
        return False

    def replaceInList(self, candidate, results, maximum = 40):
        results.append(candidate)

        if len(results) < 50:
            return

        copy = results[:]
        copy.sort(key=lambda s: -s[0])

        results[:] = []

        for i, c in enumerate(copy):
            if not self.findNearby(results, c):
                results.append(c)
            if len(results) >= maximum:
                break

    def calculateAmbushes(self, camps):        
        results = []
        for q, _ in camps:
            p = self.level.findNearestFreePosition(q)
            for i in range(10):
                o = self.angledVector(Vector2(1, 0), i * 36 * math.pi / 180)
                #o = Vector2(random.uniform(-0.5, 0.5), random.uniform(-0.5, 0.5)).normalized()
    
                s = self.evaluate(p, o, lambda x, y: 25.0-square(self.getDistance(x, y))) - square(self.visibilities.pixel(int(p.x), int(p.y)) * 5.0)
                #s = self.evaluate(p, o, lambda x, y: - self.getDistance(x, y) - self.visibilities.pixel(int(p.x), int(p.y)))
                self.replaceInList((s, (p,o)), results)

        self.ambushes = [r for _, r in results]

    def getSituation(self):
        result = None
        score = 0.0
        for i in range(10):
            p = self.level.findRandomFreePositionInBox(self.level.area)
            o = Vector2(random.uniform(-0.5, 0.5), random.uniform(-0.5, 0.5)).normalized()
            s = self.evaluate(p, o, lambda x, y: 15.0-self.getDistance(x, y))
                # - self.getDistance(int(p.x), int(p.y)) * 100 
            if s > score or result == None:
                result = (p, o)
                score = s
        print score
        return result

    def getDistance(self, x, y):
        n = self.terrain[y][x]
        if n:
            return self.distances[n]
        else:
            return 0.0

    def tick(self):
        for e in self.game.match.combatEvents[self.index:]:
            if e.type == gameinfo.MatchCombatEvent.TYPE_RESPAWN:
                if e.subject in self.queue:
                    del self.queue[e.subject]
                elif e.subject in self.game.enemyTeam.members:
                    self.aliveEnemies += 1
                    sys.stdout.write(str(self.aliveEnemies) + '\n')
            elif e.type == gameinfo.MatchCombatEvent.TYPE_KILLED and e.subject in self.game.enemyTeam.members:
                self.aliveEnemies -= 1
                sys.stdout.write(str(self.aliveEnemies) + '\n')
        self.index = len(self.game.match.combatEvents)

        for c in self.spawnCampers:
            for derp in c[0][:]:
                if derp[0].health <= 0:
                    c[0].remove(derp)

        if self.aliveEnemies == 0 and self.game.match.timeToNextRespawn > 5:
            for bot in self.game.bots_alive:
                if bot.flag:
                    self.issue(commands.Charge, bot, self.game.team.flagScoreLocation, description = 'straight home')
                else:
                    handled = False
                    for c in self.spawnCampers:
                        for b in c[0]:
                            if bot is b[0]:
                                if not b[1]:
                                    if bot.position.distance(c[1][0]) < 1:
                                        self.issue(commands.Defend, bot, c[1][1] - bot.position)
                                        b[1] = True
                                    else:
                                        self.issue(commands.Charge, bot, c[1][0])
                                handled = True
                                break
                        if handled:
                            break
                    if not handled:
                        myplace = sorted(self.spawnCampers, key = lambda f: len(f[0]))[0]
                        myplace[0].append([bot, False])      
                        self.issue(commands.Charge, bot, myplace[1][0])
        else:
            for bot in self.game.bots_available:
                if bot in self.queue:
                    p, o = self.queue[bot]
                    if (bot.position-p).length() < 1.0:
                        self.issue(commands.Defend, bot, o)
                        continue
                else:
                    p, o = random.choice(self.ambushes)
                    self.queue[bot] = (p, o)
                
                self.issue(commands.Charge, bot, p)
        
        self.visualizer.tick()

    def shutdown(self):
        self.visualizer.quit()
        del self.visualizer

    def makeGraph(self):
        blocks = self.level.blockHeights
        width, height = len(blocks), len(blocks[0])

        g = nx.Graph(directed=False, map_height = height, map_width = width)
        #self.positions = g.new_vertex_property('vector<float>')
        #self.weights = g.new_edge_property('float')
    
        #g.vertex_properties['pos'] = self.positions
        #g.edge_properties['weight'] = self.weights
    
        self.terrain = []
        for j in range(0, height):
            row = []
            for i in range(0,width):
                if blocks[i][j] == 0:
                    g.add_node(i+j*width, position = (float(i)+0.5, float(j)+0.5) )
                    row.append(i+j*width)
                else:
                    row.append(None)
            self.terrain.append(row)
        
        for i, j in itertools.product(range(0, width), range(0, height)):
            p = self.terrain[j][i]
            if not p: continue
    
            if i < width-1:
                q = self.terrain[j][i+1]
                if q:
                    e = g.add_edge(p, q, weight = 1.0)
    
            if j < height-1:
                r = self.terrain[j+1][i]
                if r:
                    e = g.add_edge(p, r, weight = 1.0)
    
        self.graph = g



    def getNodeIndex(self, position):
        i = int(position.x)
        j = int(position.y)
        width = self.graph.graph["map_width"]
        return i+j*width
Exemplo n.º 13
0
    def initialize(self):
        self.mode = self.MODE_VISIBILITY
        self.visualizer = VisualizerApplication(self)

        self.visualizer.setDrawHookPreWorld(self.drawPreWorld)
        self.visualizer.setDrawHookPreBots(self.drawPreBots)
        self.visualizer.setKeyboardHook(self.keyPressed)

        self.makeGraph()
        
        self.graph.add_node("enemy_base")
        start, finish = self.level.botSpawnAreas[self.game.enemyTeam.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("enemy_base", self.terrain[j][i], weight = 1.0)            


        self.graph.add_node("base")
        start, finish = self.level.botSpawnAreas[self.game.team.name]        
        for i, j in itertools.product(range(int(start.x), int(finish.x)), range(int(start.y), int(finish.y))):
            self.graph.add_edge("base", self.terrain[j][i],weight = 1.0)            


        self.node_EnemyFlagIndex = self.getNodeIndex(self.game.team.flag.position)
        self.node_EnemyScoreIndex = self.getNodeIndex(self.game.enemyTeam.flagScoreLocation)

        # self.node_Bases = self.graph.add_vertex()
        # e = self.graph.add_edge(self.node_Bases, self.node_MyBase)
        # e = self.graph.add_edge(self.node_Bases, self.node_EnemyBase)

        vb2f = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyFlagIndex)
        vf2s = nx.shortest_path(self.graph, source=self.node_EnemyFlagIndex, target=self.node_EnemyScoreIndex)
        #vb2s = nx.shortest_path(self.graph, source="enemy_base", target=self.node_EnemyScoreIndex)

        #Coloration based on score in an 88 by 50 pixel grid?
        #Grid squares are set with setPixel(xcoord, ycoord, intRepresentingDarkness)
        self.visibilities = QtGui.QImage(88, 50, QtGui.QImage.Format_ARGB32)
        self.visibilities.fill(0)
        #Path from enemy base to flag to scoring position.
        path = vb2f + vf2s
        #Zip returns a list of 0-nth tuples using ith items from each iterable.
        #Each represents two graph node indexes, or an edge along the path.
        edgesinpath = zip(path[0:], path[1:])
        #Vt is the start node index, vf is the end note index.
        for vt, vf in edgesinpath[:-1]:
            if "position" not in self.graph.node[vf]:
                continue
            position = Vector2(*self.graph.node[vf]["position"])
            if "position" not in self.graph.node[vt]:
                continue
            next_position = Vector2(*self.graph.node[vt]["position"])
            if position == next_position:
                continue
            #Facing vector of the move on the graph.
            orientation = (next_position - position).normalized()

            #TODO swap to actual vector/sight range visibility calc.
            def visible(p):
                delta = (p-position)
                l = delta.length()
                if l > 20.0:
                    return False
                if l < 2.5:
                    return True
                delta /= l
                return orientation.dotProduct(delta) >= 0.5

            #List of points that are visible from a designated point.
            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x, y)))
            w.compute(position)

            #Increment the visibility int of each point that it has visibility to and sees by one.
            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)

        #A bunch of points along the paths are added into a big list of positions.
        #This piece of code makes squares very close to the path even higher, and create a bit of spread around the path.
        #Otherwise it is the same as the previous big chunk save a simpler visibility calculus.
        starte, finishe = self.level.botSpawnAreas[self.game.enemyTeam.name]
        startf, finishf = self.level.botSpawnAreas[self.game.team.name]
        points = [self.game.team.flag.position, self.game.enemyTeam.flag.position,
                  self.game.team.flagScoreLocation, self.game.enemyTeam.flagScoreLocation] * 4
        for i, j in list(itertools.product(range(int(starte.x), int(finishe.x)), range(int(starte.y), int(finishe.y)))) \
                    + list(itertools.product(range(int(startf.x), int(finishf.x)), range(int(startf.y), int(finishf.y)))) \
                    + [(int(p.x), int(p.y)) for p in points]:
            #Yields node index for each list coordinate pair.
            n = self.terrain[j][i]
            if not n: continue
            
            position = Vector2(*self.graph.node[n]["position"])
            def visible(p):
                delta = (p-position)
                l = delta.length()
                return l <= 15.0
            
            cells = []
            w = Wave((88, 50), lambda x, y: self.level.blockHeights[x][y] > 1, lambda x, y: cells.append((x,y)))
            w.compute(position)

            for x, y in [c for c in cells if visible(Vector2(c[0]+0.5, c[1]+0.5))]:
                self.visibilities.setPixel(x, y, self.visibilities.pixel(x, y)+1)

        #Add weighted edges to graph
        self.node_EnemyBaseToFlagIndex = "enemy_base_to_flag"
        self.graph.add_node(self.node_EnemyBaseToFlagIndex)
        for vertex in vb2f:
            self.graph.add_edge(self.node_EnemyBaseToFlagIndex, vertex, weight = 1.0)
        
        self.node_EnemyFlagToScoreIndex = "enemy_flag_to_score" 
        self.graph.add_node(self.node_EnemyFlagToScoreIndex)
        for vertex in vf2s:
            self.graph.add_edge(self.node_EnemyFlagToScoreIndex, vertex, weight = 1.0)
        
        self.node_EnemyBaseToScoreIndex = "enemy_base_to_score"
        self.graph.add_node(self.node_EnemyBaseToScoreIndex)

        #Calculate shortest path to enemy flag from each point.
        self.distances = nx.single_source_shortest_path_length(self.graph, self.node_EnemyFlagToScoreIndex)
        
        self.queue = {}
        self.index = 0
        print "Done with init. Calculating ambush spots"
        self.calculateAmbushes()