예제 #1
0
파일: mesh.py 프로젝트: GitExl/DoomPath
    def connect_teleporters(self):
        """
        Creates area connections for teleporter line types.
        """
        
        count = 0
        rect = Rectangle()
        
        for teleporter in self.map_data.teleporters:
            target_area = None
            
            # Get the area that the teleporter target is in.
            if teleporter.kind == Teleporter.TELEPORTER_THING:
                floorz = self.map_data.get_floor_z(teleporter.dest.x, teleporter.dest.y)
                target_area = self.get_area_at(teleporter.dest, floorz)
            if teleporter.kind == Teleporter.TELEPORTER_LINE:
                dest = Vector2()
                dest.x, dest.y = self.map_data.get_line_center(teleporter.dest_line)
                floorz = self.map_data.get_floor_z(teleporter.dest.x, teleporter.dest.y)
                target_area = self.get_area_at(dest, floorz)

            # Ignore missing teleport targets.
            if target_area is None:
                print 'Teleporter linedef {} does not point to a place on the map with navigation areas.'.format(teleporter.source_line)
                continue
            
            # Create the teleport connection line from the linedef vertices.
            linedef = self.map_data.linedefs[teleporter.source_line]           
            rect.set(
                linedef.vertex1.x,
                linedef.vertex1.y,
                linedef.vertex2.x,
                linedef.vertex2.y
            )

            # Place a teleporter connection in all intersecting source areas.
            areas = self.get_areas_intersecting(rect)
            for area in areas:
                connection = Connection()
                connection.rect.copy_from(rect)
                connection.area_a = area
                connection.area_b = target_area
                connection.linedef = teleporter.source_line
                connection.flags = Connection.FLAG_AB | Connection.FLAG_TELEPORTER
                
                area.connections.append(connection)
            
            count += 1
        
        print 'Connected {} teleporters.'.format(count)
예제 #2
0
파일: mesh.py 프로젝트: GitExl/DoomPath
 def read(self, filename, map_data):
     """
     Reads a mesh from a file.
     """
     
     with open(filename, 'rb') as f:
         data = Mesh.FILE_HEADER.unpack(f.read(Mesh.FILE_HEADER.size))
         file_id = data[0]
         file_version = data[1]
         
         data_hash = data[2]
         if data_hash != map_data.data_hash:
             self.outdated = True
             print 'Warning: the navigation mesh is out of date or the wrong map is loaded.'
         else:
             self.outdated = False
         
         # Validate header.
         if file_id != Mesh.FILE_ID:
             print 'Invalid mesh file.'
             return
         if file_version > Mesh.FILE_VERSION:
             print 'Unsupported mesh version {}.'.format(file_version)
             return
         
         area_hashes = {}
         plane_hashes = {}
         connection_hashes = {}
         self.areas = []
         
         # Read planes.
         planes_count = Mesh.FILE_PLANES_HEADER.unpack(f.read(Mesh.FILE_PLANES_HEADER.size))[0]
         for _ in range(planes_count):
             plane = Plane()
             plane_hash, plane.a, plane.b, plane.c, plane.d, plane.invc = Mesh.FILE_PLANE.unpack(f.read(Mesh.FILE_PLANE.size))
             plane_hashes[plane_hash] = plane
         
         # Read area connections.
         connections_count = Mesh.FILE_CONNECTIONS_HEADER.unpack(f.read(Mesh.FILE_CONNECTIONS_HEADER.size))[0]
         for _ in range(connections_count):
             connection = Connection()
             connection_hash, left, top, right, bottom, area_a_hash, area_b_hash, linedef, flags = Mesh.FILE_CONNECTION.unpack(f.read(Mesh.FILE_CONNECTION.size))
             
             if linedef == -1:
                 linedef = None
             
             connection.rect.set(left, top, right, bottom)
             connection.center = connection.rect.get_center()
             connection.area_a = area_a_hash
             connection.area_b = area_b_hash
             connection.linedef = linedef
             connection.flags = flags
             connection_hashes[connection_hash] = connection
         
         # Read mesh areas.
         area_count = Mesh.FILE_AREAS_HEADER.unpack(f.read(Mesh.FILE_AREAS_HEADER.size))[0]
         for index in range(area_count):
             area_hash, left, top, right, bottom, z, plane_hash, sector_index, flags, connection_count = Mesh.FILE_AREA.unpack(f.read(Mesh.FILE_AREA.size))
             
             area = Area(left, top, right, bottom, z)
             if sector_index == -1:
                 sector_index = None
             area.sector = sector_index
             area.flags = flags
             area.index = index
             if plane_hash != 0:
                 area.plane = plane_hashes[plane_hash]
             
             for _ in range(connection_count):
                 connection_hash = Mesh.FILE_AREA_CONNECTION.unpack(f.read(Mesh.FILE_AREA_CONNECTION.size))[0]
                 area.connections.append(connection_hashes[connection_hash])
             
             self.areas.append(area)
             area_hashes[area_hash] = area
         
         # Set connection objects. 
         for connection in connection_hashes.itervalues():
             if connection.area_a != 0:
                 connection.area_a = area_hashes[connection.area_a]
             else:
                 connection.area_a = None
             if connection.area_b != 0:
                 connection.area_b = area_hashes[connection.area_b]
             else:
                 connection.area_b = None
     
     self.map_data = map_data
예제 #3
0
파일: mesh.py 프로젝트: GitExl/DoomPath
    def connect_areas(self):
        """
        Connects navigation areas together.
        
        Area objects are expected to contain references to only their outermost elements. Using these elements and
        their connections, areas are connected to each other.
        """
        
        count = 0
               
        for area in self.areas:
            
            # Test each element in an area.
            for element in area.elements:
                for direction in Element.DIR_RANGE:
                    if element.connection[direction] is not None:
                        continue
                
                    other_element = element.elements[direction]
                    if other_element is None or other_element.area == area or other_element.area is None:
                        continue
                    
                    # Find all elements that connect to the same area.
                    connecting = []
                    other_area = other_element.area
                    for c_element in area.elements:
                        
                        # Add elements that connect to the same area to a list of connection elements.
                        if c_element.elements[direction] is not None and c_element.elements[direction].area == other_area:
                            connecting.append(c_element)
                            connecting.append(c_element.elements[direction])
                    
                    # Calculate the bounding box of the connecting elements.
                    # This forms the bounding box of the connection area.
                    rect = self.get_elements_bounds(connecting)
                    
                    # See if a connection exists in the other area that is equal to the current one.
                    connection = None
                    for c_connection in other_area.connections:
                        if c_connection.area_b == area and c_connection.rect == rect:
                            connection = c_connection
                            connection.flags |= Connection.FLAG_BA
                            break

                    # Create new connection object if needed.
                    if connection is None:
                        count += 1
                        
                        connection = Connection()
                        connection.flags = Connection.FLAG_AB
                        connection.area_a = area
                        connection.area_b = other_area
                        connection.rect.copy_from(rect)
                        connection.center = connection.rect.get_center()
                        
                    area.connections.append(connection)
                    
                    # Assign connection to elements.
                    for c_element in connecting:
                        if c_element.area == area:
                            c_element.connection[direction] = connection
        
        return count