예제 #1
0
 def takepath(self):
     # libtcod.path_compute(game.player.path, game.player.destination[0], game.player.destination[1], ...)
     if libtcod.path_is_empty(self.path):
         return "empty"
     else:
         x, y = libtcod.path_get(self.path, 0)
         self.owner.x, self.owner.y = libtcod.path_walk(self.path, True)
         return "pathing"
예제 #2
0
    def move_towards(self, target_x, target_y):
	#Upgraded the move_towards to use the libtcod path algorythms and solving a bug 
	#where the monsters "waited" near the doors
        #path = libtcod.path_new_using_map(fov_map,1)
        path = libtcod.path_new_using_function(MAP_WIDTH, MAP_HEIGHT, path_func, map, 1)
        libtcod.path_compute(path, self.x, self.y, target_x, target_y)
        (end_x,end_y) = libtcod.path_get(path, 0)
        dx = end_x - self.x
        dy = end_y - self.y
        self.move(dx, dy)
예제 #3
0
    def get_path_pos(self, pos1, pos2, dist):

        chemin = libtcod.path_new_using_map(self.path_map, 0)
        print pos1, pos2
        libtcod.path_compute(chemin, pos1[0], pos1[1], pos2[0], pos2[1])
        print libtcod.path_is_empty(chemin)

        x, y = libtcod.path_get(chemin, dist)

        #	for i in range(dist):
        #		x,y=libtcod.path_walk(path,False)
        #	print x,y
        libtcod.path_delete(chemin)
        return [x, y]
예제 #4
0
파일: game.py 프로젝트: bope/libtcod-test
    def process(self, game):
        visible =self.game.fov.is_visible(self.x, self.y)
        moved = False

        if visible:
            self.seen += 1
            self.color = tcod.color_lerp(tcod.dark_gray, self.orig_color,
                                         (self.seen % 50) / 100.0)
            if self.seen % 50 == 0:
                self.game.duplicate(self)

            if self.seen == 200:
                self.character = 'o'
                self.movement = 0.4

            elif self.seen == 400:
                self.character = 'O'
                self.movement = 0.6

            path = tcod.path_new_using_map(self.game.fov.fov, 1.0)
            tcod.path_compute(path, self.x, self.y, self.game.player.x,
                              self.game.player.y)

            if tcod.path_size(path) > 2:
                self.points += self.movement
                if self.points >= 1:
                    self.points -= 1
                    x, y = tcod.path_get(path, 1)
                    self.move(x - self.x, y - self.y)
                    moved = True
            tcod.path_delete(path)

        if not moved:
            self.points += self.movement
            if self.points >= 1:
                self.points -= 1
                movement = [
                    (0, 0),
                    (0, 1),
                    (0, -1),
                    (1, 0),
                    (-1, 0),
                    (1, 1),
                    (-1, -1),
                    (-1, 1),
                    (1, -1)
                ]
                self.move(*random.choice(movement))

        return True
예제 #5
0
파일: tasks.py 프로젝트: Raveline/tavern
 def tick(self, world_map, creature):
     if self.tick_time == 0:
         self.compute_path(world_map, creature)
     if self.tick_time < self.path_length:
         x, y = tcod.path_get(self.path, self.tick_time)
         z = creature.z
         if not world_map[(x, y, z)].is_walkable():
             # Path is not walkable anymore !
             # We'll try to rebuild it...
             self.compute_path(world_map, creature)
         else:
             creature.move((x, y, 0))
     else:
         self.finish()
     super(Walking, self).tick(world_map, creature)
