Beispiel #1
0
def test_bsp():
    """
    commented out statements work in libtcod-cffi
    """
    bsp = libtcodpy.bsp_new_with_size(0, 0, 64, 64)
    repr(bsp)  # test __repr__ on leaf
    libtcodpy.bsp_resize(bsp, 0, 0, 32, 32)
    assert bsp != None

    # test getter/setters
    bsp.x = bsp.x
    bsp.y = bsp.y
    bsp.w = bsp.w
    bsp.h = bsp.h
    bsp.position = bsp.position
    bsp.horizontal = bsp.horizontal
    bsp.level = bsp.level

    # cover functions on leaf
    #self.assertFalse(libtcodpy.bsp_left(bsp))
    #self.assertFalse(libtcodpy.bsp_right(bsp))
    #self.assertFalse(libtcodpy.bsp_father(bsp))
    assert libtcodpy.bsp_is_leaf(bsp)

    assert libtcodpy.bsp_contains(bsp, 1, 1)
    #self.assertFalse(libtcodpy.bsp_contains(bsp, -1, -1))
    #self.assertEqual(libtcodpy.bsp_find_node(bsp, 1, 1), bsp)
    #self.assertFalse(libtcodpy.bsp_find_node(bsp, -1, -1))

    libtcodpy.bsp_split_once(bsp, False, 4)
    repr(bsp)  # test __repr__ with parent
    libtcodpy.bsp_split_once(bsp, True, 4)
    repr(bsp)

    # cover functions on parent
    assert libtcodpy.bsp_left(bsp)
    assert libtcodpy.bsp_right(bsp)
    #self.assertFalse(libtcodpy.bsp_father(bsp))
    assert not libtcodpy.bsp_is_leaf(bsp)
    #self.assertEqual(libtcodpy.bsp_father(libtcodpy.bsp_left(bsp)), bsp)
    #self.assertEqual(libtcodpy.bsp_father(libtcodpy.bsp_right(bsp)), bsp)

    libtcodpy.bsp_split_recursive(bsp, None, 4, 2, 2, 1.0, 1.0)

    # cover bsp_traverse
    def traverse(node, user_data):
        return True

    libtcodpy.bsp_traverse_pre_order(bsp, traverse)
    libtcodpy.bsp_traverse_in_order(bsp, traverse)
    libtcodpy.bsp_traverse_post_order(bsp, traverse)
    libtcodpy.bsp_traverse_level_order(bsp, traverse)
    libtcodpy.bsp_traverse_inverted_level_order(bsp, traverse)

    # test __repr__ on deleted node
    son = libtcodpy.bsp_left(bsp)
    libtcodpy.bsp_remove_sons(bsp)
    repr(son)

    libtcodpy.bsp_delete(bsp)
Beispiel #2
0
    def create(self):
        w = cfg.DNG_MINWIDTH + random.randint(0, cfg.DNG_SIZEVAR)
        h = cfg.DNG_MINHEIGHT + random.randint(0, cfg.DNG_SIZEVAR)
        self.width = w
        self.height = h

        self.level = [[DungeonTile(j, i) for i in xrange(h)]
                      for j in xrange(w)]
        self.console = libtcod.console_new(w, h)

        backColor = libtcod.Color(0, 0, 0)

        # magic!
        bsp_depth = 9
        bsp_min_room_size = 5

        bsp = libtcod.bsp_new_with_size(0, 0, w, h)
        libtcod.bsp_split_recursive(bsp, 0, bsp_depth, bsp_min_room_size,
                                    bsp_min_room_size, 1.5, 1.5)
        libtcod.bsp_traverse_inverted_level_order(bsp, self.traverseNode)

        self.findPathable()
        self.clearUnpathableAreas()

        # Place entrance

        e_pos = random.choice(self.pathable)
        entry = DungeonTileEntity(e_pos[0], e_pos[1])
        entry.setChar('>')
        entry.setColors(libtcod.Color(0, 100, 150), libtcod.Color(40, 40, 0))
        self.tile_entity.append(entry)
        self.entry = entry

        self.buildBlockedMap()
