def __init__(self,x,y, level=1): POI.__init__(self,x,y,libtcod.Color(libtcod.random_get_int(0,50,255),libtcod.random_get_int(0,0,100),libtcod.random_get_int(0,100,150)), "#") self.level = level self.exp = 0 self.floors = [] self.generate_floors() print "dungeon!"
def pickGeneratedResources(self, resource_list): limit = len(resource_list) - 1 #selections = {} print self.name quantity_resources = libtcod.random_get_int(0, 2, 6) temp = [] for n in range(quantity_resources): resource = resource_list[libtcod.random_get_int(0, 0, limit)] temp.append(resource) #now consolidate so there is just one instance of a resource. for resource in resource_list: count = 0 for test_for in temp: if test_for == resource: count += 1 self.producing[resource] = [resource, count] print "produces:-" for resource in self.producing: if self.producing[resource][1] > 0: print resource + str(self.producing[resource][1]) print "\n" self.findDesiredResources()
def place_monsters(room): #choose random number of monsters num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): #choose random spot for this monster 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 is_blocked(x, y): i = libtcod.random_get_int(0, 0, 100) if i < 20: #create a teacher teacher_ai = mods.Teacher() monster = Object(x, y, 'T', 'teacher', libtcod.light_blue, blocks=True, ai=teacher_ai) elif i < 80: #80% chance of getting a child #create a child child_fighter = mods.Fighter(hp=3, defense=0, power=1, on_death=mods.monster_death) child_ai = mods.BasicMonster() monster = Object(x, y, 't', 'toddler', libtcod.light_pink, blocks=True, fighter=child_fighter, ai=child_ai) elif i < 90: #create a bully bully_fighter = mods.Fighter(hp=5, defense=1, power=2, on_death=mods.monster_death) bully_ai = mods.BasicMonster() monster = Object(x, y, 'B', 'bully', libtcod.light_green, blocks=True, fighter=bully_fighter, ai=bully_ai) else: #create a smart bully bully_fighter = mods.Fighter(hp=5, defense=1, power=3, on_death=mods.monster_death) bully_ai = mods.SmartMonster() monster = Object(x, y, 'B', 'smart bully', libtcod.dark_green, blocks=True, fighter=bully_fighter, ai=bully_ai) things.append(monster)
def interact(self, interlocutor): if self.dead is True: return if self.hp <= 0: self.dead = True return if interlocutor.name != "You": return #We're not interacting with the player for some reason. This is not good. #See if we hit the enemy attacker_hit_try = libtcod.random_get_int(0, 0, interlocutor.attack) + interlocutor.attack defender_dodge_try = libtcod.random_get_int(0, 0, self.defense) + self.defense hit_enemy = False damage_enemy = 0 if (attacker_hit_try > defender_dodge_try): hit_enemy = True #See how much we damage the enemy damage_enemy = (attacker_hit_try - defender_dodge_try) + libtcod.random_get_int(0,0,interlocutor.attack) else: hit_enemy = False #Deal the damage and report if hit_enemy: self.hp -= damage_enemy message(interlocutor.name + " hit " + self.name + " for " + str(damage_enemy) + " hit points.", libtcod.green) else: message(interlocutor.name + " missed " + self.name + ".", color_ui_text)
def make_map(): global map, player # fill map with blocked tiles map = [[Tile(True) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] # iterate until max number of rooms, assigning random coordinates and size rooms = [] num_rooms = 0 for r in range(MAX_ROOMS): # random width and height w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) # random position without going out of bounds of the map 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(x, y, w, h) # check if other rooms intersect with this one failed = False for other_room in rooms: if new_room.intersect(other_room): failed = True break if not failed: # there are no intersections, this room is valid # draw room to map tiles create_room(new_room) # find center coordinates of room (new_x, new_y) = new_room.center() if num_rooms == 0: # the first room, where player starts player.x = new_x player.y = new_y else: # for all rooms after the first # connect it to previous room with a tunnel # center coords of previous room (prev_x, prev_y) = rooms[num_rooms - 1].center() # coin toss: horizontal or vertical first? if libtcod.random_get_int(0, 0, 1) == 1: # horizontal, then vertical create_h_tunnel(prev_x, new_x, prev_y) create_v_tunnel(prev_y, new_y, new_x) else: # vertical, then horizontal create_v_tunnel(prev_y, new_y, prev_x) create_h_tunnel(prev_x, new_x, new_y) # add contents to room (monsters etc) place_objects(new_room) # append new rooms to list rooms.append(new_room) num_rooms += 1
def make_map(): global map, objects #the list of objects with just the player objects = [player] player.x = MAP_WIDTH / 2 player.y = MAP_HEIGHT / 2 myrng = libtcod.random_new(123) noise2d = libtcod.noise_new(2,libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY, myrng) libtcod.noise_set_type(noise2d, libtcod.NOISE_PERLIN) #fill map with "normal" tiles map = [[Tile(False, libtcod.light_gray) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] #add color for y in range(MAP_HEIGHT): for x in range(MAP_WIDTH): value = int((libtcod.noise_get_fbm(noise2d,[x/float(MAP_WIDTH),y/float(MAP_HEIGHT)],32) + 1) * 96 ) map[x][y] = Tile(False, libtcod.Color(value,value,value)) r = [libtcod.random_get_int(0, CRATER_MIN_SIZE, (CRATER_MIN_SIZE + (CRATER_MAX_SIZE - CRATER_MIN_SIZE) * (MAX_CRATERS - i)**2/(MAX_CRATERS**2)) ) for i in range(MAX_CRATERS)] r.sort(reverse=True) for i in range(MAX_CRATERS): x = libtcod.random_get_int(0, 0, MAP_WIDTH - 1) y = libtcod.random_get_int(0, 0, MAP_HEIGHT - 1) # r = libtcod.random_get_int(0, CRATER_MIN_SIZE, (CRATER_MIN_SIZE + (CRATER_MAX_SIZE - CRATER_MIN_SIZE) * (MAX_CRATERS - i)/MAX_CRATERS) ) make_crater(x, y, r[i]) spawn_silicon(noise2d)
def melee_attack(attacker, defender): # miss chance if Combat.melee_hit_roll(attacker, defender): if Combat.melee_block_roll(attacker, defender): # damage spread i, d = divmod(attacker.fighter.power / 3, 1) # raw damage attacker_power = attacker.fighter.power * ( 0.8 + 0.05 * attacker.fighter.power) raw_damage = attacker_power + libtcod.random_get_int( 0, int(-i), int(i)) # amplification sources amp = 0 # armor reduction die = libtcod.random_get_int(0, 0, 20) if die + defender.fighter.fighting > 2 * attacker.fighter.power: # target is strong defender reduction = 0.6 * defender.fighter.armor + 0.03 * defender.fighter.shielding else: reduction = 0.35 * defender.fighter.armor + 0.03 * defender.fighter.shielding # damage after modifiers damage = int(round(raw_damage - reduction) * (1 + amp)) if damage > 0: defender.fighter.take_damage(damage) if attacker.fighter.lifesteal > 0: attacker.fighter.heal(attacker.fighter.lifesteal) return CombatResults.HIT else: return CombatResults.ARMOR else: return CombatResults.BLOCK else: return CombatResults.MISS
def make_rivers(): starty = libtcod.random_get_int(0, 1, config.MAP_HEIGHT-1) startx = 0 #Drunkard's Walk with double weight to move east x = startx y = starty while 1 <= x <= config.MAP_WIDTH-1 and 1 <= y <= config.MAP_HEIGHT-1: #place water tile if not config.map[x][y].water: pool_component = Pool(water=True) pool_instance = game.Object(x, y, 'w', 'a pool of water', libtcod.Color(52,108,105), pool=pool_component) config.objects.append(pool_instance) config.map[x][y].blocked = False config.map[x][y].block_sight = False config.map[x][y].water = True walk = libtcod.random_get_int(0, 0, 5) if walk == 0: #go north y -= 1 elif walk == 1: #go south y += 1 elif walk == 2: #go west x -= 1 else: #go east, 2x chance x += 1
def attack(self, target): #a simple formula for attack damage hit_power = libtcod.random_get_int(0, 0, self.power) hit_defense = libtcod.random_get_int(0, 0, target.fighter.defense) damage = hit_power - hit_defense if (self.owner.is_player): attack_word = libtcod.random_get_int(0, 0, len(player_attacks) - 1) else: attack_word = libtcod.random_get_int(0, 0, len(enemy_attacks) - 1) if damage > 0: #make the target take some damage if (self.owner.is_player): draw.message('You ' + player_attacks[attack_word] + ' the ' + target.name + '.') else: draw.message('The ' + self.owner.name + ' ' + enemy_attacks[attack_word] + ' you. It hurts.') target.fighter.take_damage(damage) # notify other visible objects about attack if (self.owner.visible): self.owner.notify_visible('damage') else: if (self.owner.is_player): draw.message('You ' + player_attacks[attack_word] + ' the ' + target.name + ' but it has no effect!') else: draw.message('The ' + self.owner.name + ' ' + enemy_attacks[attack_word] + ' you but it has no effect!') # notify other visible objects about attack if (self.owner.visible): self.owner.notify_visible('attack')
def ranged_attack(attacker, defender): if Combat.ranged_hit_roll(attacker, defender): if Combat.ranged_block_roll(attacker, defender): # damage spread i, d = divmod(attacker.fighter.power / 3, 1) # raw damage attacker_power = attacker.fighter.power * (0.7 + 0.07*attacker.fighter.archery) + \ attacker.fighter.archery/2 raw_damage = attacker_power + libtcod.random_get_int(0, -i, i) # amplification sources amp = sum(equipment.damage_amp_bonus for equipment in get_all_equipped(attacker)) # armor reduction die = libtcod.random_get_int(0, 0, 20) if die + defender.fighter.shielding > attacker.fighter.archery + attacker.fighter.power: # target is strong defender reduction = 0.5 * defender.fighter.armor + 0.03 * defender.fighter.shielding else: reduction = 0.2 * defender.fighter.armor + 0.03 * defender.fighter.shielding # damage after modifiers damage = int(round(raw_damage - reduction) * (1 + amp)) if damage > 0: defender.fighter.take_damage(damage) return CombatResults.HIT else: return CombatResults.ARMOR else: return CombatResults.BLOCK else: return CombatResults.MISS
def rand_gaussian_d20(rerolls = 0): rollResult = 0 rollNo = 0 if rerolls >= 0: while rollNo < rerolls + 1: roll1 = libtcod.random_get_int(0, 1, 20) roll2 = libtcod.random_get_int(0, 1, 20) result = (roll1 + roll2) / 2 if result > rollResult: rollResult = result rollNo += 1 else: while rollNo < abs(rerolls) + 1: roll1 = libtcod.random_get_int(0, 1, 20) roll2 = libtcod.random_get_int(0, 1, 20) result = (roll1 + roll2) / 2 if rollNo == 0: rollResult = result elif result < rollResult: rollResult = result rollNo += 1 return rollResult
def place_objects(room): # choose random number of monsters num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): #choose random spot for this monster x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) #only place it if the tile is not blocked if not is_blocked(x, y): choice = libtcod.random_get_int(0, 0, 100) if choice < 20: # create a bat fighter_component = Fighter(hp=4, defense=1, power=1) ai_component = BasicMonster() monster = Object(x, y, 'w', 'bat', libtcod.light_yellow, blocks=True, fighter=fighter_component, ai=ai_component) elif choice < 20 + 40: # create a troll fighter_component = Fighter(hp=12, defense=1, power=4) ai_component = BasicMonster() monster = Object(x, y, 'T', 'troll', libtcod.dark_violet, blocks=True, fighter=fighter_component, ai=ai_component) else: # create a zombie fighter_component = Fighter(hp=5, defense=0, power=3) ai_component = BasicMonster() monster = Object(x, y, 'Z', 'zombie', libtcod.desaturated_green, blocks=True, fighter=fighter_component, ai=ai_component) objects.append(monster)
def place_objects(room): # maximum number of monsters per room max_monsters = from_dungeon_level([[2, 1], [3, 4], [5, 6]]) # chance of each monster monster_chances = { 'orc': 80, 'troll': from_dungeon_level([[15, 3], [30, 5], [60, 7]]) } # monster_chances = {'orc': 80, 'troll': 20} monster_creators = {'orc': o.create_orc, 'troll': o.create_troll} # choose random number of monsters num_monsters = libtcod.random_get_int(0, 0, max_monsters) for i in range(num_monsters): # choose random spot for this monster x = libtcod.random_get_int(0, room.x1 + 1, room.x2 - 1) y = libtcod.random_get_int(0, room.y1 + 1, room.y2 - 1) choice = random_choice(monster_chances) monster = monster_creators[choice](x, y) # only place it if the tile is not blocked if not o.is_blocked(x, y, tile_map, objects): objects.append(monster) # place the items place_items(room)
def place_objects(zone, room, max_monsters, objects): """Places a random number n monsters (0 < n < max_monsters) in the provided room, appending them to objects. Modifies objects. Returns nothing. """ # Choose a random number of monsters num_monsters = libtcod.random_get_int(0, 0, max_monsters ) for i in range(num_monsters): # Choose random spot for monster x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) # Only place if the location isn't blocked if not classes.is_blocked(zone, objects, x, y): if libtcod.random_get_int(0, 0, 100) < 80: #80% Chance of Orc # Create an Orc fighter_comp = classes.Fighter(hp=10, defense=0, power=3, death_func=partial(monster_death, obj_list=objects)) ai_comp = classes.MonsterBasic() monster = classes.Object("Orc", x, y, 'o', libtcod.desaturated_green, fighter=fighter_comp, ai=ai_comp) else: #create a Troll fighter_comp = classes.Fighter(hp=16, defense=1, power=4, death_func=partial(monster_death, obj_list=objects)) ai_comp = classes.MonsterBasic() monster = classes.Object("Troll", x, y, 'T', libtcod.darker_green, fighter=fighter_comp, ai=ai_comp) objects.append(monster)
def make_map(): global map #fill map with unblocked tiles map = [[ Tile(True) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] rooms = [] num_rooms = 0 for r in range(MAX_ROOMS): #random widths and heights w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) #random postion within the map 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(x, y, w, h) failed = False for other_room in rooms: if new_room.intersect(other_room): failed =True break if not failed: #this means their is no intersections so the room is valid #'paint it' to the new maps tiles create_room(new_room) #center coordinates of new room, will be useful later (new_x, new_y) = new_room.center() room_no = Object(new_x, new_y, chr(65+num_rooms), libtcod.white) objects.insert(0, room_no) if num_rooms == 0: #this is the first room where the player starts player.x = new_x player.y = new_y else: #all rooms after the first #conect it to the previous room with a tunnel #center coodinates of previous room (prev_x, prev_y) =rooms[num_rooms-1].center() if libtcod.random_get_int(0, 0, 1) == 1: #first move horizontally then vertiacally create_h_tunnel(prev_x, new_x, prev_y) create_v_tunnel(prev_y, new_y, new_x) else: #first move vertically then horzontally create_v_tunnel(prev_y, new_y, prev_x) create_h_tunnel(prev_x, new_x, new_y) #finally append new room to list rooms.append(new_room) num_rooms += 1
def make_pool(): w = libtcod.random_get_int(0, 10, 16) h = libtcod.random_get_int(0, 10, 16) x = libtcod.random_get_int(0, 0, MAP_WIDTH - w) y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h) new_room = Rect(x, y, w, h) create_pool(new_room)
def generate_level_map(): levelmap = [[ tile.Tile(True) for y in xrange(MAP_HEIGHT) ] for x in xrange(MAP_WIDTH) ] levelmapobjs = [] num_generated = 0 rects = [] for x in xrange(MAX_GENERATIONS): w = libtcod.random_get_int(0, GEN_MIN_SIZE, GEN_MAX_SIZE) h = libtcod.random_get_int(0, GEN_MIN_SIZE, GEN_MAX_SIZE) x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1) y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1) new_rect = rect.Rect(x, y, w, h) draw_rect(new_rect, levelmap) num_generated += 1 """ Chance of generating an overworld object. pretty low odds. """ chance = libtcod.random_get_int(0, 0, 100) if chance > 85: obj = generate_overworld_object(x, y) obj.blocked = True levelmapobjs.append(obj) return levelmap, levelmapobjs
def restart_game(): global snake while True: startX = libtcod.random_get_int(0, 5, SCREEN_WIDTH - 5) startY = libtcod.random_get_int(0, 5, SCREEN_HEIGHT - 5) if not gamemap[startY][startX].blocked: break #make the snake snake = [] obj = snake_parts(startX, startY, '@', 'head', libtcod.white, True) snake.append(obj) for i in range(initSnakeLen): obj = snake_parts(startX, startY, '#', 'body', libtcod.white, True) snake.append(obj) food = [] obj = mob(40, 40, '%', food, libtcod.dark_yellow) food.append(obj) define_map() status = 'newgame' oldX = 0 oldY = 0
def _place_random_creatures(new_map, player): for r_count in range(0, RUSALKA_GOAL): while True: r_pos = algebra.Location( libtcod.random_get_int(new_map.rng, new_map.pool_x, new_map.width - 3), libtcod.random_get_int(new_map.rng, 3, new_map.height - 3)) if new_map.terrain[r_pos.x][r_pos.y] != map.TERRAIN_WALL: break # TODO: can we ensure this doesn't block the passage? #for x in range(r_pos.x-2, r_pos.x+3): # for y in range(r_pos.y-2, r_pos.y+3): # if new_map.terrain[x][y] == map.TERRAIN_FLOOR: # new_map.terrain[x][y] = map.TERRAIN_WATER mob = bestiary.rusalka(new_map, r_pos, player) _new_equipment(mob, miscellany.tortoiseshell_comb()) for vc_count in range(0, VODANYOI_CLUSTER_GOAL): while True: vc_pos = algebra.Location( libtcod.random_get_int(new_map.rng, new_map.pool_x, new_map.width - 3), libtcod.random_get_int(new_map.rng, 3, new_map.height - 3)) if new_map.terrain[vc_pos.x][vc_pos.y] == map.TERRAIN_FLOOR: break _place_vodanyoi_cluster(new_map, player, vc_pos)
def mpd_setCornerAltitudes(_map, minAlt, maxAlt): print('Map w', _map.width, 'h', _map.height) _map.setHeight(0, 0, tcod.random_get_int(0,minAlt, maxAlt)) _map.setHeight(_map.width - 1, 0, tcod.random_get_int(0,minAlt, maxAlt)) _map.setHeight(_map.width - 1, _map.height - 1, tcod.random_get_int(0,minAlt, maxAlt)) _map.setHeight(0, _map.height - 1, tcod.random_get_int(0,minAlt, maxAlt))
def place_objects(room): """ Places objects within the specified room. TODO: Add generic support for which objects. """ # Init a random number of monsters in the room from 0 to MAX_ROOM_MONSTERS (3) num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) if not is_blocked(x, y): # the likely hood of this is 80% if libtcod.random_get_int(0, 0, 100) < 80: # creates an orc object monster monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green, blocks=True) else: # create a troll monster = Object(x, y, 'T', 'troll', libtcod.darker_green, blocks=True) #append monsters generated to list objects.append(monster)
def generate_random_item(x, y): item = None if libtcod.random_get_int(0, 0, 100) < 65: #create candy item_comp = mods.Item('candy') item = Object( x, y, '!', candy_names[libtcod.random_get_int(0, 0, len(candy_names)) - 1], libtcod.violet, item=item_comp) else: #create toy item_comp = mods.Item('toy') item = Object(x, y, ':', toy_names[libtcod.random_get_int(0, 0, len(toy_names)) - 1], libtcod.blue, item=item_comp) things.append(item) item.send_to_back() #items appear below other objects
def spawn_mobs(map): """ | Spawns randomly distributed mobs. Mobs spawn in packs. | The count and type of mobs is determined by the dungeon level. """ numberMobs = [] for moblevel in range(7): numberMobs.append(chances(moblevel, map.owner.maps.index(map)+1)) #Eliminate level 0 Mobs numberMobs.pop(0) #go through all the mob levels for mobcount in numberMobs: currentLevelMobs = gvar.mobdb[str(numberMobs.index(mobcount)+1)] #Mob Count is +-2 of function value mobcount = libtcod.random_get_int(0, mobcount-2, mobcount+2) #spawn packs of mobs until the count is depleted while mobcount != 0: #get random mob of this level mobToSpawn = currentLevelMobs[libtcod.random_get_int(0, 0, len(currentLevelMobs)-1)] packSize = libtcod.random_get_int(0,mobToSpawn["packsize"][0], mobToSpawn["packsize"][1]) if packSize > mobcount: packSize = mobcount #choose random room room = map.random_room() #choose random spot for this pack (x, y) = room.random_spot() while map.is_blocked(x, y, ai=True): (x, y) = room.random_spot() place_mob_pack(map, x, y, mobToSpawn, packSize) mobcount -= packSize
def new_split(self, rect): if rect.w > MIN_BSP_SIZE * 2 and rect.h > MIN_BSP_SIZE * 2: if utils.flip() and rect.x + rect.w / 2 + MIN_BSP_SIZE < len( self.map) and rect.y + rect.h / 2 + MIN_BSP_SIZE < len(self.map[0]): x = libtcod.random_get_int(0, rect.x + MIN_BSP_SIZE, rect.x + rect.w - MIN_BSP_SIZE) w = (rect.x + rect.w) - x baby = Rect(rect.w - w, rect.h, rect.x, rect.y) baby.bsp(rect) baby_2 = Rect(w - 1, rect.h, x, rect.y) baby_2.bsp(rect) rect.babies.append(baby) rect.babies.append(baby_2) else: y = libtcod.random_get_int(0, rect.y + MIN_BSP_SIZE, rect.y + rect.h - MIN_BSP_SIZE) h = (rect.y + rect.h) - y baby = Rect(rect.w, rect.h - h, rect.x, rect.y) baby.bsp(rect) baby_2 = Rect(rect.w, h - 1, rect.x, y) baby_2.bsp(rect) rect.babies.append(baby) rect.babies.append(baby_2) else: rect.end = True for baby in rect.babies: if baby.end != True: self.new_split(baby)
def generate_room(self, map_x_length, map_y_length, no_of_intersects, room_min_size, room_max_size): #chooses random coords for the room and defines the shape of the room global current_rooms #random width and height w = libtcod.random_get_int(0,room_min_size, room_max_size) h = libtcod.random_get_int(0,room_min_size, room_max_size) #random position in bounds on the map x = libtcod.random_get_int(0,0,map_x_length - w - 1) y = libtcod.random_get_int(0,0,map_y_length - h - 1) #makes the room new_room = Rect(x,y,w,h) #check other rooms for an intersection failed = False room_intersects = 0 for other_room in current_rooms: if new_room.intersect(other_room): room_intersects +=1 if room_intersects >= no_of_intersects: failed = True break break if not failed: #not over max number of intersections, so clear to build self.create_room(new_room) return new_room
def place_objects(room): num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): #pick a random location for object generation x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) #uses option b to create 4 monster entities based on 20/40/10/30% distribution #checks to see if a tile is blocked. if not, step into these choices: if not is_blocked(x, y): choice = libtcod.random_get_int(0, 0, 100) if choice < 20: fighter_component = Fighter(hp=10, defense=0, power=3, death_function=monster_death) ai_component = BasicMonster() monster = Object(x, y, 'h', 'human', libtcod.desaturated_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice < 20+40: fighter_component = Fighter(hp=15, defense=0, power=4, death_function=monster_death) ai_component = BasicMonster() monster = Object(x, y, 'o', 'orc', libtcod.orange, blocks=True, fighter=fighter_component, ai=ai_component) elif choice < 20+40+10: fighter_component = Fighter(hp=20, defense=0, power=5, death_function=monster_death) ai_component = BasicMonster() monster = Object(x, y, 'd', 'dragon', libtcod.red, blocks=True, fighter=fighter_component, ai=ai_component) else: fighter_component = Fighter(hp=25, defense=0, power=6, death_function=monster_death) ai_component = BasicMonster() monster = Object(x, y, 'T', 'troll', libtcod.green, blocks=True, fighter=fighter_component, ai=ai_component) objects.append(monster)
def moveai (self): #behavior for monster movement when a direct line to the player is not available not_moved = True while not_moved: direction = libtcod.random_get_int(0,1,5) #pick a random direction if direction == 1: #north if not is_blocked(self.x, self.y - 1) and (player.distance(self.x, self.y - 1) <= self.distance_to(player)): self.y -= 1 not_moved = False elif direction == 2: #east if not is_blocked(self.x + 1, self.y) and (player.distance(self.x + 1, self.y) <= self.distance_to(player)): self.x += 1 not_moved = False elif direction == 3: #south if not is_blocked(self.x, self.y + 1) and (player.distance(self.x, self.y + 1) <= self.distance_to(player)): self.y += 1 not_moved = False elif direction == 4: #west if not is_blocked(self.x - 1, self.y) and (player.distance(self.x - 1, self.y) <= self.distance_to(player)): self.x -= 1 not_moved = False else: #randomly move in some direction if the space is clear, or else wait a turn if it is not. dx = libtcod.random_get_int(0, -1, 1) dy = libtcod.random_get_int(0, -1, 1) if not is_blocked(self.x + dx, self.y): self.x = self.x + dx if not is_blocked(self.x, self.y + dy): self.y = self.y + dy not_moved = False
def takeTurn(self, sightedCreatures): targetCreature = None for creature in sightedCreatures: if self.owner.isHostile(creature): targetCreature = creature if self.owner.canAttack(creature): self.owner.attack(creature, self.owner.weapon) return else: self.owner.chase(targetCreature.x, targetCreature.y, self.theMap) return #if targetCreature: #if self.owner.canAttack(targetCreature): # self.owner.attack(targetCreature, self.owner.weapon) # return #else: # self.owner.chase(targetCreature.x, targetCreature.y) # return # no hostile creature found; wander around #50% chance of not moving anywhere if libtcod.random_get_int(0, 0, 100) > 50: return else: self.owner.moveOrAttack(libtcod.random_get_int(0,0,1), libtcod.random_get_int(0,0,1), self.theMap) return
def attack(self, targetCreature, weapon): attack = libtcod.random_get_int(0, 1, 20) damage = 0 if attack == 0: #TODO: handle critical miss pass elif attack >= 20 - weapon.criticalThreat: #TODO: handle critical hit pass else: attack = attack + weapon.attackBonus + self.stats.getStrBonus() if attack >= targetCreature.armorClass: #hit! damage=libtcod.random_get_int(0, weapon.minDamage, weapon.maxDamage) damage=damage + self.stats.getStrBonus() print ('The '+ self.name+' hits the '+ targetCreature.name+' for '+str(damage)) else: #TODO: handle miss pass targetCreature.hp = targetCreature.hp - damage if targetCreature.hp < 1: targetCreature.blocks = False targetCreature.isDead = True targetCreature.color = DEAD_COLOR print("The "+targetCreature.name+" died!")
def construct_objects(self): stair = entities.Object(self.up[0], self.up[1], char="<", name="stair", colour=libtcod.purple, blocks=False, always_visible=False) self.objects.append(stair) stair = entities.Object(self.down[0], self.down[1], char=">", name="stair", colour=libtcod.red, blocks=False, always_visible=False) self.objects.append(stair) if len(self.rects) > 0: room = self.rects[libtcod.random_get_int(0, 0, len(self.rects) - 1)] item = entities.Item() potion = entities.Object( libtcod.random_get_int(0, room.x, room.x + room.w - 2), libtcod.random_get_int(0, room.y, room.y + room.h - 2), char="!", name="potion", colour=libtcod.orange, blocks=False, always_visible=False, item=item) self.objects.append(potion)
def make_sanctum(): #create a predefined level, which we will call the sanctum global map, player, objects, stairs, up_stairs, floors, boss objects = [player] map = [[Tile(True) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] broom = Rect(20, 20, 40, 10) create_room(broom) #placing the player player.x = 40 player.y = 25 #let the player know that shit's getting real message("Welcome to the Sanctum! The Amulet is here somewhere...", libtcod.yellow) #the stairs up_stairs = Object(player.x, player.y, "<", "up stairs", libtcod.white, always_visible = True) stairs = Object(0, 0, ">", "TEEHEE", libtcod.black, always_visible = True) objects.append(up_stairs) objects.append(stairs) send_to_back(up_stairs) altar_x = libtcod.random_get_int(0, 21, 59) altar_y = libtcod.random_get_int(0, 21, 29) #the boss ai_component = BasicMonster() fighter_component = Fighter(hp = 100, defense = 5, power = 15, xp = 300, death_function = monster_death) monster = Object(altar_x, altar_y, '&', "sanctum guardian", libtcod.dark_flame, blocks = True, fighter = fighter_component, ai = ai_component) objects.append(monster) #the Amulet equipment_component = Equipment(slot = 'neck') amulet = Object(altar_x, altar_y, "*", "amulet", libtcod.azure, equipment = equipment_component) objects.append(amulet) send_to_back(amulet) #the altar altar = Object(altar_x, altar_y, "_", "bloodstained altar", libtcod.darkest_gray, always_visible = True) objects.append(altar) send_to_back(altar)
def summon_ally(name, duration, x=None, y=None): adj = main.adjacent_tiles_diagonal(player.instance.x, player.instance.y) # Get viable summoning position. Return failure if no position is available if x is None or y is None: summon_positions = [] for tile in adj: if not main.is_blocked(tile[0], tile[1]): summon_positions.append(tile) if len(summon_positions) == 0: ui.message('There is no room to summon an ally here.') return summon_pos = summon_positions[libtcod.random_get_int( 0, 0, len(summon_positions) - 1)] else: summon_pos = (x, y) # Select monster type - default to goblin import monsters if name in monsters.proto.keys(): summon = main.spawn_monster(name, summon_pos[0], summon_pos[1], team='ally') if summon is not None: if summon.behavior is not None: summon.behavior.follow_target = player.instance # Set summon duration summon.summon_time = duration + libtcod.random_get_int( 0, 0, duration) return 'success' else: return 'didnt-take-turn'
def wander(behavior): monster = behavior.owner target = acquire_target(monster) if target is not None: behavior.last_seen_position = target.x, target.y behavior.target = target behavior.wander_path = None return 'acquired-target' else: if behavior.wander_path is None or len(behavior.wander_path) == 0: rand_x = libtcod.random_get_int( 0, min(1, monster.x - 10), max(consts.MAP_WIDTH - 2, monster.x + 10)) rand_y = libtcod.random_get_int( 0, min(1, monster.y - 10), max(consts.MAP_HEIGHT - 2, monster.y + 10)) rand_pos = rand_x, rand_y rand_pos = game.find_closest_open_tile(rand_pos[0], rand_pos[1]) if rand_pos is None: return 'wandered' behavior.wander_path = game.get_path_to_point( (monster.x, monster.y), rand_pos, monster.movement_type, None) if behavior.wander_path is None: return 'wandered' old_pos = monster.x, monster.y next_move = monster.x, monster.y while next_move == old_pos and len(behavior.wander_path) > 0: next_move = behavior.wander_path.pop(0) monster.move(next_move[0] - monster.x, next_move[1] - monster.y) if old_pos == (monster.x, monster.y): monster.behavior.wander_path = None return 'wandered'
def take_turn(self): if self.num_turns > 0: self.owner.creature.move( libtcod.random_get_int(0,-1,1), libtcod.random_get_int(0,-1,1)) self.num_turns -= 1 else: self.owner.ai = self.old_ai game_message( "The creature has broken free!" , constants.COLOR_RED )
def use_bandage(actor): """ First aid skill needs to be at least 2x wounds + 5x bleeding to have a 50-50 chance of making things better, but if so it does quite a lot. """ effective_skill = actor.fighter.skills.get( 'first aid', 0) - actor.fighter.action_penalty difficulty = actor.fighter.wounds + actor.fighter.bleeding * 4 attack_roll = libtcod.random_get_int(0, 1, effective_skill) defense_roll = libtcod.random_get_int(0, 1, difficulty) if defense_roll > attack_roll: log.message("Your efforts don't help.", libtcod.red) return if actor.fighter.bleeding > 0: if actor.fighter.bleeding < attack_roll / 8: attack_roll -= actor.fighter.bleeding * 4 actor.fighter.bleeding = 0 else: attack_roll /= 2 actor.fighter.bleeding /= 2 actor.fighter.wounds = max(actor.fighter.wounds - attack_roll, 0) log.message("You bandage your wounds.")
def use_bandage(actor): """ First aid skill needs to be at least 2x wounds + 5x bleeding to have a 50-50 chance of making things better, but if so it does quite a lot. """ effective_skill = actor.fighter.skills.get('first aid', 0) - actor.fighter.action_penalty difficulty = actor.fighter.wounds + actor.fighter.bleeding * 4 attack_roll = libtcod.random_get_int(0, 1, effective_skill) defense_roll = libtcod.random_get_int(0, 1, difficulty) if defense_roll > attack_roll: log.message("Your efforts don't help.", libtcod.red) return if actor.fighter.bleeding > 0: if actor.fighter.bleeding < attack_roll / 8: attack_roll -= actor.fighter.bleeding * 4 actor.fighter.bleeding = 0 else: attack_roll /= 2 actor.fighter.bleeding /= 2 actor.fighter.wounds = max(actor.fighter.wounds - attack_roll, 0) log.message("You bandage your wounds.")
def place_creatures(self, creature_type, room): creatures = filter(lambda m: m['type'] == creature_type, objects.MONSTER_TEMPLATES) if len(creatures) == 0: return # Random number of creatures max_creatures = from_dungeon_level( self.CREATURE_CHANCES[creature_type], self._game.dungeon_level) num_creatures = libtcod.random_get_int(0, 0, max_creatures) creature_chances = get_spawn_chances(creatures, self._game.dungeon_level) chance = libtcod.random_get_int(0, 1, 100) if chance <= 5: num_creatures = max_creatures * 3 for i in range(num_creatures): # Random position for creature point = room.random_point_inside() if not is_blocked(self.map, self.game_actors, point): choice = random_choice(creature_chances) creature = objects.new_monster(self._game, choice, point) self.game_actors.append(creature)
def place_objects(room): #choose random number of monsters num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): #choose random spot for this monster x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) #only place it if the tile is not blocked if not is_blocked(x, y): # create stairs '''if libtcod.random_get_int(0, 0, 100) < 100: #this is a better way to call this objects.append(Object(x,y, '>', 'stairs', libtcod.grey, blocks=False))''' #stairs= Object(x,y, '>', 'stairs', libtcod.grey, blocks=False) if libtcod.random_get_int(0, 0, 100) < 80: #80% chance of getting an orc #create an orc fighter_component = Fighter(hp=10, defense=0, power=3, xp=0, death_function=monster_death) ai_component = BasicMonster() monster = Object(x, y, '#', 'orc', libtcod.desaturated_green, blocks=True, fighter=fighter_component, ai=ai_component) else: #create a troll fighter_component = Fighter(hp=16, defense=1, power=4, xp=0, death_function=monster_death) ai_component = BasicMonster() monster = Object(x, y, '&', 'troll', libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) objects.append(monster)
def generate_floors(self, level=1, num=5): for ID in range(num): monster_num = libtcod.random_get_int(0, 10, 25) item_num = libtcod.random_get_int(0, 5, 15) a_items = [] a_monst = [] for n in range(monster_num): key = random.choice(MONSTERS[str(self.level)].keys()) mons = MONSTERS[str(self.level)][key] #not finsiehd yet. colour = libtcod.Color(mons["colour"][0], mons["colour"][1], mons["colour"][2]) temp = entities.Object(0, 0, char=mons["char"], name=mons["name"], colour=colour, blocks=False, always_visible=False) a_monst.append(mons) for n in range(item_num): item = random.choice(ITEMS) #colour = libtcod.Color(item["colour"][0],item["colour"][1],item["colour"][2]) #temp = entities.Object(0,0, char=item["char"], name=item["name"], colour=colour, blocks=False, always_visible=False) a_items.append(item) floor = Floor(ID, a_monst, a_items) self.floors.append(floor)
def make_map(): global map, player #fill map with "blocked" tiles map = [[Tile(True) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] rooms = [] num_rooms = 0 for r in range(MAX_ROOMS): #random width and height w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) #random position without going out of the boundaries of the map x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1) y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1) #"Rect" class makes rectangles easier to work with new_room = Rect(x, y, w, h) #run through the other rooms and see if they intersect with this one failed = False for other_room in rooms: if new_room.intersect(other_room): failed = True break if not failed: #this means there are no intersections, so this room is valid #"paint" it to the map's tiles create_room(new_room) #center coordinates of new room, will be useful later (new_x, new_y) = new_room.center() if num_rooms == 0: #this is the first room, where the player starts at player.x = new_x player.y = new_y else: #all rooms after the first: #connect it to the previous room with a tunnel #center coordinates of previous room (prev_x, prev_y) = rooms[num_rooms - 1].center() #draw a coin (random number that is either 0 or 1) if libtcod.random_get_int(0, 0, 1) == 1: #first move horizontally, then vertically create_h_tunnel(prev_x, new_x, prev_y) create_v_tunnel(prev_y, new_y, new_x) else: #first move vertically, then horizontally create_v_tunnel(prev_y, new_y, prev_x) create_h_tunnel(prev_x, new_x, new_y) #finally, append the new room to the list rooms.append(new_room) num_rooms += 1
def RoomCrossCenter(prev_x, prev_y, center_x, center_y): #If previous room is in top left relative to new room if (prev_x < center_x and prev_y < center_y): if libtcod.random_get_int(0, 0, 1) == 1: return (center_x, center_y-2) else: return (center_x-2, center_y) #If room is in bottom right elif (prev_x >= center_x and prev_y >= center_y): if libtcod.random_get_int(0, 0, 1) == 1: return (center_x, center_y+2) else: return (center_x+2, center_y) #If room is in bottom left relative to new room elif (prev_x < center_x and prev_y >= center_y): if libtcod.random_get_int(0, 0, 1) == 1: return (center_x, center_y+2) else: return (center_x-2, center_y) #If old room is in top right elif (prev_x >= center_x and prev_y < center_y): if libtcod.random_get_int(0, 0, 1) == 1: return (center_x, center_y-2) else: return (center_x+2, center_y) else: return (center_x, center_y)
def CreateRandomWalkableCoords(): x = libtcod.random_get_int(0,0,MAP_WIDTH-1) y = libtcod.random_get_int(0,0,MAP_HEIGHT-1) while 'Impassable' in Map[x][y].flags: x = libtcod.random_get_int(0,0,MAP_WIDTH-1) y = libtcod.random_get_int(0,0,MAP_HEIGHT-1) return Coord(x,y,'Coords for ' + str(x) + ',' + str(y))
def attack(self, target): if self.owner==player: #if player, use player attack stats hitdie = player.stats.hitdie mindmg = player.stats.mindmg maxdmg = player.stats.maxdmg else: #not player, use filler stats hitdie = 2 mindmg = 1 maxdmg = 5 if libtcod.random_get_int(0,1,20) > hitdie: #hit! message('hit!') #determine damage damage = libtcod.random_get_int(0, mindmg, maxdmg) - target.fighter.defense else: #miss! message('miss!') damage = 0 if damage > 0: #make the target take some damage message(self.owner.name.capitalize() + ' attacks ' + target.name + ' for ' + str(damage) + ' hit points.') target.fighter.take_damage(damage) else: message(self.owner.name.capitalize() + ' attacks ' + target.name + ' but it has no effect!')
def take_turn(self,game): self.owner.fighter.ticker.schedule_turn(self.owner.fighter.speed,self.owner) if self.dest and self.owner.distance(self.dest_x,self.dest_y) <= 0: self.dest = False if self.dest and self.owner.distance(self.dest_x,self.dest_y) > 0: self.owner.move_towards(self.dest_x,self.dest_y,game.Map.map,game.objects) if not self.dest: picked = False while not picked: min_x,max_x = self.home_x-self.radius,self.home_x+self.radius min_y,max_y = self.home_y-self.radius,self.home_y+self.radius mx,my = game.Map.MAP_WIDTH,game.Map.MAP_HEIGHT #make sure min and max values are within the boundaries of the map if not min_x <=0 or not min_y <=0 or not max_x >= my or not max_y >= mx: self.dest_x=libtcod.random_get_int(0,min_x+1,max_x-1) self.dest_y=libtcod.random_get_int(0,min_y+1,max_y-1) if not game.Map.map[self.dest_x][self.dest_y].blocked and not self.owner.distance(self.dest_x,self.dest_y) == 0: picked = True self.owner.move_towards(self.dest_x,self.dest_y,game.Map.map,game.objects) if libtcod.map_is_in_fov(game.fov_map, self.owner.x, self.owner.y): self.owner.ai = BasicMonster() self.owner.ai.owner = self.owner
def place_dungeons(self): print 'Placing dungeons....' t0 = libtcod.sys_elapsed_seconds() path = self.set_dijkstra_map() for i in range(game.MAX_THREAT_LEVEL): done = False attempt = 0 while not done and attempt <= 1000: x = libtcod.random_get_int(self.rnd, 0, game.WORLDMAP_WIDTH - 1) y = libtcod.random_get_int(self.rnd, 0, game.WORLDMAP_HEIGHT - 1) cellheight = int(libtcod.heightmap_get_value(game.heightmap, x, y) * 1000) threat = self.set_threat_level(x, y, path) dice = libtcod.random_get_int(self.rnd, 1, 100) if dice <= 65: dtype = 'Dungeon' elif dice <= 95: dtype = 'Cave' else: dtype = 'Maze' if cellheight in range(int(game.terrain['Plains']['elevation'] * 1000), int(game.terrain['High Hills']['maxelev'] * 1000)) and threat == i + 1: self.dungeons.append((len(self.dungeons) + 1, 'Dungeon', 'Dng', x, y, threat + 1, dtype)) done = True attempt += 1 starter_dungeon = libtcod.random_get_int(self.rnd, 1, 4) if starter_dungeon == 1: self.dungeons.append((len(self.dungeons) + 1, 'Starter Dungeon', 'SD', self.player_positionx, self.player_positiony - 1, 1, 'Dungeon')) elif starter_dungeon == 2: self.dungeons.append((len(self.dungeons) + 1, 'Starter Dungeon', 'SD', self.player_positionx + 1, self.player_positiony, 1, 'Dungeon')) elif starter_dungeon == 3: self.dungeons.append((len(self.dungeons) + 1, 'Starter Dungeon', 'SD', self.player_positionx, self.player_positiony + 1, 1, 'Dungeon')) else: self.dungeons.append((len(self.dungeons) + 1, 'Starter Dungeon', 'SD', self.player_positionx - 1, self.player_positiony, 1, 'Dungeon')) t1 = libtcod.sys_elapsed_seconds() print ' done! (%.3f seconds)' % (t1 - t0)
def place_objects(room): # choose random number of monsters num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): # choose random spot for this monster x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) # only place it if the tile is not blocked if not is_blocked(x, y): if libtcod.random_get_int(0, 0, 100) < 80: # 80% chance of getting an orc # create an orc fighter_component = Fighter(hp=10, defense=0, power=3, death_function=monster_death) ai_component = BasicMonster() monster = Object( x, y, "o", "orc", libtcod.desaturated_green, blocks=True, fighter=fighter_component, ai=ai_component ) else: # create a troll fighter_component = Fighter(hp=16, defense=1, power=4, death_function=monster_death) ai_component = BasicMonster() monster = Object( x, y, "T", "troll", libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component ) objects.append(monster)
def place_objects(room): #choose random number of monsters num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): #choose random spot for this monster x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) #only place it if the tile is not blocked if not is_blocked(x, y): if libtcod.random_get_int(0, 0, 100) < 80: #80% chance of getting an orc #create an orc monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green, blocks=True) else: #create a troll monster = Object(x, y, 'T', 'troll', libtcod.darker_green, blocks=True) objects.append(monster)
def make_map(): global map, player # fill map with "blocked" tiles map = [[Tile(True) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] rooms = [] num_rooms = 0 for r in range(MAX_ROOMS): # random width and height w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) # random position without going out of the boundaries of the map x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1) y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1) # "Rect" class makes rectangles easier to work with new_room = Rect(x, y, w, h) # run through the other rooms and see if they intersect with this one failed = False for other_room in rooms: if new_room.intersect(other_room): failed = True break if not failed: # this means there are no intersections, so this room is valid # "paint" it to the map's tiles create_room(new_room) # center coordinates of new room, will be useful later (new_x, new_y) = new_room.center() if num_rooms == 0: # this is the first room, where the player starts at player.x = new_x player.y = new_y else: # all rooms after the first: # connect it to the previous room with a tunnel # center coordinates of previous room (prev_x, prev_y) = rooms[num_rooms - 1].center() # draw a coin (random number that is either 0 or 1) if libtcod.random_get_int(0, 0, 1) == 1: # first move horizontally, then vertically create_h_tunnel(prev_x, new_x, prev_y) create_v_tunnel(prev_y, new_y, new_x) else: # first move vertically, then horizontally create_v_tunnel(prev_y, new_y, prev_x) create_h_tunnel(prev_x, new_x, new_y) # finally, append the new room to the list rooms.append(new_room) num_rooms += 1
def pick_up(self): #add to the player's inventory and remove from the map if len(inventory) >= 26: sarcasm = libtcod.random_get_int(0, 0, 100) if sarcasm <= 20: message('You cannot carry any more items, puny man.', libtcod.dark_lime) elif sarcasm <= 40 and sarcasm > 20: message('Do you really need ' + self.owner.name + '? Cause if you do, you better get rid of some of this other junk.', libtcod.dark_lime) elif sarcasm <= 60 and sarcasm > 40: message('Hoarding is not healthy. You must shed some of your itmes before you can add this one to your horrid collection.', libtcod.dark_lime) elif sarcasm <= 80 and sarcasm > 60: message('You must clear some space in your inventory before you can pick up ' + self.owner.name + '. Perhaps you should experiment with some magic potions?', libtcod.dark_lime) elif sarcasm <= 100 and sarcasm > 80: message('You simply cannot carry anything more. It would be impossible. Even if you were to have the strength of ten men, you could not best the mysterious limit of 26 that plagues all adventurers.', libtcod.dark_lime) else: inventory.append(self.owner) objects.remove(self.owner) sarcasm = libtcod.random_get_int(0, 0, 100) if sarcasm <= 20: message('You got yourself a shiny, new ' + self.owner.name + '. (Okay, maybe it was a little used.)', libtcod.lime) elif sarcasm <= 40 and sarcasm > 20: message('I hope you know what you are doing by picking up ' + self.owner.name + '.', libtcod.lime) elif sarcasm <= 60 and sarcasm > 40: message('You now have a ' + self.owner.name + '. Hooray greed!', libtcod.lime) elif sarcasm <= 80 and sarcasm > 60: message('Pretty sweet ' + self.owner.name + ' you got there.', libtcod.lime) elif sarcasm <= 100 and sarcasm > 80: message('Oh good, you finally got your own ' + self.owner.name + '. Now you can stop borrowing mine.', libtcod.lime)
def choose_armor_material(loot_level=0): roll = libtcodpy.random_get_int(0, 0, min(100 + 30 * loot_level, 150)) if roll > 100: ops = armor_materials.keys() return ops[libtcodpy.random_get_int(0, 0, len(ops) - 1)] else: return ''
def place_objects(room): #choose random number of monsters num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) for i in range(num_monsters): #choose random spot for this monster x = libtcod.random_get_int(0, room.x1, room.x2) y = libtcod.random_get_int(0, room.y1, room.y2) #only place it if the tile is not blocked if not is_blocked(x, y): if libtcod.random_get_int(0, 0, 100) < 50: #50% chance of getting an orc #create an orc fighter_component = Fighter(hp=10, defense=0, power=3, death_function=monster_death, ) ai_component = BasicMonster() #for speed smaller is faster monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green, blocks=True, fighter=fighter_component, ai=ai_component, speed=DEFAULT_SPEED+libtcod.random_get_int(0, -8, -7) ) else: #create a troll fighter_component = Fighter(hp=16, defense=1, power=4, death_function=monster_death, ) ai_component = BasicMonster() monster = Object(x, y, 'T', 'troll', libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component, speed=DEFAULT_SPEED+libtcod.random_get_int(0, 7, 8)) objects.append(monster)
def take_turn(self): if self.num_turns > 0: self.owner.move(libtcod.random_get_int(0, -1, 1), libtcod.random_get_int(0, -1, 1)) self.num_turns -= 1 else: self.owner.ai = self.old_ai message('The ' + self.owner.name + ' is no longer confused!', libtcod.red)
def take_turn(self): if self.num_turns > 0: self.owner.move(libtcod.random_get_int(0, -1, 1), libtcod.random_get_int(0, -1, 1)) self.num_turns += -1 else: self.owner.ai = self.old_ai message('The ' + self.owner.name + ' has shaken off the confusion!', libtcod.light_azure)
def random_point_surrounding(position): p = Position(libtcod.random_get_int(0, position.x - 1, position.x + 1), libtcod.random_get_int(0, position.y - 1, position.y + 1)) while p.x == position.x and p.y == position.y: p = Position(libtcod.random_get_int(0, position.x - 1, position.x + 1), libtcod.random_get_int(0, position.y - 1, position.y + 1)) return p
def make_outdoor_map(): global map # Fill map with "unblocked" tiles data = libtcod.noise_get(height_map, [10, 10]) map = [[Tile(False, data=TILE_TYPE['GRASS_3']) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] for y in range(MAP_HEIGHT): for x in range(MAP_WIDTH): data = libtcod.noise_get(height_map, [x * 0.1, y * 0.1], libtcod.NOISE_PERLIN) # print data if data > 0.2: data = TILE_TYPE['GRASS_1'] elif data < -0.2: data = TILE_TYPE['GRASS_3'] else: data = TILE_TYPE['GRASS_2'] map[y][x].data = data buildings = [] num_buildings = 0 for r in range(MAX_ROOMS): #random width and height w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) #random position without going out of the boundaries of the map x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1) y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1) #"Rect" class makes rectangles easier to work with new_room = Rect(x, y, w, h) #run through the other buildings and see if they intersect with this one failed = False for other_room in buildings: if new_room.intersect(other_room): failed = True break if not failed: #this means there are no intersections, so this room is valid #"paint" it to the map's tiles create_building(new_room) #center coordinates of new room, will be useful later (new_x, new_y) = new_room.center() if num_buildings == 0: #this is the first room, where the player starts at player.x = new_x player.y = new_y # Add some objects to the room place_objects(new_room) #finally, append the new room to the list buildings.append(new_room) num_buildings += 1
def make_map(): global map #fill map with 'unblocked' tiles map = [[ Tile(True) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] rooms = [] num_rooms =0 for r in range(MAX_ROOMS): #random height and width w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_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(x, y, w, h) failed = False for other_room in rooms: if new_room.intersect(other_room): failed = True break if not failed: # if no intersections paint new map tiles create_room(new_room) #add some content to this room place_objects(new_room) (new_x, new_y) = new_room.center() '''room_no = Object(new_x, new_y, chr(65+num_rooms), libtcod.white) objects.insert(0, room_no)''' if num_rooms == 0: player.x = new_x player.y = new_y else: #all rooms after the first: # connect it to the previous with tunnel # center coordinates of previous room (prev_x, prev_y) = rooms[num_rooms-1].center() if libtcod.random_get_int(0, 0, 1) == 1: create_h_tunnel(prev_x, new_x, prev_y) create_v_tunnel(prev_y, new_y, new_x) else: create_v_tunnel(prev_y, new_y, prev_x) create_h_tunnel(prev_x, new_x, new_y) rooms.append(new_room) num_rooms += 1
def make_map(): global tile_map, objects global num_downstairs, num_upstairs objects = [player] rooms = [] num_rooms = 0 num_downstairs = 0 num_upstairs = 0 # fill map with "unblocked" tiles tile_map = [[Tile(blocked=True) for y in xrange(MAP_HEIGHT)] for x in xrange(MAP_WIDTH)] for r in xrange(MAX_ROOMS): # random width and height w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE) 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(x, y, w, h) failed = False if in_map(x, y) and in_map(x + w, y + h): for other_room in rooms: if new_room.intersects(other_room): failed = True break else: failed = True r -= 1 if not failed: create_room(new_room) # add some contents to this room, such as monsters place_objects(new_room) new_x, new_y = new_room.center() if num_rooms == 0: # place character center of first room player.x, player.y = new_room.center() else: # from second room and beyond connect via tunnel prev_x, prev_y = rooms[-1].center() # coin toss (random int either 0 or 1) if libtcod.random_get_int(0, 0, 1) == 1: create_h_tunnel(prev_x, new_x, prev_y) create_v_tunnel(new_x, prev_y, new_y) else: create_v_tunnel(prev_x, prev_y, new_y) create_h_tunnel(prev_x, new_x, new_y) rooms.append(new_room) num_rooms += 1 place_stairs(rooms)