예제 #6
0
def move_astar(entity, entities, target, fov_map):
    """Use the A* algorithm to find a path to target, returning the next step along that path"""

    # TODO: maybe we re-use the existing fov map, but just un-set this entity and the target temporarily
    # that should save an entities iteration for making everything but entity and target unwalkable

    # Create a FOV map that has the dimensions of the map
    fov = libtcod.map_new(init.map_width, init.map_height)

    # Scan the current map each turn and set all the walls as unwalkable
    for ent in entities:
        if ent != entity and ent != target and 'Position' in ent:
            libtcod.map_set_properties(fov, ent['Position']['x'], ent['Position']['y'], ent['Opacity'] < 0.5, ent['Solid'] < 0.5)

    # Allocate a A* path
    # The 1.41 is the normal diagonal cost of moving, it can be set as 0.0 if diagonal moves are prohibited
    my_path = libtcod.path_new_using_map(fov, 1.41)

    # Compute the path between self's coordinates and the target's coordinates
    libtcod.path_compute(my_path, entity['Position']['x'], entity['Position']['y'], target['Position']['x'], target['Position']['y'])

    # Debugging A*
    for i in range (libtcod.path_size(my_path)):
        (x, y) = libtcod.path_get(my_path, i)
        for ent in entities:
            if (i < libtcod.path_size(my_path) - 1) and 'Position' in ent and ent['Position']['x'] == x and ent['Position']['y'] == y and 'A*Highlight' in ent:
                ent['A*Highlight'] = True

    # Check if the path exists, and in this case, also the path is shorter than 25 tiles
    # The path size matters if you want the monster to use alternative longer paths (for example through other rooms) if for example the player is in a corridor
    # It makes sense to keep path size relatively low to keep the monsters from running around the map if there's an alternative path really far away
    if not libtcod.path_is_empty(my_path) and libtcod.path_size(my_path) < 25:
        # Find the next coordinates in the computed full path
        (next_x, next_y) = libtcod.path_walk(my_path, True)
        dx = next_x - entity['Position']['x']
        dy = next_y - entity['Position']['y']
    else:
        # Keep the old move function as a backup so that if there are no paths (for example another monster blocks a corridor)
        # it will still try to move towards the player (closer to the corridor opening)
        (dx, dy) = from_a_to_b(entity['Position']['x'], entity['Position']['y'], target['Position']['x'], target['Position']['y'])

    # Delete the path to free memory
    libtcod.path_delete(my_path)
    return (dx, dy)
예제 #7
0
	def move_towards(self, target_x, target_y):
		global fov_map
		path = libtcod.path_new_using_map(fov_map)
		libtcod.path_compute(path, self.x, self.y, target_x, target_y)
		x,y = libtcod.path_get(path, 0)

		if x is None:
			self.move(0, 0)
			
		else:
			dx = int(round(target_x - x))
			dy = int(round(target_y - y))
		
			if dx != 0:
				dx = dx/abs(dx)
			if dy != 0:
				dy = dy/abs(dy)
			
			self.move(dx, dy)
		
		libtcod.path_delete(path)
예제 #8
0
def can_hear(obj, x,y, volume):
    if ( on(obj,DEAD) or on(obj,DEAF) or not obj.stats.get('hearing') ):
         return False
    dist=maths.dist(obj.x, obj.y, x, y)
    maxHearDist=volume*obj.stats.get('hearing')/AVG_HEARING
    if (obj.x == x and obj.y == y): return (0,0,maxHearDist,)
    if dist > maxHearDist: return False
    # calculate a path
    path=path_init_sound()
    path_compute(path, obj.x,obj.y, x,y)
    pathSize=libtcod.path_size(path)
    if dist >= 2:
        semifinal=libtcod.path_get(path, 0)
        xf,yf=semifinal
        dx=xf - obj.x
        dy=yf - obj.y
    else:
        dx=0
        dy=0
    path_destroy(path)
    loudness=(maxHearDist - pathSize - (pathSize - dist))
    if loudness > 0:
        return (dx,dy,loudness)
