def make_map(self):
'''Generates the map.'''
self.map = [[Tile(True) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)]
# Generate random map
rooms = []
room_count = 0
b_fighter = Fighter(hp=10, defense=5, power=8, death_func=player_death)
self.player = Object(self.con, self, 1, 1, '@', "Player",
libtcod.blue, blocks=True, fighter=b_fighter)
for r in range(MAX_ROOMS):
w = libtcod.random_get_int(0, MIN_ROOM_SIZE, MAX_ROOM_SIZE)
h = libtcod.random_get_int(0, MIN_ROOM_SIZE, MAX_ROOM_SIZE)
# Random 'position'
x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1)
y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1)
new_room = Rect(self.map, x, y, w, h)
new_room.create_room()
failed = False
for room in rooms:
if new_room.intersect(room):
failed = True
break
if not failed:
# No intersections, can safely draw room
new_room.create_room()
(newx,newy) = new_room.center()
if room_count == 0:
# Player starts in the center of the first room
self.player.x = newx
self.player.y = newy
else:
# Connect with previous room's center
(px,py) = rooms[room_count-1].center()
if libtcod.random_get_int(0, 0, 1) == 1:
new_room.create_h_tunnel(px, newx, py)
new_room.create_v_tunnel(py, newy, newx)
else:
new_room.create_v_tunnel(py, newy, px)
new_room.create_h_tunnel(px, newx, newy)
self.insert_objects(new_room)
rooms.append(new_room)
room_count += 1
self.object_list.append(self.player)
self.fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
libtcod.map_set_properties(self.fov_map, x, y, not
self.map[x][y].blocked, not self.map[x][y].block_sight)
def __init__(self, cols, rows):
self.f_color = lt.light_amber
self.f_color_explored = lt.blue
self.b_color = lt.darkest_amber
self.b_color_explored = lt.darker_blue
self.blocked = [[True for x in xrange(cols)] for y in xrange(rows)]
if DEBUG:
self.explored = [[True for x in xrange(cols)] for y in xrange(rows)]
else:
self.explored = [[False for x in xrange(cols)] for y in xrange(rows)]
# Create rooms
rooms = []
for room in xrange(10):
w = lt.random_get_int(0, 8, 25)
h = lt.random_get_int(0, 8, 25)
col = lt.random_get_int(0, 0, cols - w - 1)
row = lt.random_get_int(0, 0, rows - h - 1)
new_room = Rect_Room(col, row, w, h)
# Check for intersections.
failed = False
for other in rooms:
if new_room.intersect(other):
failed = True
break
# Carve out new room.
if not failed:
for col in range(new_room.col1 + 1, new_room.col2):
for row in range(new_room.row1 + 1, new_room.row2):
self.blocked[row][col] = False
# Create tunnel to previous room.
if len(rooms) != 0:
(new_col, new_row) = new_room.center()
(prev_col, prev_row) = rooms[-1].center()
if lt.random_get_int(0, 0, 1) == 1:
self.horizontal_tunnel(prev_col, new_col, prev_row)
self.vertical_tunnel(prev_row, new_row, new_col)
else:
self.vertical_tunnel(prev_row, new_row, prev_col)
self.horizontal_tunnel(prev_col, new_col, new_row)
rooms.append(new_room)
# Create console
self.con = lt.console_new(cols, rows)
# Create FOV map and cache (cache being for the currently dumb algorithm).
self.fov = lt.map_new(cols, rows)
for col in xrange(cols):
for row in xrange(rows):
lt.map_set_properties(self.fov, col, row, not self.blocked[row][col], True)
self.fov_cache = lt.map_new(cols, rows)
lt.map_copy(self.fov, self.fov_cache)
def take_turn(self):
mob = self.owner
if libtcod.map_is_in_fov(self.owner.map.fov_map, mob.x, mob.y):
# Moves towards the player
if mob.distance_to(self.owner.map.player) >= 2:
mob.move_towards(self.owner.map.player.x,
self.owner.map.player.y)
# Mob moving towards player, random growls
chance = libtcod.random_get_int(0, 1, 100)
if chance <= 20:
sfx.play('zombie_a')
elif chance <= 40:
sfx.play('zombie_b')
elif chance <= 60:
sfx.play('zombie_c')
elif self.owner.map.player.fighter.hp > 0:
mob.fighter.attack(self.owner.map.player)
def take_damage(self, damage):
'''Applies damage to the fighter.'''
if damage > 0:
self.hp -= damage
if self.owner.ai:
# It's a zombie, let's randomly choose a hit sfx
chance = libtcod.random_get_int(0, 1, 100)
if chance <= 50:
sfx.play('zombie_hurt_a')
elif chance <= 100:
sfx.play('zombie_hurt_b')
if self.hp <= 0:
func = self.death_func
if func is not None:
func(self.owner)
def insert_objects(self, room):
'''Randomly inserts monsters or items into the room.'''
mob_count = libtcod.random_get_int(0, 0, MAX_ROOM_MOBS)
for i in range(mob_count):
x = libtcod.random_get_int(0, room.x1+1, room.x2-1)
y = libtcod.random_get_int(0, room.y1+1, room.y2-1)
mob_percent = libtcod.random_get_int(0, 0, 100)
if not self.is_blocked(x, y):
if mob_percent < 80:
# Zombie
b_zombie = Fighter(hp=10, defense=5, power=7,
death_func=zombie_a_death)
aic = BasicMob()
mob = Object(self.con, self, x, y, 'z', zombie_title(1),
libtcod.green, True, fighter=b_zombie, ai=aic)
elif mob_percent < 98:
# Zombie Leader
m_zombie = Fighter(hp=15, defense=7, power=7,
death_func=zombie_b_death)
aic = BasicMob()
mob = Object(self.con, self, x, y, 'z', zombie_title(2),
libtcod.red, True, fighter=m_zombie, ai=aic)
else:
# Zombie Boss
a_zombie = Fighter(hp=20, defense=10, power=12,
death_func=zombie_c_death)
aic = BasicMob()
mob = Object(self.con, self, x, y, 'Z', zombie_title(3),
libtcod.violet, True, fighter=a_zombie, ai=aic)
self.object_list.append(mob)
item_count = libtcod.random_get_int(0, 0, MAX_ROOM_ITEMS)
for i in range(item_count):
x = libtcod.random_get_int(0, room.x1+1, room.x2-1)
y = libtcod.random_get_int(0, room.y1+1, room.y2-1)
if not self.is_blocked(x, y):
# we place the items
item = Object(self.con, self, x, y, 'M', 'Medkit', libtcod.orange)
self.object_list.append(item)
item.send_to_back()