Beispiel #3
0
def generate_dungeon():
    global rooms
    #fill map with "blocked" tiles
    g.level_map = [
        [
            Tile(tile_types.CAVE_WALL)
            for x in range(MAP_WIDTH)
        ]
        for y in range(MAP_HEIGHT)
    ]

    # First, we create the root node of the tree.
    # This node encompasses the whole rectangular region.
    # bsp_new_with_size(x,y,w,h)
    my_bsp = libtcod.bsp_new_with_size(0, 0, MAP_WIDTH - 1, MAP_HEIGHT - 1)

    # Once we have the root node, we split it
    # into smaller non-overlapping nodes.
    #bsp_split_recursive(node, randomizer, num_recursive_levels, minHSize,
    #                    minVSize, maxHRatio, maxVRatio)
    libtcod.bsp_split_recursive(my_bsp, 0, BSP_RECURSE_LEVEL,
                                ROOM_MIN_SIZE, ROOM_MIN_SIZE, 1.5, 1.5)

    # Then we change each leaf to a room
    # and connect each subdivision with tunnels.
    libtcod.bsp_traverse_inverted_level_order(my_bsp, bsp_leaf_create_room)
    libtcod.bsp_traverse_level_order(my_bsp, bsp_leaf_create_tunnel)

    # set player coordinates to the center of this first room
    return (rooms[0].center()[0], rooms[0].center()[1])
Beispiel #4
0
def bsp_make_map():
	global map, objects, stairs, rooms
	objects = [player]	
	map = [[Tile(True)
			for y in range(MAP_HEIGHT)]
				for x in range(MAP_WIDTH)]
	my_bsp = libtcod.bsp_new_with_size(0,0,MAP_WIDTH, MAP_HEIGHT)
	libtcod.bsp_split_recursive(my_bsp,0,6,ROOM_MIN_SIZE,ROOM_MIN_SIZE,1.2,1.1)
	rooms = []
	libtcod.bsp_traverse_inverted_level_order(my_bsp,make_room)
	num_rooms = 0
	
	for room in rooms:
		(r_x, r_y) = room.center()
		if num_rooms == 0:
			player.x = r_x
			player.y = r_y
		else:
			(prev_x, prev_y) = rooms[num_rooms - 1].center()
			# Draw a coin (random 0 or 1)
			if libtcod.random_get_int(0,0,1) == 1:
				# first move horizontally, then vertically
				create_h_tunnel(prev_x, r_x, prev_y)
				create_v_tunnel(prev_y, r_y, r_x)
			else:
				# first move vertically, then horizontally
				create_v_tunnel(prev_y, r_y, prev_x)
				create_h_tunnel(prev_x, r_x, r_y)

		num_rooms += 1
	# Add stairs to last room
	stairs = Object(r_x, r_y, '<', 'stairs', libtcod.white, always_visible=True)
	objects.append(stairs)
	stairs.send_to_back()
def main_gen_level_algorithm():
    rnd = 0
    level = [[
        tile.Tile(blocked=True,
                  explore=True,
                  view=True,
                  char='#',
                  color=color.dark_wall) for i in range(const.MAP_WIDTH)
    ] for j in range(const.MAP_HEIGHT)]
    rooms = [make.create_room()]

    bsp = libtcod.bsp_new_with_size(0, 0, 50, 50)
    libtcod.bsp_split_recursive(bsp, 0, 2, 5, 5, 1.5, 1.5)
    fathre = libtcod.bsp_right(bsp)
    print(fathre.y)
    """
    нач:
        выбираем правого
        если его нету есть в списке:
            нач.
        иначе:
            добавляем текущий в список
            возвращаемся к папе
            выбираем левого
            нач.
    """

    return level