예제 #9
0
def test_astar(map_):
    astar = libtcodpy.path_new_using_map(map_)

    assert not libtcodpy.path_compute(astar, *POINTS_AC)
    assert libtcodpy.path_size(astar) == 0
    assert libtcodpy.path_compute(astar, *POINTS_AB)
    assert libtcodpy.path_get_origin(astar) == POINT_A
    assert libtcodpy.path_get_destination(astar) == POINT_B
    libtcodpy.path_reverse(astar)
    assert libtcodpy.path_get_origin(astar) == POINT_B
    assert libtcodpy.path_get_destination(astar) == POINT_A

    assert libtcodpy.path_size(astar) != 0
    assert libtcodpy.path_size(astar) > 0
    assert not libtcodpy.path_is_empty(astar)

    for i in range(libtcodpy.path_size(astar)):
        x, y = libtcodpy.path_get(astar, i)

    while (x, y) != (None, None):
        x, y = libtcodpy.path_walk(astar, False)

    libtcodpy.path_delete(astar)
예제 #10
0
파일: player.py 프로젝트: jdau/adungeon
	def tick(self,world):
		if self.explored: return
		if not self.goal:
			[self.goal,self.path] = self.findExplorePoint(world)
			if not self.goal:
				path=world.getPathable()
				self.explored=True
				unseen=0
				for n in path:
					if not world.isSeen(n[0],n[1]):unseen=unseen+1
				
				print "Exploration done,",unseen,"unseen tiles"
				
				return
			self.path_progress=0
		
		[next_x,next_y]=libtcod.path_get(self.path, self.path_progress)
		self.x=next_x
		self.y=next_y
		self.path_progress=self.path_progress+1
		if libtcod.path_size(self.path)==self.path_progress:
			self.goal=None
			self.path=None
예제 #11
0
 def nodes(self):
     rr = range(self.path.size())
     return [Pos(*libtcod.path_get(self.path, i)) for i in rr]
예제 #12
0
파일: main.py 프로젝트: flappity/Dogelike
 def move_towards(self, target_x, target_y):
     path = libtcod.path_new_using_map(fov_map)
     libtcod.path_compute(path, self.x, self.y, target_x, target_y)
     dx, dy = libtcod.path_get(path, 0)
     self.move_absolute(dx, dy)
     libtcod.path_delete(path)
예제 #13
0
파일: main.py 프로젝트: flappity/Dogelike
 def move_towards(self, target_x, target_y):
     path = libtcod.path_new_using_map(fov_map)
     libtcod.path_compute(path, self.x, self.y, target_x, target_y)
     dx, dy = libtcod.path_get(path, 0)
     self.move_absolute(dx, dy)
     libtcod.path_delete(path)
예제 #14
0
파일: helpers.py 프로젝트: pangal/it
def libtcod_path_to_list(path_map):
    ''' get a libtcod path into a list '''
    return [libtcod.path_get(path_map, i) for i in xrange(libtcod.path_size(path_map))]
예제 #15
0
 def path_toward(self, target_x, target_y):
     if libtcod.path_compute(base_path, self.owner.x, self.owner.y, target_x, target_y):
         (path_x, path_y) = libtcod.path_get(base_path, 0)
         dx = path_x - self.owner.x
         dy = path_y - self.owner.y
         self.owner.move(dx, dy)
예제 #16
0
파일: paths.py 프로젝트: ludamad/7DayRL2013
 def get_node(self, idx):
     return Pos( *libtcod.path_get(self.path, idx))
예제 #17
0
 def get_node(self, idx):
     return Pos(*libtcod.path_get(self.path, idx))
예제 #18
0
파일: ai.py 프로젝트: mscottmoore16/golemrl
    def update(self):
        tcod_map = self.game.dungeon.tcod_map        
        if not self.path:
            self.path = libtcod.path_new_using_map(tcod_map)

        pos = self.entity.pos
        visible = self.game.player.fov(*pos)
    
        done = False
        while not done:
            if self.state == AI_INACTIVE: #not used yet
                done = True
            elif self.state == AI_SLEEPING:
                wake_up = False
                for s in self.sounds:
                    if self.game.rng.percent(min(95,s[0]*(self.creature.perception+5)/10)):
                        wake_up = True
                if self.creature.health < self.creature.max_health:
                    wake_up = True
                if wake_up:
                    self.state = AI_RESTING
                    self.entity.notify(Event(EVENT_WAKE_UP,
                                            actor=self.entity))
                else: #continue sleeping
                    done = True

            elif self.state == AI_RESTING:
                self.creature.fov.refresh()
                if self.check_for_player():
                    self.state = AI_FIGHTING
                    self.entity.notify(Event(EVENT_NOTICE,
                                            actor=self.entity))
                else: #continue to rest or wander?
                    if self.game.rng.percent(20):
                        done = True
                    else:
                        self.state = AI_WANDERING

            elif self.state == AI_WANDERING:
                self.creature.fov.refresh()
                if self.check_for_player():
                    self.state = AI_FIGHTING
                    self.entity.notify(Event(EVENT_NOTICE,
                                            actor=self.entity))
                else:
                    direction = (0,0)
                    while not (self.valid_movement(direction) or
                               self.game.cur_level.get_tile(self.entity.x+direction[0],self.entity.y+direction[1]).creature==self.game.player):

                        directions = [(1,1),(1,-1),(-1,1),(-1,-1),
                                      (0,1),(0,-1),(1,0),(-1,0)]
                        if self.prev_dir:
                            directions += [self.prev_dir]*6
                            if self.prev_dir[0]==0:
                                directions += [(1,self.prev_dir[1])]*2
                                directions += [(-1,self.prev_dir[1])]*2
                            elif self.prev_dir[1]==0:
                                directions += [(self.prev_dir[0],1)]*2
                                directions += [(self.prev_dir[0],-1)]*2
                            else:
                                directions += [(self.prev_dir[0],0)]*2
                                directions += [(0,self.prev_dir[1])]*2
                        direction = self.game.rng.choose(directions)
                    t = self.game.cur_level(self.entity.x+direction[0],
                                            self.entity.y+direction[1])
                    if self.game.rng.percent(10):
                        self.state = AI_RESTING
                        done=True
                    elif t.creature is self.game.player:
                        self.entity.notify(EVENT_NOTICE,
                                          actor=self.entity)
                        self.state = AI_FIGHTING
                    else:
                        self.entity.move_to(self.entity.x+direction[0],
                                           self.entity.y+direction[1])
                        self.prev_dir=direction
                        done=True

            elif self.state == AI_FIGHTING:
                if self.creature.fov(*self.game.player.pos):
                    self.last_saw_player = 0
                else: #increase last_saw_player and fall asleep if it's been too long
                    self.last_saw_player += 1
                    if self.last_saw_player >= 5:
                        self.state = AI_SLEEPING

                new_player_pos = self.game.player.pos #get latest player pos and recalculate path if needed
                if self.player_pos != new_player_pos:
                    self.player_pos = new_player_pos
                    self.compute_path(*self.player_pos)

                if (self.path_index < libtcod.path_size(self.path)
                    and self.game.player.creature.alive):#walk path
                    x,y = libtcod.path_get(self.path, self.path_index)
                    event = self.entity.move_to(x,y)
                    if event.event_type == EVENT_MOVE: #successfully moved, increase path index
                        self.path_index += 1
                        done = True
                    elif self.entity.distance_to(*self.player_pos) < 2:
                        #didn't move but can attack player
                        self.creature.attack(self.game.player)
                        done = True
                    else: #didn't move or attack, try new path
                        self.compute_path(*self.player_pos)
                else: #end of path and don't know where to go now
                    done = True

        self.sounds = []
        if self.state != AI_INACTIVE and self.state != AI_SLEEPING:
            self.creature.fov.refresh()
예제 #19
0
파일: helpers.py 프로젝트: engwalker/it
def libtcod_path_to_list(path_map):
    ''' get a libtcod path into a list '''
    return [
        libtcod.path_get(path_map, i)
        for i in xrange(libtcod.path_size(path_map))
    ]