Beispiel #6
0
	def create(self):
		w=cfg.DNG_MINWIDTH+random.randint(0,cfg.DNG_SIZEVAR)
		h=cfg.DNG_MINHEIGHT+random.randint(0,cfg.DNG_SIZEVAR)
		self.width=w
		self.height=h
		
		self.level=[[DungeonTile(j,i) for i in xrange(h)] for j in xrange(w)]
		self.console=libtcod.console_new(w,h)

		backColor=libtcod.Color(0, 0, 0)
		
		# magic!
		bsp_depth=9
		bsp_min_room_size=5
		
		bsp = libtcod.bsp_new_with_size(0,0,w,h)
		libtcod.bsp_split_recursive(bsp, 0, bsp_depth,
                                            bsp_min_room_size,
                                            bsp_min_room_size, 1.5, 1.5)
		libtcod.bsp_traverse_inverted_level_order(bsp, self.traverseNode)
		
		self.findPathable()
		self.clearUnpathableAreas()
		
		# Place entrance
		
		e_pos=random.choice(self.pathable)
		entry=DungeonTileEntity(e_pos[0],e_pos[1])
		entry.setChar('>')
		entry.setColors(libtcod.Color(0, 100, 150),libtcod.Color(40, 40, 0))
		self.tile_entity.append(entry)
		self.entry=entry
			
		self.buildBlockedMap()
Beispiel #7
0
def make_map():
    global map, leafs, rooms, doors, fov_map
    map = [[Tile(True)
        for y in range(MAP_HEIGHT) ]
            for x in range(MAP_WIDTH) ]
    leafs = []
    rooms = []
    doors = []
    fov_map = tcod.map_new(MAP_WIDTH, MAP_HEIGHT)
    bsp = tcod.bsp_new_with_size(2, 2, MAP_WIDTH-3, MAP_HEIGHT-3)
    tcod.bsp_split_recursive(bsp, 0, 4 , MIN_LEAF_SIZE, MAX_LEAF_SIZE, 1.5, 1.5)
    tcod.bsp_traverse_inverted_level_order(bsp, bsp_callback)
    
    n=0 #create numerated rooms from leafs
    for object in leafs:
        make_room(object, n)
        n += 1 
    for object in rooms: #dig rooms & corridors
        dig(object)
        make_doors(object, object.number)
    for object in doors:
        prev = doors[object.number-1]
        dig_h_tunnel(prev.center_x, object.center_x, prev.center_y)
        dig_v_tunnel(prev.center_y, object.center_y, object.center_x)
    
    for x in range(0, MAP_WIDTH):
        set_diggable(x,0,False)
        set_diggable(x,MAP_HEIGHT-1,False)
    for y in range(0, MAP_HEIGHT):
        set_diggable(0,y,False)
        set_diggable(MAP_WIDTH-1,y,False)
    
    populate()
    
    fov_init()
	def create_dungeon(self):
		"""	|  Creates a random map

			|  First, fills the map with walls.
			|  Creates a BSP (Binary Space Partitioning) Tree and traverses it, creating a randomly-sized room for every node.
			|  50 % chance to spawn a random room feature, such as holes in the floor or columns.
			|  Spawns the player on a random unblocked spot.
			|  Then, calls *spawn_stuff()* to spawn mobs, items and the stairs
		"""
		from spawn import spawn_stuff
		from components import Object
		from roomfeatures import random_roomfeature

		#fill map with walls
		self.map = [[ Tile(char=chr(219), tile_type='wall', color=libtcod.grey * libtcod.random_get_float(0, 0.7, 1))
			for y in range(gvar.MAP_HEIGHT) ]
				for x in range(gvar.MAP_WIDTH) ]

		#Create BSP Tree and Traverse it
		tree = libtcod.bsp_new_with_size(0, 0, gvar.MAP_WIDTH-2, gvar.MAP_HEIGHT-2)
		libtcod.bsp_split_recursive(tree, 0, 4, 8, 8, 1.3, 1.3)
		libtcod.bsp_traverse_post_order(tree, self.process_node, userData=0)

		#Random Roomfeature
		for room in self.rooms:
			if libtcod.random_get_int(0, 0, 2) == 0:
				random_roomfeature(self, room)

		spawn_stuff(self)
Beispiel #9
0
    def split(self, depth, min_size, maxHRatio = 2, maxVRatio = 2):
        libtcod.bsp_split_recursive(self.bsp, 0, depth,
                                    min_size +1,
                                    min_size +1, maxHRatio, maxVRatio)
        bsp_nodes = []
        def build_list(node, _):
            bsp_nodes.append(node)
            return True
        libtcod.bsp_traverse_inverted_level_order(self.bsp, build_list)

        return bsp_nodes