예제 #20
0
def map_init_dungeon(width, height):
    def path_cost(xFrom, yFrom, xTo, yTo, alg_array):
        if alg_array[xTo][yTo] == 0:
            return 1
        if alg_array[xTo][yTo] == 3:
            return 0.01
        else:
            return 10

    room_prefabs_10x10 = []
    f = open('resources/map_prefabs/map_prefabs[10x10].csv',
             'r').read().split('\n')  # 10x10
    for i in range(len(f[0]) // 10):
        for j in range(len(f) // 10):
            room = ''
            for y in range(10):
                for x in range(10):
                    room += f[j * 10 + x][i * 10 + y]
            room_prefabs_10x10.append(room)
    room_prefabs_5x5 = []
    f = open('resources/map_prefabs/map_prefabs[5x5].csv',
             'r').read().split('\n')  # 10x10
    for i in range(len(f[0]) // 5):
        for j in range(len(f) // 5):
            room = ''
            for y in range(5):
                for x in range(5):
                    room += f[j * 5 + x][i * 5 + y]
            room_prefabs_5x5.append(room)
    monsters_pool = [[game_content.m_slime], []]

    alg_array = [[0 for j in range(height)] for i in range(width)]
    terrain = [[0 for j in range(height)] for i in range(width)]
    items = []
    entities = []
    creatures = []

    rooms = []
    room_exits = []
    room_connections = []
    rooms_size = [(10, 10), (5, 5)]

    rooms.append((width // 2 - 3, height // 2 - 3, 6, 6))
    for x in range(width // 2 - 3, width // 2 + 3):
        for y in range(height // 2 - 3, height // 2 + 3):
            if y == height // 2 and (x == width // 2 - 3
                                     or x == width // 2 + 3):
                alg_array[x][y] = 7
                room_exits.append((x, y, -1))
            else:
                alg_array[x][y] = 2
    available_spots = [
        (x, y) for x in range(width) for y in range(height)
        if x > 6 and x < width - 12 and y > 6 and y < height - 12
    ]
    for x in range(len(available_spots)):
        append = True
        i, j = available_spots.pop(random.randint(0, len(available_spots) - 1))
        w, h = random.choice(rooms_size)
        newRoom = (i, j, w, h)  #X, Y, W, H
        for room in rooms:
            if util.rectangle_intersects(newRoom, room):
                append = False
        if append == True:
            rooms.append(newRoom)
    for roomIndex in range(len(rooms))[0:]:
        room = rooms[roomIndex]
        if room[2] == 10 and room[3] == 10:
            room_layout = random.choice(room_prefabs_10x10)
            for x in range(room[2]):
                for y in range(room[3]):
                    alg_array[x + room[0]][y + room[1]] = int(
                        room_layout[x * 10 + y])
                    if int(room_layout[x * 10 + y]) == 7:
                        room_exits.append(
                            (x + room[0], y + room[1], roomIndex))
        elif room[2] == 5 and room[3] == 5:
            room_layout = random.choice(room_prefabs_5x5)
            for x in range(room[2]):
                for y in range(room[3]):
                    alg_array[x + room[0]][y + room[1]] = int(
                        room_layout[x * 5 + y])
                    if int(room_layout[x * 5 + y]) == 7:
                        room_exits.append(
                            (x + room[0], y + room[1], roomIndex))
    for exit_init in room_exits:
        path = libtcodpy.path_new_using_function(width, height, path_cost,
                                                 alg_array, 0)
        other_exits = sorted([
            exit_other
            for exit_other in room_exits if exit_other[2] != exit_init[2] and (
                exit_other[2], exit_init[2]) not in room_connections
        ],
                             key=lambda e: util.simpledistance(
                                 (exit_init[0], exit_init[1]), (e[0], e[1])))
        if len(other_exits) > 0:
            exit_end = other_exits[0]
        else:
            exit_end = sorted([
                exit_other
                for exit_other in room_exits if exit_other[2] != exit_init[2]
            ],
                              key=lambda e: util.simpledistance(
                                  (exit_init[0], exit_init[1]),
                                  (e[0], e[1])))[0]
        room_connections.append((exit_init[2], exit_end[2]))
        room_connections.append((exit_end[2], exit_init[2]))
        libtcodpy.path_compute(path, exit_init[0], exit_init[1], exit_end[0],
                               exit_end[1])
        for i in range(libtcodpy.path_size(path) - 1):
            x, y = libtcodpy.path_get(path, i)
            alg_array[x][y] = 3

    for x in range(len(alg_array)):
        for y in range(len(alg_array[x])):
            if alg_array[x][y] in [0, 1]:
                terrain[x][y] = game_content.t_cave_wall(x, y)
            else:
                terrain[x][y] = game_content.t_cave_floor(x, y)
            if alg_array[x][y] == 4:
                creatures.append(
                    random.choice(monsters_pool[GAME.level])(x, y))
            if alg_array[x][y] == 7:
                entities.append(
                    game_content.n_door(
                        x, y,
                        game_content.SPRITESHEET_ENTITIES.image_at(
                            (0, 32, 32, 32)),
                        game_content.SPRITESHEET_ENTITIES.image_at(
                            (32, 32, 32, 32),
                            colorkey=game_constants.COLOR_COLORKEY)))
                terrain[x][y].passable = False
                terrain[x][y].transparent = False
    return terrain, items, entities, creatures
예제 #21
0
파일: paths.py 프로젝트: ludamad/7DayRL2013
 def nodes(self):
     rr = range(self.path.size())
     return [ Pos( *libtcod.path_get(self.path, i) ) for i in rr ]
예제 #22
0
파일: util.py 프로젝트: pom2ter/immortal
def render_map():
	# recompute FOV if needed (the player moved or something)
	libtcod.console_rect(0, game.MAP_X, game.MAP_Y, game.MAP_WIDTH, game.MAP_HEIGHT, True)
	if game.fov_recompute:
		find_map_viewport()
		fov_radius()
		initialize_fov(True)
		libtcod.map_compute_fov(game.fov_map, game.char.x, game.char.y, game.FOV_RADIUS, game.FOV_LIGHT_WALLS, game.FOV_ALGO)
		game.fov_recompute = False

	# 'torch' animation
	if game.fov_torch:
		game.fov_torchx += 0.2
		tdx = [game.fov_torchx + 20.0]
		dx = libtcod.noise_get(game.fov_noise, tdx, libtcod.NOISE_SIMPLEX) * 1.5
		tdx[0] += 30.0
		dy = libtcod.noise_get(game.fov_noise, tdx, libtcod.NOISE_SIMPLEX) * 1.5
		di = 0.4 * libtcod.noise_get(game.fov_noise, [game.fov_torchx], libtcod.NOISE_SIMPLEX)

	# go through all tiles, and set their background color according to the FOV
	for y in range(game.MAP_HEIGHT):
		for x in range(game.MAP_WIDTH):
			px = x + game.curx
			py = y + game.cury
			if not libtcod.map_is_in_fov(game.fov_map, px, py):
				if game.draw_map and game.current_map.tile_is_explored(px, py):
					if game.current_map.tile_is_animated(px, py):
						libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['dark_color'], game.current_map.tile[px][py]['dark_back_color'])
					else:
						libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['dark_color'], game.current_map.tile[px][py]['back_dark_color'])
			else:
				if not game.fov_torch:
					if 'animate' in game.current_map.tile[px][py] or 'duration' in game.current_map.tile[px][py]:
						(front, back, game.current_map.tile[px][py]['lerp']) = render_tiles_animations(px, py, game.current_map.tile[px][py]['color'], game.current_map.tile[px][py]['back_light_color'], game.current_map.tile[px][py]['back_dark_color'], game.current_map.tile[px][py]['lerp'])
						libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], front, back)
					elif game.draw_map:
						libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['color'], game.current_map.tile[px][py]['back_light_color'])
				else:
					base = game.current_map.tile[px][py]['back_light_color']
					r = float(px - game.char.x + dx) * (px - game.char.x + dx) + (py - game.char.y + dy) * (py - game.char.y + dy)
					if r < game.SQUARED_TORCH_RADIUS:
						l = (game.SQUARED_TORCH_RADIUS - r) / game.SQUARED_TORCH_RADIUS + di
						if l < 0.0:
							l = 0.0
						elif l > 1.0:
							l = 1.0
						base = libtcod.color_lerp(base, libtcod.gold, l)
					libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['color'], base)
				if not game.current_map.tile_is_explored(px, py):
					game.current_map.tile[px][py].update({'explored': True})

	# draw all objects in the map (if in the map viewport), except the player who his drawn last
	for obj in reversed(game.current_map.objects):
		if obj.y in range(game.cury, game.cury + game.MAP_HEIGHT) and obj.x in range(game.curx, game.curx + game.MAP_WIDTH) and game.current_map.tile_is_explored(obj.x, obj.y) and obj.name != 'player':
			if game.draw_map and obj.entity is not None:
				if libtcod.map_is_in_fov(game.fov_map, obj.x, obj.y) and not obj.entity.is_identified():
					skill = game.player.find_skill('Mythology')
					if (game.player.skills[skill].level * 0.8) + 20 >= roll_dice(1, 100):
						obj.entity.flags.append('identified')
						game.message.new('You properly identify the ' + obj.entity.unidentified_name + ' as ' + obj.entity.get_name(True) + '.', game.turns)
						game.player.skills[skill].gain_xp(3)
			if obj.entity is not None and not obj.entity.is_identified():
				obj.draw(game.con, libtcod.white)
			else:
				obj.draw(game.con)
	game.char.draw(game.con)
	libtcod.console_blit(game.con, 0, 0, game.MAP_WIDTH, game.MAP_HEIGHT, 0, game.MAP_X, game.MAP_Y)
	game.draw_map = False

	# move the player if using mouse
	if game.mouse_move:
		if mouse_auto_move() and not libtcod.path_is_empty(game.path):
			game.char.x, game.char.y = libtcod.path_walk(game.path, True)
			game.fov_recompute = True
			game.player_move = True
		else:
			items_at_feet()
			game.mouse_move = False

	# check where is the mouse cursor if not in the act of moving while using the mouse
	if not game.mouse_move:
		(mx, my) = (game.mouse.cx - game.MAP_X, game.mouse.cy - 1)
		px = mx + game.curx
		py = my + game.cury
		game.path_dx = -1
		game.path_dy = -1
		if my in range(game.MAP_HEIGHT) and mx in range(game.MAP_WIDTH):
			libtcod.console_set_char_background(0, mx + game.MAP_X, my + 1, libtcod.white, libtcod.BKGND_SET)
			if game.current_map.tile_is_explored(px, py) and not game.current_map.tile_is_blocked(px, py):
				game.path_dx = px
				game.path_dy = py
				if game.mouse.lbutton_pressed:
					target = [obj for obj in game.current_map.objects if obj.y == py and obj.x == px and obj.entity]
					if target:
						mouse_auto_attack(px, py, target[0])
					else:
						game.mouse_move = mouse_auto_move()
				# draw a line between the player and the mouse cursor
				if not game.current_map.tile_is_blocked(game.path_dx, game.path_dy):
					libtcod.path_compute(game.path, game.char.x, game.char.y, game.path_dx, game.path_dy)
					for i in range(libtcod.path_size(game.path)):
						x, y = libtcod.path_get(game.path, i)
						if (y - game.cury) in range(game.MAP_HEIGHT) and (x - game.curx) in range(game.MAP_WIDTH):
							libtcod.console_set_char_background(0, game.MAP_X + x - game.curx, game.MAP_Y + y - game.cury, libtcod.desaturated_yellow, libtcod.BKGND_SET)

	libtcod.console_set_default_foreground(0, libtcod.light_yellow)
	libtcod.console_print_rect(0, game.MAP_X, game.MAP_Y, game.MAP_WIDTH - 18, game.MAP_HEIGHT, get_names_under_mouse())
	if game.debug.enable:
		libtcod.console_print_ex(0, game.MAP_X + game.MAP_WIDTH - 1, game.MAP_Y, libtcod.BKGND_NONE, libtcod.RIGHT, str(game.gametime.hour) + ':' + str(game.gametime.minute).rjust(2, '0') + ' (%3d fps)' % libtcod.sys_get_fps())
	if game.hp_anim:
		render_floating_text_animations()