Beispiel #10
0
    def make_house():
        bsp_tree = tcod.bsp_new_with_size(0, 0, HOUSE_WIDTH - 1, HOUSE_HEIGHT - 1)
        tcod.bsp_split_recursive(bsp_tree, 0, BSP_DEPTH, MIN_ROOM_WIDTH, MIN_ROOM_HEIGHT,
                                 MAX_H_RATIO, MAX_V_RATIO)

        tcod.bsp_traverse_inverted_level_order(bsp_tree, handle_node)
        house_array[-1][-1] = Tile("wall", True, True)

        noise = tcod.noise_new(2, HURST, LACNULARITY)
        for x in xrange(HOUSE_WIDTH):
            for y in xrange(HOUSE_HEIGHT):
                if tcod.noise_get_turbulence(noise, [x, y], 32.0, tcod.NOISE_SIMPLEX) > THRESHOLD:
                    house_array[y][x] = Tile("floor", True, True)
Beispiel #11
0
def make_bsp():
    # map stuff
    var.map = [[Tile(True) for y in range(var.MAP_HEIGHT)]
               for x in range(var.MAP_WIDTH)]

    var.fov_map = lib.map_new(var.MAP_WIDTH, var.MAP_HEIGHT)
    var.fov_recompute = True

    # new root node
    bsp = lib.bsp_new_with_size(0, 0, var.MAP_WIDTH, var.MAP_HEIGHT)

    # split into nodes
    lib.bsp_split_recursive(bsp, 0, var.DEPTH, var.MIN_SIZE + 1,
                            var.MIN_SIZE + 1, 1.5, 1.5)

    # traverse the nodes and create rooms
    lib.bsp_traverse_inverted_level_order(bsp, traverse_node)

    # Random room for the stairs
    stairs_location = random.choice(var.bsp_rooms)
    var.bsp_rooms.remove(stairs_location)
    var.stairs = Entity(stairs_location[0],
                        stairs_location[1],
                        '<',
                        'stairs',
                        'white',
                        always_visible=True,
                        graphical_char='[0xE0A9]')
    var.entities.append(var.stairs)
    send_to_back(var.stairs)

    # Random room for player start
    player_room = random.choice(var.bsp_rooms)
    var.bsp_rooms.remove(player_room)
    var.player.x = player_room[0]
    var.player.y = player_room[1]

    # add monsters and items
    for room in var.bsp_rooms:
        new_room = Rect(room[0], room[1], 2, 2)
        place_objects(new_room)

    initialize_fov()
    def generate_map(self):
        self._map = self._generate_empty_map()
        bsp = libtcod.bsp_new_with_size(0, 0, self.map_width, self.map_height)
        libtcod.bsp_split_recursive(bsp, 0, self.generation_depth,
                                    self.min_room_size + 1,
                                    self.min_room_size + 1, 1.5, 1.5)
        libtcod.bsp_traverse_inverted_level_order(bsp, self._traverse_node)

        stairs_room = random.choice(self._rooms)
        self._rooms.remove(stairs_room)
        self.stairs = StairsUp(stairs_room[0], stairs_room[1])
        self.objects.append(self.stairs)
        self.objects.send_to_back(self.stairs)

        player_room = random.choice(self._rooms)
        self._rooms.remove(player_room)
        self.player.x = player_room[0]
        self.player.y = player_room[1]

        return self._map
Beispiel #13
0
def make_bsp():
    global bsp_rooms
 
    cfg.objects = [cfg.player]
 
    cfg.map = [[Tile(True) for y in range(cfg.MAP_HEIGHT)] for x in range(cfg.MAP_WIDTH)]
 
    #Empty global list for storing room coordinates
    bsp_rooms = []
 
    #New root node
    bsp = libtcod.bsp_new_with_size(0, 0, cfg.MAP_WIDTH, cfg.MAP_HEIGHT)
 
    #Split into nodes
    libtcod.bsp_split_recursive(bsp, 0, cfg.DEPTH, cfg.MIN_SIZE + 1, cfg.MIN_SIZE + 1, 1.5, 1.5)
 
    #Traverse the nodes and create rooms                            
    libtcod.bsp_traverse_inverted_level_order(bsp, traverse_node)
 
    #Random room for the stairs
    stairs_location = random.choice(bsp_rooms)
    bsp_rooms.remove(stairs_location)
    if cfg.MAKE_STAIRS:
        cfg.stairs = object.Object(stairs_location[0], stairs_location[1], '>', 'stairs', libtcod.white, always_visible=True)
    else:
        cfg.stairs = object.Object(stairs_location[0], stairs_location[1], cfg.FLOOR_CHAR, ' ', cfg.color_light_ground, always_visible=False)
    cfg.objects.append(cfg.stairs)
    cfg.stairs.send_to_back()
 
    #Random room for player start
    player_room = random.choice(bsp_rooms)
    bsp_rooms.remove(player_room)
    cfg.player.x = player_room[0]
    cfg.player.y = player_room[1]
 
    #Add monsters and items
    for room in bsp_rooms:
        new_room = Rect(room[0] - cfg.MIN_SIZE/2, room[1] - cfg.MIN_SIZE/2, cfg.MIN_SIZE, cfg.MIN_SIZE)
        place_objects(new_room)
 
    initialize_fov()
Beispiel #14
0
    def __init__(self, width, height, seed=54):
        self.screen_width = width
        self.screen_height = height
        self.seed = seed
        random.seed(seed)
        self.rnd = libtcod.random_new_from_seed(self.seed)

        # Load Random Names
        self.planet_names = []
        with open("planet_names", "r") as planet_names_file:
            self.planet_names = planet_names_file.readlines()
        random.shuffle(self.planet_names)
        self.planet_name_index = -1

        # Build Galaxy Map
        self.bsp_depth = 6
        self.bsp = libtcod.bsp_new_with_size(0, 0, self.screen_width, self.screen_height)
        libtcod.bsp_split_recursive(self.bsp, self.rnd, self.bsp_depth, 8, 8, 1.0, 1.0)

        # Count number of sectors
        count = [ 0 ]
        def count_bsp_leaf_nodes(node, userData):
            if node.level == self.bsp_depth:
                count[0] += 1
            return True
        libtcod.bsp_traverse_inverted_level_order(self.bsp, count_bsp_leaf_nodes, userData=None)
        self.sector_count = count[0]
        # self.sector_count = 2**self.bsp_depth # only if we have a fully populated tree (not guaranteed)

        self.sectors = []
        for i in range(0, self.sector_count):
            self.new_sector()

        self.link_sectors()

        self.current_sector = random.randrange(self.sector_count)
        # pp("total sectors: {}  current sector: {}".format(self.sector_count, self.current_sector))
        self.targeted_sector_index = 0
        self.selected_blink = 0
Beispiel #15
0
    def generate(self):
        self.tiles = [[self.board.factory.createPiece('empty', x, y) for y in range(self.height)] for x in range(self.width)]
        
        bsp_root = libtcod.bsp_new_with_size(0, 0, self.width, self.height)
        libtcod.bsp_split_recursive(bsp_root, None, 8, minHSize=11, minVSize=11, maxHRatio=1.0, maxVRatio=1.0)

        rooms = []
        self.process_node(bsp_root, rooms)

        for room in rooms:
            self.carve_room(room.x, room.y, room.width, room.height)

        full_graph = csr_matrix([[room1.distance_to(room2) for room1 in rooms] for room2 in rooms])
        minimum_spanning_graph = minimum_spanning_tree(full_graph)
        indexes = minimum_spanning_graph.nonzero()

        for i in range(len(indexes[0])):
            room1 = rooms[indexes[0][i]]
            room2 = rooms[indexes[1][i]]
            self.carve_corridor(room1.center_x, room1.center_y, room2.center_x, room1.center_y)
            self.carve_corridor(room2.center_x, room1.center_y, room2.center_x, room2.center_y)

        return rooms