def test_switch_weapon(self): new_entity = Entity("equipswitch", 100) axe = Weapon("skullsplitter", 10, 0.2) bow = Weapon("arrowless bow", 1, 1.0) new_entity.equip_weapon(axe) new_entity.equip_weapon(bow) self.assertEqual(new_entity.weapon.name, bow.name)
def main(): #----------------------------Initialize your storage------------------------------------# if len(sys.argv) < 2: print "Expected: "+str(sys.argv[0])+" <config>" conf = __import__(str(sys.argv[1]), fromlist=["*"]) """Initialize storage plugin""" st = Storage(conf.store_plugin_mod, conf.store_plugin_class) st.connect(conf.store_ip, conf.store_port) """Create a service endpoint for up coming Data""" xeid_key = get_sha256_hash(str(conf.eid_uuid)) xeid = EID(xeid_key, conf.app_proto, conf.transport) #-----------------------Create an entity and store it in registry----------------------# """Create an entity""" xentity = Entity("WathsalaObject", "A bogus document inserted to demonstrate the software", "text/xml", "xyz", "D") """Create an SID string for the entity""" uuid = "50aec6e5-1968-4243-a51c-ab1768a2c514"#uuid.uuid4() sid_str = get_sha256_hash(str(uuid)) xentity.set_sid(sid_str) xjson = xentity.object2json() """Store this entity in author registry""" st.put("wathsala", xjson) """Store this entity's EID under sid_str""" st.put(sid_str, xeid.object2json())
def __init__(self, *args, **kwargs): Server.__init__(self, *args, **kwargs) self.id_inc = 0 self.clients = [] self.entities = [] # Entities that can be hit. self.collided = [] # Entites that hit. self.colliders = [] # Static Objects in space. # Functions for the entities. self.functions = { 'new_id': self.get_id, 'add_entity': self.add_entity, 'remove_entity': self.remove_entity, 'system_size': SYSTEM_SIZE, } # A Planet to respawn at: planet = Entity(self.functions) planet.type = 'planet' self.entities.append(planet)
def test_Entity_attack_with_weapon(self): my_weapon = Weapon("Axe", 31, 0.2) my_Entity = Entity("Ivan", 100) my_Entity.equip_weapon(my_weapon) attack = my_weapon.damage * (1 + my_weapon.critical_strike_percent) true_attack = my_Entity.attack() self.assertEqual(attack, true_attack)
def __init__(self, board): size = 15 x = board.getWidth()/2 - size/2 y = board.getHeight()/2 - size/2 Entity.__init__(self, x, y, size) self.speed = 100 self.dead = False
def update(self, timestep, target): displacementX = target[0]-self.position[0] displacementY = target[1]-self.position[1] distance = math.sqrt(displacementX**2 + displacementY**2) if distance == 0: distance = 1 normalX = displacementX/distance normalY = displacementY/distance accelerationX = normalX*self.maxAcceleration accelerationY = normalY*self.maxAcceleration self.velocity = self.velocity[0]+accelerationX*timestep, self.velocity[1]+accelerationY*timestep angleTo = math.atan2(normalY, normalX)*180/math.pi+180 angleDifference = angleTo - self.angle if angleDifference > 180: angleDifference -= 360 angularAcceleration = angleDifference/180*self.maxAngularAcceleration self.angularVelocity += angularAcceleration*timestep relativeSpeed = self.speed()/self.topSpeed if relativeSpeed > 1: self.velocity = (self.velocity[0]/relativeSpeed, self.velocity[1]/relativeSpeed) if self.angularVelocity > self.topAngularSpeed: self.angularVelocity = self.topAngularSpeed elif self.angularVelocity < -self.topAngularSpeed: self.angularVelocity = -self.topAngularSpeed Entity.update(self, timestep)
def __init__(self, number:int=0, name:str='<Default Company Name>', address:list=list(['<Default Address, line %u>' %(n+1) for n in range(4)]), btwNumber:str='', # => don't show BTW number on factuur, do charge BTW reference:str='', paymentTerms:list=[ "Betaling naar bankrekening (zie gegevens boven) binnen 30 dagen wordt op prijs gesteld.", "Bij betaling svp factuurnummer vermelden.", ], restitutionTerms:list=[ "Het positieve van de hierbovengenoemde negatieve totaal wordt vandaag overgeboekt ", "volgens uw instructies.", ], companyLogo:str='', cars:list=[], ): Entity.__init__(self, number=number, name=name, address=address, btwNumber=btwNumber, reference=reference, paymentTerms=paymentTerms, restitutionTerms=restitutionTerms, companyLogo=companyLogo, cars=cars, )
def __init__(self): Entity.__init__(self) self.collide_walls = True self.walk_speed = 100 self._movement_vectors = [] self._walking = { Character.Direction.UP : False, Character.Direction.RIGHT : False, Character.Direction.DOWN : False, Character.Direction.LEFT : False } self.max_hitpoints = self.current_hitpoints = 10 self.hitbar_health_color = 0, 255, 0 self.hitbar_damage_color = 255, 0, 0 self.sprites = { Character.Direction.UP : 0, Character.Direction.RIGHT : 0, Character.Direction.DOWN : 0, Character.Direction.LEFT : 0 } self.facing = Character.Direction.DOWN
def test_Entity_equip_weapon_no_weapon(self): my_weapon = Weapon("Axe", 31, 0.2) my_Entity = Entity("Ivan", 100) my_Entity.equip_weapon(my_weapon) self.assertEqual(my_Entity.weapon.type, "Axe") self.assertEqual(my_Entity.weapon.damage, 31) self.assertEqual(my_Entity.weapon.critical_strike_percent, 0.2)
def __init__(self, position): Entity.__init__(self) # Physics stuff self.position = position self.velocity = Vector2(0, 0) self.acceleration = Vector2(0, 0) # Image stuff self.animations = {} self.currentAnimation = None self.flipHorizontal = False self.offset = Vector2(0, 0) self.visible = True # z self.z = 0 self.zVelocity = 0 # self.shadow = content.images["shadow.png"] self.shadowSize = 14 self.shadowOffset = Vector2(0, 0) self.shadowVisible = True # layering self.layerIndex = 0 # rotation self.angle = 0
def __init__(self, text="<no text specified>", width=None, height=None, collision=Entity.BLOCK, draworder=10, rsize=None, halo_img="default", width_ofs=0, height_ofs=0, double=False, permute=True, dropshadow=False, dropshadow_color=sf.Color(30,30,30,150), colored_halo=True): self.colored_halo = colored_halo # Note: the 'constants' from defaults may change during startup, but # this file may get parsed BEFORE this happens, so we can't # access defaults safely from default arguments which are # stored at parse-time. height = height or Tile.AUTO width = width or Tile.AUTO rsize = rsize or defaults.letter_size[1] scale = rsize / defaults.letter_size[1] self.permute = permute Entity.__init__(self) self.scale = scale self.rsize = rsize self.collision = collision self.text = text self.double = double self.dropshadow = dropshadow self.dropshadow_color = dropshadow_color self.optimized_text_elem = None self.draworder = draworder self.halo_img = halo_img # if either width and height are AUTO, compute the minimum bounding # rectangle for all glyph bounding rectangles. if width==Tile.AUTO or height==Tile.AUTO: self.dim,self.ofs = self._GuessRealBB(self.text) elif width==Tile.AUTO_QUICK or height==Tile.AUTO_QUICK: self.dim,self.ofs = self._GuessRealBB_Quick(self.text) else: self.dim = self._LetterToTileCoords(width,height) self.ofs = (width_ofs,height_ofs) if self.permute: self.text = self._Permute(self.text) self._Recache()
def __init__(self, name, **properties): self._account = None Entity.__init__(self, 'category', name, **properties) # Category id is it's name self._id = name
def update(self, dt): Entity.update(self, dt) self.z += self.zVelocity * dt self.velocity += self.acceleration * dt self.position += self.velocity * dt if self.currentAnimation: self.currentAnimation.update(dt)
def __init__(self, x, y, level, color = None): Entity.__init__(self) self.image = Surface((16, 16)) if color: self.image.fill(color) self.image.convert() self.rect = Rect(x, y, 16, 16) self.level = level
def __init__(self, engine, color, axis_get_func): Entity.__init__(self, engine) self.color = color self.get_axis = axis_get_func self.pos = pos(0, 0) self.velocity = pos(0, 0) self._speed = 1.0
def __init__(self, player): Entity.__init__(self, player.level, player.y, player.x) self.player = player self.num_ticks = NUM_TICKS self.curr_tick = NUM_TICKS self.radius = 3 self.created_at = time.time()
def update( self, dt ): self.setPosition( self.host.standingAt ) self.position[0] -= self.rect.w/2 self.position[1] -= (self.rect.h - 1) self.rect.topleft = self.getPosition() Entity.update( self, dt )
def __init__(self, level): Entity.__init__(self) self._category = '_Environment' self._level = level self.animPath = '' self.graphics = '' self.physics = ''
def __init__( self, max_speed=1.0, average_turn=20.0, turn_std_dev=5.0, probability_positive_turn=0.5, x_pos=0.0, y_pos=0.0, parent=None): Entity.__init__(self, x_pos=x_pos, y_pos=y_pos, parent=parent) # basic attributes self.direction = 0.0 self.max_speed = max_speed self.average_turn = average_turn self.turn_std_dev = turn_std_dev self.positive_turn = probability_positive_turn self.curr_x = x_pos self.curr_y = y_pos # Memory of movement self.X = [] # x position self.Y = [] # y position self.A = [] # angle turned self.X.append(self.curr_x) self.Y.append(self.curr_y) self.A.append(0.0)
def copyEntitiesFromInfiniteIter(self, sourceLevel, sourceBox, destinationPoint, entities): chunkCount = sourceBox.chunkCount i = 0 copyOffset = map(lambda x, y: x - y, destinationPoint, sourceBox.origin) e = t = 0 for (chunk, slices, point) in sourceLevel.getChunkSlices(sourceBox): yield (i, chunkCount) i += 1 if entities: e += len(chunk.Entities) for entityTag in chunk.Entities: x, y, z = Entity.pos(entityTag) if (x, y, z) not in sourceBox: continue eTag = Entity.copyWithOffset(entityTag, copyOffset) self.addEntity(eTag) t += len(chunk.TileEntities) for tileEntityTag in chunk.TileEntities: x, y, z = TileEntity.pos(tileEntityTag) if (x, y, z) not in sourceBox: continue eTag = TileEntity.copyWithOffset(tileEntityTag, copyOffset) self.addTileEntity(eTag) info("Copied {0} entities, {1} tile entities".format(e, t))
def __init__(self): Entity.__init__(self) self.slash_duration = 64 self.damage_output = 1 self._force = 640 #TODO: This is just a placeholder value. self.setVisible(False) #TODO: Put sprites into a spritesheet self.hold_sprites = {} self.hold_sprites[Character.Direction.UP] = loadImage('knifeb.bmp') self.hold_sprites[Character.Direction.RIGHT] = loadImage('knifer.bmp') self.hold_sprites[Character.Direction.DOWN] = loadImage('knifef.bmp') self.hold_sprites[Character.Direction.LEFT] = loadImage('knifel.bmp') #TODO: For dual-handed whatevers, these shouldn't be keyed to character directions after all. (If I ever do that.) self.swing_sprites = {} self.swing_sprites[Character.Direction.UP] = loadImage('knifeslashne.bmp') self.swing_sprites[Character.Direction.RIGHT] = loadImage('knifeslashse.bmp') self.swing_sprites[Character.Direction.DOWN] = loadImage('knifeslashsw.bmp') self.swing_sprites[Character.Direction.LEFT] = loadImage('knifeslashnw.bmp') self.sprites = self.hold_sprites #Change self.sprites to the appropriate set...? self.facing = Character.Direction.DOWN self.attacker = None self.attacking = False self.is_slash = False self._atk_origin = [0, 0] self.slash_timer = Timer(self.slash_duration, self.finishSlash) self.slash_timer.pause()
def __init__( self, length=100, width=100, n_patches=0): Entity.__init__(self, length=length, width=width) self.create_patches(n_patches)
def __init__(self, isEnnemy): Entity.__init__(self) self.isEnnemy = TimestampedValue('i', isEnnemy) self.champion = TimestampedValue('i', CHAMPION.UNKNOWN) self.skills = [Skill() for j in range(4)] self.range = TimestampedValue('i', -1) # 0 for melee champion ? self.mana = TimestampedValue('i', -1) self.speed = TimestampedValue('i', -1)
def __init__(self): Entity.__init__(self, 200, 200, 40, 40, 0, 0) self.debug_color = (23,33,220) self.is_sticky = True self.speed = 6 self.boost_multiplier = 2 self.boost_ready = False
def __init__(self, pos_x, pos_y, surface, dt): Entity.__init__(self, pos_x, pos_y, surface, dt, self.VERTICES) self.angle = random.uniform(0.0, 360.0) self.spin = random.uniform(-1.0, 1.0) self.speed = 50.0 # self.scale = Vector(5, 5) self.velocity = Vector(self.speed * random.uniform(-1.0, 1.0), self.speed * random.uniform(-1.0, 1.0))
def __init__(self, world): Entity.__init__(self, world) self.singular = 'a priest' self.ai.addAI(task.Fallback(self)) self.ai.addAI(task.Cast(self)) self.ai.addAI(task.Follow(self)) self.ai.addAI(task.Wander(self))
def __init__(self, x=0, y=0, f=Action.South): Entity.__init__(x, y, f) self.nextAction = Action.Wait # store player statistics self.moves = 0 if debug.active: print self
def __init__(self, x, y): Entity.__init__(self) self.xvel = x self.yvel = y self.onGround = False self.image = image.load(img_heror) (hauteur, largeur) = self.image.get_size() self.rect = Rect(x, y, hauteur, largeur)
def __init__( self, pos=[0,0], vel=[0,0], group=None, **kwargs ): Entity.__init__( self, pos, [0,0], None, group, pygame.Rect( 0, 0, self.width, self.height ), animated=False, **kwargs ) self.visible = 0 if EmptyPoint.instanceSpecificVars is None: attrList = list( self.__dict__.keys() ) if EmptyPoint.instanceSpecificVars is None: EmptyPoint.instanceSpecificVars = dict( [ ( eachKey, eachVal ) for eachKey, eachVal in self.__dict__.items() if eachKey not in attrList ] )
def __init__(self, name, **properties): self._due = None self._recurrence = None self._priority = "low" self._memo = None self._completed = None Entity.__init__(self, "task", name, **properties)
def main(): game_title = 'libtcod tutorial revised' screen_width = 80 screen_height = 50 bar_width = 20 panel_height = 7 panel_y = screen_height - panel_height message_x = bar_width + 2 message_width = screen_width - bar_width - 2 message_height = panel_height - 1 map_width = 80 map_height = 43 room_max_size = 10 room_min_size = 6 max_rooms = 30 fov_algorithm = 0 fov_light_walls = True fov_radius = 10 max_monsters_per_room = 3 max_items_per_room = 2 colors = { 'dark_wall': libtcod.Color(0, 0, 100), 'dark_ground': libtcod.Color(50, 50, 150), 'light_wall': libtcod.Color(130, 110, 50), 'light_ground': libtcod.Color(200, 180, 50) } #colors.get('dark_wall') yields the color val fighter_component = Fighter(hp=30, defense=2, power=5) inventory_component = Inventory(26) player = Entity(0, 0, '@', libtcod.white, 'Player', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, inventory=inventory_component) entities = [player] libtcod.console_set_custom_font( 'arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD) libtcod.console_init_root(screen_width, screen_height, game_title, False) con = libtcod.console_new(screen_width, screen_height) panel = libtcod.console_new(screen_width, panel_height) game_map = GameMap(map_width, map_height) game_map.make_map(max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities, max_monsters_per_room, max_items_per_room) fov_recompute = True fov_map = initialize_fov(game_map) message_log = MessageLog(message_x, message_width, message_height) key = libtcod.Key() mouse = libtcod.Mouse() game_state = GameStates.PLAYERS_TURN previous_game_state = game_state while not libtcod.console_is_window_closed(): libtcod.sys_check_for_event( libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse) if fov_recompute: recompute_fov(fov_map, player.x, player.y, fov_radius, fov_light_walls, fov_algorithm) render_all(con, panel, entities, player, game_map, fov_map, fov_recompute, message_log, screen_width, screen_height, bar_width, panel_height, panel_y, mouse, colors, game_state) libtcod.console_flush() clear_all(con, entities) action = handle_keys(key, game_state) move = action.get('move') pickup = action.get('pickup') show_inventory = action.get('show_inventory') drop_inventory = action.get('drop_inventory') inventory_index = action.get('inventory_index') exit = action.get('exit') fullscreen = action.get('fullscreen') player_turn_results = [] if move and game_state == GameStates.PLAYERS_TURN: dx, dy = move destination_x = player.x + dx destination_y = player.y + dy if not game_map.is_blocked(destination_x, destination_y): target = get_blocking_entities_at_location( entities, destination_x, destination_y) if target: attack_results = player.fighter.attack(target) player_turn_results.extend(attack_results) else: player.move(dx, dy) fov_recompute = True game_state = GameStates.ENEMY_TURN elif pickup and game_state == GameStates.PLAYERS_TURN: for entity in entities: if entity.item and entity.x == player.x and entity.y == player.y: pickup_results = player.inventory.add_item(entity) player_turn_results.extend(pickup_results) break else: message_log.add_message( Message('There is nothing here to pick up.', libtcod.yellow)) if show_inventory: previous_game_state = game_state game_state = GameStates.SHOW_INVENTORY if drop_inventory: previous_game_state = game_state game_state = GameStates.DROP_INVENTORY if inventory_index is not None and previous_game_state != GameStates.PLAYER_DEAD and inventory_index < len( player.inventory.items): item = player.inventory.items[inventory_index] if game_state == GameStates.SHOW_INVENTORY: player_turn_results.extend(player.inventory.use(item)) elif game_state == GameStates.DROP_INVENTORY: player_turn_results.extend(player.inventory.drop_item(item)) if exit: if game_state in (GameStates.SHOW_INVENTORY, GameStates.DROP_INVENTORY): game_state = previous_game_state else: return True if fullscreen: libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen()) for player_turn_result in player_turn_results: message = player_turn_result.get('message') dead_entity = player_turn_result.get('dead') item_added = player_turn_result.get('item_added') item_consumed = player_turn_result.get('consumed') item_dropped = player_turn_result.get('item_dropped') if message: print(message) message_log.add_message(message) if dead_entity: if dead_entity == player: message, game_state = kill_player(dead_entity) else: message = kill_monster(dead_entity) message_log.add_message(message) if item_added: entities.remove(item_added) game_state = GameStates.ENEMY_TURN if item_consumed: game_state = GameStates.ENEMY_TURN if item_dropped: entities.append(item_dropped) game_state = GameStates.ENEMY_TURN if game_state == GameStates.ENEMY_TURN: for entity in entities: if entity.ai: enemy_turn_results = entity.ai.take_turn( player, fov_map, game_map, entities) for enemy_turn_result in enemy_turn_results: message = enemy_turn_result.get('message') dead_entity = enemy_turn_result.get('dead') if message: print(message) message_log.add_message(message) if dead_entity: if dead_entity == player: message, game_state = kill_player(dead_entity) else: message = kill_monster(dead_entity) message_log.add_message(message) if game_state == GameStates.PLAYER_DEAD: break else: game_state = GameStates.PLAYERS_TURN
def place_entities(self, room, entities): max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level) max_items_per_room = from_dungeon_level([[1, 1], [2, 4]], self.dungeon_level) # Get a random number of monsters number_of_monsters = randint(0, max_monsters_per_room) number_of_items = randint(0, max_items_per_room) monster_chances = { 'goblin': 500, 'orc': 350, 'uruk': 100, 'infirnimp': 49, 'dragon': from_dungeon_level([100, 10], self.dungeon_level) } item_chances = { 'healing_potion': 70, 'lightning_scroll': 10, 'fireball_scroll': 10, 'confusion_scroll': 10 } for i in range(number_of_monsters): # Choose a random location in the room x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): monster_choice = random_choice_from_dict(monster_chances) #monster generation % if monster_choice == 'goblin': fighter_component = Fighter(hp=10, sp=10, mp=1, defense=0, power=3, xp=30) ai_component = BasicMonster() #create an goblin at 50.0% chance monster = Entity(x, y, 'g', libtcod.light_green, 'Goblin', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'orc': fighter_component = Fighter(hp=20, sp=10, mp=1, defense=1, power=4, xp=50) ai_component = BasicMonster() #create an orc at 35.0% chance monster = Entity(x, y, 'o', libtcod.desaturated_green, 'Orc', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'uruk': fighter_component = Fighter(hp=35, sp=20, mp=1, defense=1, power=5, xp=100) ai_component = BasicMonster() #create an uruk at 10.0% chance monster = Entity(x, y, 'u', libtcod.darkest_green, 'uruk', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'infirnimp': fighter_component = Fighter(hp=40, sp=30, mp=10, defense=3, power=6, xp=200) ai_component = BasicMonster() #create an infernimp at 4.9% chance monster = Entity(x, y, 'Infernimp', libtcod.amber, 'Infernimp', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) else: fighter_component = Fighter(hp=1000, sp=100, mp=1000, defense=30, power=60, xp=30000) ai_component = BasicMonster() #create a dragon at .1% chance monster = Entity(x, y, 'd', libtcod.darker_red, 'Dragon', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) entities.append(monster) for i in range(number_of_items): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): item_choice = random_choice_from_dict(item_chances) if item_choice == 'healing_potion': #spawns healing potion at 70% item_component = Item(use_function=heal, amount=4) item = Entity(x, y, '!', libtcod.violet, 'Healing Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'fireball_scroll': #spawns fireball scroll at 10% item_component = Item( use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=12, radius=3) item = Entity(x, y, '#', libtcod.red, 'Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'confusion_scroll': #spawns confuse scroll at 10% item_component = Item( use_function=cast_confuse, targeting=True, targeting_message=Message( 'Left-click an enemy to confuse it, or right-click to cancel.', libtcod.light_cyan)) item = Entity(x, y, '#', libtcod.light_pink, 'Confusion Scroll', render_order=RenderOrder.ITEM, item=item_component) else: #spawns lightning scroll at 10% item_component = Item(use_function=cast_lightning, damage=20, maximum_range=5) item = Entity(x, y, '#', libtcod.yellow, 'Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component) entities.append(item)
def make_map(self, max_rooms, room_max_size, room_min_size, map_width, map_height, player, entities): rooms = [] num_rooms = 0 center_of_last_room_x = 0 center_of_last_room_y = 0 for r in range(max_rooms): # generates random room size w = randint(room_min_size, room_max_size) h = randint(room_min_size, room_max_size) # generates random room location in the map and not overlapping x = randint(0, map_width - w - 1) y = randint(0, map_height - h - 1) new_room = Rect(x, y, w, h) # checks for room intersections for other_room in rooms: if new_room.intersect(other_room): break else: # if no intersections self.create_room(new_room) (new_x, new_y) = new_room.center() if num_rooms == 0: # the first room contains the player in its center player.x = new_x player.y = new_y else: # finds center of previous room (prev_x, prev_y) = rooms[num_rooms - 1].center() center_of_last_room_x = new_x center_of_last_room_y = new_y # flips a coin to find order of tunnel generation if randint(0, 1) == 0: # moves horizontally then vertically self.create_horizontal_tunnel(prev_x, new_x, prev_y) self.create_vertical_tunnel(prev_y, new_y, new_x) else: # moves vertically then horizontally self.create_horizontal_tunnel(prev_x, new_x, new_y) self.create_vertical_tunnel(prev_y, new_y, prev_x) self.place_entities(new_room, entities) rooms.append(new_room) num_rooms += 1 stairs_component = Stairs(self.dungeon_level + 1) down_stairs = Entity(center_of_last_room_x, center_of_last_room_y, ">", libtcod.white, "Stairs", False, render_order=RenderOrder.STAIRS, stairs=stairs_component) entities.append(down_stairs)
def place_entities(self, room, entities): max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level) max_items_per_room = from_dungeon_level([[1, 1], [2, 4]], self.dungeon_level) # Get a random number of monsters number_of_monsters = randint(0, max_monsters_per_room) number_of_items = randint(0, max_items_per_room) monster_chances = { 'rat': from_dungeon_level([[80, 1], [40, 3], [15, 5]], self.dungeon_level), 'goblin': from_dungeon_level([[15, 1], [40, 3], [15, 5]], self.dungeon_level), 'orc': from_dungeon_level([[20, 2], [30, 4], [60, 6]], self.dungeon_level), 'troll': from_dungeon_level([[15, 3], [30, 5], [60, 7]], self.dungeon_level) } item_chances = { 'torch': 10, 'healing_potion': 35, 'dagger': from_dungeon_level([[7, 1]], self.dungeon_level), 'buckler': from_dungeon_level([[7, 2]], self.dungeon_level), 'sword': from_dungeon_level([[35, 4]], self.dungeon_level), 'shield': from_dungeon_level([[35, 8]], self.dungeon_level), 'lightning_scroll': from_dungeon_level([[25, 4]], self.dungeon_level), 'fireball_scroll': from_dungeon_level([[25, 6]], self.dungeon_level), 'confusion_scroll': from_dungeon_level([[10, 2]], self.dungeon_level) } for i in range(number_of_monsters): # Choose a random location in the room x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): monster_choice = random_choice_from_dict(monster_chances) if monster_choice == 'rat': level_component = Level(current_level=1, current_xp=0, level_up_base=100, level_up_factor=100) fighter_component = Fighter(hp=5, defense=0, power=1, body=monster_choice, xp=10, will_power=0) ai_component = BasicMonster() monster = Entity(x, y, 'r', libtcod.dark_amber, 'Rat', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'goblin': level_component = Level(current_level=1, current_xp=0, level_up_base=40, level_up_factor=150) fighter_component = Fighter(hp=10, defense=0, power=2, body=monster_choice, fov=7, xp=20, level=level_component, will_power=1) ai_component = BasicMonster() monster = Entity(x, y, 'g', libtcod.dark_green, 'Goblin', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component, inventory=Inventory(2), equipment=Equipment()) elif monster_choice == 'orc': fighter_component = Fighter(hp=20, defense=0, power=4, body=monster_choice, fov=4, xp=35, will_power=2) ai_component = BasicMonster() monster = Entity(x, y, 'o', libtcod.darker_green, 'Orc', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component, inventory=Inventory(10), equipment=Equipment()) else: fighter_component = Fighter(hp=30, defense=2, power=8, body=monster_choice, xp=100, will_power=3) ai_component = BasicMonster() monster = Entity(x, y, 'T', libtcod.darkest_green, 'Troll', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component, inventory=Inventory(15), equipment=Equipment()) entities.append(monster) for i in range(number_of_items): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): item_choice = random_choice_from_dict(item_chances) if item_choice == 'healing_potion': item_component = Item(use_function=heal, amount=40) item = Entity(x, y, '!', libtcod.violet, 'Healing Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'torch': equippable_component = Equippable(EquipmentSlots.OFF_HAND, fov_bonus=5) item = Entity(x, y, 't', libtcod.yellow, 'Torch', equippable=equippable_component) elif item_choice == 'sword': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, power_bonus=3) item = Entity(x, y, '/', libtcod.sky, 'Sword', equippable=equippable_component) elif item_choice == 'shield': equippable_component = Equippable(EquipmentSlots.OFF_HAND, defense_bonus=2) item = Entity(x, y, '[', libtcod.darker_orange, 'Shield', equippable=equippable_component) elif item_choice == 'dagger': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, power_bonus=1) item = Entity(x, y, '/', libtcod.red, 'Small Dagger', equippable=equippable_component) elif item_choice == 'buckler': equippable_component = Equippable(EquipmentSlots.OFF_HAND, defense_bonus=1) item = Entity(x, y, '[', libtcod.red, 'Rotten Buckler', equippable=equippable_component) elif item_choice == 'fireball_scroll': item_component = Item( use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=25, radius=3) item = Entity(x, y, '#', libtcod.red, 'Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'confusion_scroll': item_component = Item( use_function=cast_confuse, targeting=True, targeting_message=Message( 'Left-click an enemy to confuse it, or right-click to cancel.', libtcod.light_cyan)) item = Entity(x, y, '#', libtcod.light_pink, 'Confusion Scroll', render_order=RenderOrder.ITEM, item=item_component) else: item_component = Item(use_function=cast_lightning, damage=40, maximum_range=5) item = Entity(x, y, '#', libtcod.yellow, 'Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component) entities.append(item)
def __init__(self, workflow=None): Entity.__init__(self) self.id = None self.update(workflow)
def place_entities(self, room, entities): max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level) max_items_per_room = from_dungeon_level([[1, 1], [2, 4]], self.dungeon_level) max_equipment_items_per_room = from_dungeon_level([[2, 1]], self.dungeon_level) number_of_equipment_items = randint(0, max_equipment_items_per_room) number_of_monsters = randint(0, max_monsters_per_room) number_of_items = randint(0, max_items_per_room) monster_chances = { 'goblin': from_dungeon_level([[80, 1], [60, 3], [30, 5], [0, 7]], self.dungeon_level), 'orc': from_dungeon_level([[40, 2], [50, 3], [30, 7]], self.dungeon_level), 'troll': from_dungeon_level([[20, 3], [40, 5], [60, 7]], self.dungeon_level), 'Balrog': from_dungeon_level([[20, 7], [30, 9], [80, 11]], self.dungeon_level) } #Terrium, Ferrium, Aurium item_chances = { 'healing_potion': from_dungeon_level([[15, 1], [10, 8]], self.dungeon_level), 'greater_healing_potion': from_dungeon_level([[30, 8]], self.dungeon_level), 'terrium_sword': from_dungeon_level([[5, 4]], self.dungeon_level), 'terrium_shield': from_dungeon_level([[15, 4]], self.dungeon_level), 'terrium_chestplate': from_dungeon_level([[15, 5]], self.dungeon_level), 'terrium_leg_armor': from_dungeon_level([[15, 4]], self.dungeon_level), 'terrium_helmet': from_dungeon_level([[20, 3]], self.dungeon_level), 'terrium_amulet': from_dungeon_level([[10, 7]], self.dungeon_level), 'lightning_spell': from_dungeon_level([[25, 4]], self.dungeon_level), 'fireball_spell': from_dungeon_level([[25, 5]], self.dungeon_level), 'confusion_spell': from_dungeon_level([[10, 2]], self.dungeon_level) } equipment_item_chances = { 'equipment_health_potion': from_dungeon_level([[90, 1]], self.dungeon_level) } for i in range(number_of_monsters): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): monster_choice = random_choice_from_dict(monster_chances) if monster_choice == 'goblin': fighter_component = Fighter(hp=5, defense=0, power=2, magic=0, xp=10) ai_component = BasicMonster() monster = Entity(x, y, 'g', libtcod.darker_chartreuse, 'Goblin', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'orc': fighter_component = Fighter(hp=12, defense=0, power=4, magic=0, xp=35) ai_component = BasicMonster() monster = Entity(x, y, 'o', libtcod.desaturated_green, 'Orc', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'troll': fighter_component = Fighter(hp=18, defense=2, power=8, magic=0, xp=100) ai_component = BasicMonster() monster = Entity(x, y, 'T', libtcod.darker_green, 'Troll', blocks=True, fighter=fighter_component, render_order=RenderOrder.ACTOR, ai=ai_component) else: fighter_component = Fighter(hp=60, defense=5, power=16, magic=0, xp=200) ai_component = BasicMonster() monster = Entity(x, y, 'B', libtcod.darker_red, 'Balrog', blocks=True, fighter=fighter_component, render_order=RenderOrder.ACTOR, ai=ai_component) entities.append(monster) for i in range(number_of_items): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): item_choice = random_choice_from_dict(item_chances) if item_choice == 'healing_potion': item_component = Item(use_function=heal, amount=20) item = Entity(x, y, '&', libtcod.violet, "health potion", render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'greater_healing_potion': item_component = Item(use_function=heal, amount=40) item = Entity(x, y, '&', libtcod.red, "greater healing potion", render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'terrium_sword': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, power_bonus=randint( 2, 4)) item = Entity(x, y, '/', libtcod.darker_orange, "terrium sword", equippable=equippable_component) elif item_choice == 'terrium_shield': equippable_component = Equippable(EquipmentSlots.OFF_HAND, defense_bonus=randint( 1, 2)) item = Entity(x, y, '[', libtcod.darker_orange, "terrium shield", equippable=equippable_component) elif item_choice == 'terrium_chestplate': equippable_component = Equippable(EquipmentSlots.CHEST, defense_bonus=randint( 2, 3)) item = Entity(x, y, 'M', libtcod.darker_orange, "terrium chestplate", equippable=equippable_component) elif item_choice == 'terrium_leg_armor': equippable_component = Equippable(EquipmentSlots.LEGS, defense_bonus=randint( 1, 2)) item = Entity(x, y, 'H', libtcod.darker_orange, "terrium leg armor", equippable=equippable_component) elif item_choice == 'terrium_helmet': equippable_component = Equippable(EquipmentSlots.HEAD, defense_bonus=randint( 1, 2)) item = Entity(x, y, '^', libtcod.darker_orange, "terrium helmet", equippable=equippable_component) elif item_choice == 'terrium_amulet': equippable_component = Equippable(EquipmentSlots.AMULET, magic_bonus=randint( 1, 4)) item = Entity(x, y, '*', libtcod.darker_orange, "terrium amulet", equippable=equippable_component) elif item_choice == 'fireball_spell': item_component = Item( use_function=cast_fireball, targeting=True, targeting_message=Message( "Left click a target tile for the fireball, or right click to cancel.", libtcod.light_cyan), damage=15, radius=3) item = Entity(x, y, '#', libtcod.red, "Fireball Spell", render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'confusion_spell': item_component = Item( use_function=cast_confusion, targeting=True, targeting_message=Message( "Left click an enemy to confuse it, or right click to cancel.", libtcod.light_cyan)) item = Entity(x, y, '#', libtcod.light_pink, "Confusion Spell", render_order=RenderOrder.ITEM, item=item_component) else: item_component = Item(use_function=cast_lightning, damage=30, maximum_range=5) item = Entity(x, y, '#', libtcod.blue, "Lightning Spell", render_order=RenderOrder.ITEM, item=item_component) entities.append(item) '''
def __init__(self, x, r_y): Entity.__init__(self) self.r_y = r_y self.y = 0 self.x = x self.color = BUOY_COLOUR
def main(): # Variables that define the screen size. screen_width = 80 screen_height = 50 bar_width = 20 panel_height = 7 panel_y = screen_height - panel_height message_x = bar_width + 2 message_width = screen_width - bar_width - 2 message_height = panel_height - 1 map_width = 80 map_height = 43 room_max_size = 10 room_min_size = 6 max_rooms = 30 fov_algorithm = 0 fov_light_walls = True fov_radius = 10 max_monsters_per_room = 3 colors = { 'dark_wall': libtcod.Color(0, 0, 100), 'dark_ground': libtcod.Color(50, 50, 150), 'light_wall': libtcod.Color(130, 110, 50), 'light_ground': libtcod.Color(200, 180, 50) } fighter_component = Fighter(hp=30, defense=2, power=5) # Keeps track of the player's position at all times. player = Entity(0, 0, '@', libtcod.white, 'Player', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component) entities = [player] # Tells libtcod which font to use. libtcod.console_set_custom_font( 'arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD) # Creates the screen with a title. libtcod.console_init_root(screen_width, screen_height, 'AngrealRL version T0.01', False) con = libtcod.console_new(screen_width, screen_height) panel = libtcod.console_new(screen_width, panel_height) game_map = GameMap(map_width, map_height) game_map.make_map(max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities, max_monsters_per_room) fov_recompute = True fov_map = initialize_fov(game_map) message_log = MessageLog(message_x, message_width, message_height) # Variables that hold the keyboard and mouse inputs. key = libtcod.Key() mouse = libtcod.Mouse() game_state = GameStates.PLAYER_TURN # Game loop that will only end if the screen is closed. while not libtcod.console_is_window_closed(): # Captures new 'events' (user inputs). libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse) if fov_recompute: recompute_fov(fov_map, player.x, player.y, fov_radius, fov_light_walls, fov_algorithm) # Print the '@' symbol, set it to the position set by two parameters and set the backgroung to 'none'. render_all(con, panel, entities, player, game_map, fov_map, fov_recompute, message_log, screen_width, screen_height, bar_width, panel_height, panel_y, mouse, colors) fov_recompute = False libtcod.console_flush() clear_all(con, entities) # Allow the game to be 'gracefully' closed by hitting the ESC key. action = handle_keys(key) move = action.get('move') exit = action.get('exit') fullscreen = action.get('fullscreen') player_turn_results = [] if move and game_state == GameStates.PLAYER_TURN: dx, dy = move destination_x = player.x + dx destination_y = player.y + dy if not game_map.is_blocked(destination_x, destination_y): target = get_blocking_entities_at_location( entities, destination_x, destination_y) if target: attack_results = player.fighter.attack(target) player_turn_results = player.fighter.attack(target) else: player.move(dx, dy) fov_recompute = True game_state = GameStates.ENEMY_TURN if exit: return True if fullscreen: libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen()) for player_turn_result in player_turn_results: message = player_turn_result.get('message') dead_entity = player_turn_result.get('dead') if message: message_log.add_message(message) if dead_entity: if dead_entity == player: message, game_state = kill_player(dead_entity) else: message = kill_monster(dead_entity) message_log.add_message(message) if game_state == GameStates.ENEMY_TURN: for entity in entities: if entity.ai: enemy_turn_results = entity.ai.take_turn( player, fov_map, game_map, entities) for enemy_turn_result in enemy_turn_results: message = enemy_turn_result.get('message') # If the entity dies, changes the enemy status to 'dead' dead_entity = enemy_turn_result.get('dead') if message: print(message) if dead_entity: if dead_entity == player: message, game_state = kill_player(dead_entity) else: message = kill_monster(dead_entity) print(message) if game_state == GameStates.PLAYER_DEAD: break if game_state == GameStates.PLAYER_DEAD: break else: game_state = GameStates.PLAYER_TURN
def make_map(self, max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities,): """ Create rooms for dungeon map """ rooms = [] num_rooms = 0 center_of_last_room_x = None center_of_last_room_y = None for r in range(max_rooms): # random width and height w = randint(room_min_size, room_max_size) h = randint(room_min_size, room_max_size) # random position without going outside the boundaries of the map x = randint(0, map_width - w - 1) y = randint(0, map_height - h - 1) # 'Rect' class to make rooms new_room = Rect(x, y, w, h) # Run through other rooms to make sure it doesnt intersect for other_rooms in rooms: if new_room.intersect(other_rooms): break else: # This will action if there are no intersections # unblock map tiles self.create_room(new_room) # center coordinates for new room (new_x, new_y) = new_room.center() center_of_last_room_x = new_x center_of_last_room_y = new_y if num_rooms == 0: # Upon creation of first room player.x = new_x player.y = new_y else: """ for all rooms after the first one connect the current room to the previous room """ # Coordinates of the previous room (prev_x, prev_y) = rooms[num_rooms - 1].center() # Randomise the direction of the tunnel 1 == horizontal if randint(0, 1) == 1: # Move horizontal then vertical self.create_h_tunnel(prev_x, new_x, prev_y) self.create_v_tunnel(prev_y, new_y, new_x) else: # move vertical then horizontal self.create_v_tunnel(prev_y, new_y, prev_x) self.create_h_tunnel(prev_x, new_x, new_y) self.place_entities(new_room, entities, ) # Finally add the new room to the room list rooms.append(new_room) num_rooms += 1 stairs_component = Stairs(self.dungeon_level + 1) down_stairs = Entity(center_of_last_room_x, center_of_last_room_y, '>', tcod.white, 'stairs', render_order=RenderOrder.STAIRS, stairs=stairs_component) entities.append(down_stairs)
from entity import Entity player = Entity(charTile = "@", color = [255, 255, 255], name="Player", blocks_movement=True) enemy = Entity(charTile = "E", color = [255, 255, 0], name="Enemy", blocks_movement=True)
from entity import Entity, Point a = Entity("object 1") objects = [a, Entity("object 2"), Entity("object 3")] for ob in objects: print ob print 'selected: ', objects[1] box = objects[1] #remove del objects[1] for ob in objects: print ob print 'in box: ', box box.setName("new name!") print box
import tcod as libtcod from random_utils import random_choice_from_dict, from_dungeon_level from entity import Entity from render_functions import RenderOrder from components.fighter import Fighter from components.ai import BasicMonster monsters = { 'orc': Entity([80], -1, -1, 'o', libtcod.desaturated_green, 'Orc', blocks=True, render_order=RenderOrder.ACTOR, fighter=Fighter(hp=20, defense=0, power=4, speed=150, xp=35), ai=BasicMonster()), 'troll': Entity([[15, 3], [30, 5], [60, 7]], -1, -1, 'T', libtcod.darker_green, 'Troll', blocks=True, render_order=RenderOrder.ACTOR, fighter=Fighter(hp=30, defense=2, power=8, speed=200, xp=100), ai=BasicMonster()), }
def __init__(self, row, col): Entity.__init__(self, row, col)
def place_entities(self, room, entities): max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level) max_items_per_room = from_dungeon_level([[1, 1], [2, 4]], self.dungeon_level) # Get a random number of monsters number_of_monsters = randint(0, max_monsters_per_room) number_of_items = randint(0, max_items_per_room) monster_chances = { 'quiz': 80, 'exam': from_dungeon_level([[15, 3], [30, 5], [60, 7]], self.dungeon_level), 'final': from_dungeon_level([[10, 3], [20, 5], [30, 7]], self.dungeon_level) } # Define chance for each type monster_type_chances = { 'art': 25, 'math': 25, 'science': 25, 'english': 25, } item_chances = { 'healing_potion': 50, 'art_sword': from_dungeon_level([[5, 1]], self.dungeon_level), 'art_shield': from_dungeon_level([[5, 1]], self.dungeon_level), 'math_sword': from_dungeon_level([[5, 1]], self.dungeon_level), 'math_shield': from_dungeon_level([[5, 1]], self.dungeon_level), 'science_sword': from_dungeon_level([[5, 1]], self.dungeon_level), 'science_shield': from_dungeon_level([[5, 1]], self.dungeon_level), 'english_sword': from_dungeon_level([[5, 1]], self.dungeon_level), 'english_shield': from_dungeon_level([[5, 1]], self.dungeon_level), #'lightning_scroll': from_dungeon_level([[25, 4]], self.dungeon_level), #'fireball_scroll': from_dungeon_level([[25, 6]], self.dungeon_level), #'confusion_scroll': from_dungeon_level([[10, 2]], self.dungeon_level) } for i in range(number_of_monsters): # Choose a random location in the room x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): monster_choice = random_choice_from_dict(monster_chances) monster_type_choice = random_choice_from_dict( monster_type_chances) # Get random type of monsters if monster_choice == 'quiz': if monster_type_choice == 'art': fighter_component = Fighter(hp=20, defense=0, power=4, name='Art Quiz', xp=0, subject='art') ai_component = BasicMonster() monster = Entity(x, y, 275, libtcod.white, 'Art Quiz', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'math': fighter_component = Fighter(hp=20, defense=0, power=4, name='Math Quiz', xp=0, subject='math') ai_component = BasicMonster() monster = Entity(x, y, 278, libtcod.white, 'Math Quiz', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'science': fighter_component = Fighter(hp=20, defense=0, power=4, name='Science Quiz', xp=0, subject='science') ai_component = BasicMonster() monster = Entity(x, y, 281, libtcod.white, 'Science Quiz', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'english': fighter_component = Fighter(hp=20, defense=0, power=4, name='English Quiz', xp=0, subject='english') ai_component = BasicMonster() monster = Entity(x, y, 284, libtcod.white, 'English Quiz', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'exam': if monster_type_choice == 'art': fighter_component = Fighter(hp=35, defense=1, power=6, name='Art Exam', xp=0, subject='art') ai_component = BasicMonster() monster = Entity(x, y, 276, libtcod.white, 'Art Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'math': fighter_component = Fighter(hp=35, defense=1, power=6, name='Math Exam', xp=0, subject='math') ai_component = BasicMonster() monster = Entity(x, y, 279, libtcod.white, 'Math Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'science': fighter_component = Fighter(hp=35, defense=1, power=6, name='Science Exam', xp=0, subject='science') ai_component = BasicMonster() monster = Entity(x, y, 282, libtcod.white, 'Science Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'english': fighter_component = Fighter(hp=35, defense=1, power=6, name='English Exam', xp=0, subject='english') ai_component = BasicMonster() monster = Entity(x, y, 285, libtcod.white, 'English Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == 'final': if monster_type_choice == 'art': fighter_component = Fighter(hp=50, defense=2, power=8, name='Art Final Exam', xp=4, subject='art') ai_component = BasicMonster() monster = Entity(x, y, 277, libtcod.white, 'Art Final Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'math': fighter_component = Fighter(hp=50, defense=2, power=8, name='Math Final Exam', xp=4, subject='math') ai_component = BasicMonster() monster = Entity(x, y, 280, libtcod.white, 'Math Final Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'science': fighter_component = Fighter(hp=50, defense=2, power=8, name='Science Final Exam', xp=4, subject='science') ai_component = BasicMonster() monster = Entity(x, y, 283, libtcod.white, 'Science Final Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_type_choice == 'english': fighter_component = Fighter(hp=50, defense=2, power=8, name='English Final Exam', xp=4, subject='english') ai_component = BasicMonster() monster = Entity(x, y, 286, libtcod.white, 'English Final Exam', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) entities.append(monster) for i in range(number_of_items): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): item_choice = random_choice_from_dict(item_chances) if item_choice == 'healing_potion': item_component = Item(use_function=heal, amount=40) item = Entity(x, y, 262, libtcod.white, 'Relaxing Tea', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'art_sword': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, art_power_bonus=5) item = Entity(x, y, 267, libtcod.white, 'Paintbrush', equippable=equippable_component) elif item_choice == 'art_shield': equippable_component = Equippable(EquipmentSlots.OFF_HAND, art_defense_bonus=4) item = Entity(x, y, 268, libtcod.white, 'Pallete Clipboard', equippable=equippable_component) elif item_choice == 'math_sword': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, math_power_bonus=5) item = Entity(x, y, 269, libtcod.white, 'Ruler', equippable=equippable_component) elif item_choice == 'math_shield': equippable_component = Equippable(EquipmentSlots.OFF_HAND, math_defense_bonus=4) item = Entity(x, y, 270, libtcod.white, 'Measuring Clipboard', equippable=equippable_component) elif item_choice == 'science_sword': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, science_power_bonus=5) item = Entity(x, y, 271, libtcod.white, 'Calculator', equippable=equippable_component) elif item_choice == 'science_shield': equippable_component = Equippable(EquipmentSlots.OFF_HAND, science_defense_bonus=4) item = Entity(x, y, 272, libtcod.white, 'Vial Clipboard', equippable=equippable_component) elif item_choice == 'english_sword': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, english_power_bonus=5) item = Entity(x, y, 273, libtcod.white, 'Dictionary', equippable=equippable_component) elif item_choice == 'english_shield': equippable_component = Equippable(EquipmentSlots.OFF_HAND, english_defense_bonus=4) item = Entity(x, y, 274, libtcod.white, 'Report Clipboard', equippable=equippable_component) entities.append(item)
def __init__(self, name): self.name = name self.init_stats() Entity.__init__(self)
def main(): screen_width = 80 screen_height = 50 map_width = 80 map_height = 45 room_max_size = 10 room_min_size = 6 max_rooms = 30 fov_algorithm = 0 fov_light_walls = True fov_radius = 10 max_monsters_per_room = 3 colors = { 'dark_wall': libtcod.Color(0, 0, 100), 'dark_ground': libtcod.Color(50, 50, 150), 'light_wall': libtcod.Color(130, 110, 50), 'light_ground': libtcod.Color(200, 180, 50), } player = Entity(0, 0, '@', libtcod.white, 'Player', blocks=True) entities = [player] libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD) libtcod.console_init_root(screen_width, screen_height, 'libtcod tutorial revised', False) con = libtcod.console_new(screen_width, screen_height) game_map = GameMap(map_width, map_height) game_map.make_map(max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities, max_monsters_per_room) fov_recompute = True fov_map = initialize_fov(game_map) key = libtcod.Key() mouse = libtcod.Mouse() while not libtcod.console_is_window_closed(): libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse) if fov_recompute: recompute_fov(fov_map, player.x, player.y, fov_radius, fov_light_walls, fov_algorithm) render_all(con, entities, game_map, fov_map, fov_recompute, screen_width, screen_height, colors) fov_recompute = False libtcod.console_flush() clear_all(con, entities) action = handle_keys(key) move = action.get('move') exit = action.get('exit') fullscreen = action.get('fullscreen') if move: dx, dy = move destination_x = player.x + dx destination_y = player.y + dy if not game_map.is_blocked(destination_x, destination_y): target = get_blocking_entities_at_location(entities, destination_x, destination_y) if target: print('You kick the ' + target.name + ' in the shins, much to its annoyance!') else: player.move(dx, dy) fov_recompute = True if exit: return True if fullscreen: libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
def place_entities(self, room, entities): max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level) max_items_per_room = from_dungeon_level([[1, 1], [2, 4]], self.dungeon_level) # Get a random number of monsters number_of_monsters = randint(0, max_monsters_per_room) number_of_items = randint(0, max_items_per_room) monster_chances = { 'orc': 80, 'troll': from_dungeon_level([[15, 3], [30, 5], [60, 7]], self.dungeon_level) } item_chances = { 'sword': from_dungeon_level([[5, 4]], self.dungeon_level), 'shield': from_dungeon_level([[15, 8]], self.dungeon_level), 'healing_potion': 35, 'lightning_scroll': from_dungeon_level([[25, 4]], self.dungeon_level), 'fireball_scroll': from_dungeon_level([[25, 6]], self.dungeon_level), 'confusion_scroll': from_dungeon_level([[10, 2]], self.dungeon_level) } for i in range(number_of_monsters): # Choose a random location in the room x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([entity for entity in entities if entity.x == x and entity.y == y]): monster_choice = random_choice_from_dict(monster_chances) if monster_choice == 'orc': fighter_component = Fighter(hp=20, defense=0, power=4, xp=35) ai_component = BasicMonster() monster = Entity(x, y, 'o', libtcod.desaturated_green, 'Orc', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) else: fighter_component = Fighter(hp=30, defense=2, power=8, xp=100) ai_component = BasicMonster() monster = Entity(x, y, 'T', libtcod.darker_green, 'Troll', blocks=True, fighter=fighter_component, render_order=RenderOrder.ACTOR, ai=ai_component) entities.append(monster) for i in range(number_of_items): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([entity for entity in entities if entity.x == x and entity.y == y]): item_choice = random_choice_from_dict(item_chances) if item_choice == 'healing_potion': item_component = Item(use_function=heal, amount=40) item = Entity(x, y, '!', libtcod.violet, 'Healing Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'sword': equippable_component = Equippable(EquipmentSlots.MAIN_HAND, power_bonus=3) item = Entity(x, y, '/', libtcod.sky, 'Sword', equippable=equippable_component) elif item_choice == 'shield': equippable_component = Equippable(EquipmentSlots.OFF_HAND, defense_bonus=1) item = Entity(x, y, '[', libtcod.darker_orange, 'Shield', equippable=equippable_component) elif item_choice == 'fireball_scroll': item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=25, radius=3) item = Entity(x, y, '#', libtcod.red, 'Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'confusion_scroll': item_component = Item(use_function=cast_confuse, targeting=True, targeting_message=Message( 'Left-click an enemy to confuse it, or right-click to cancel.', libtcod.light_cyan)) item = Entity(x, y, '#', libtcod.light_pink, 'Confusion Scroll', render_order=RenderOrder.ITEM, item=item_component) else: item_component = Item(use_function=cast_lightning, damage=40, maximum_range=5) item = Entity(x, y, '#', libtcod.yellow, 'Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component) entities.append(item)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities): rooms = [] num_rooms = 0 center_of_last_room_x = None center_of_last_room_y = None for r in range(max_rooms): # random width and height w = randint(room_min_size, room_max_size) h = randint(room_min_size, room_max_size) # random position without going out of the boundaries of the map x = randint(0, map_width - w - 1) y = randint(0, map_height - h - 1) # "Rect" class makes rectangles easier to work with new_room = Rect(x, y, w, h) if r == 0 and self.dungeon_level != 1: up_stairs_component = Stairs(self.dungeon_level - 1) up_stairs = Entity(x + int(round(w / 2)), y + int(round(h / 2)), '<', libtcod.white, 'Stairs', render_order=RenderOrder.STAIRS, stairs=up_stairs_component) entities.append(up_stairs) # run through the other rooms and see if they intersect with this one for other_room in rooms: if new_room.intersect(other_room): break else: # this means there are no intersections, so this room is valid # "paint" it to the map's tiles self.create_room(new_room) # center coordinates of new room, will be useful later (new_x, new_y) = new_room.center() center_of_last_room_x = new_x center_of_last_room_y = new_y 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() # flip a coin (random number that is either 0 or 1) if randint(0, 1) == 1: # first move horizontally, then vertically self.create_h_tunnel(prev_x, new_x, prev_y) self.create_v_tunnel(prev_y, new_y, new_x) else: # first move vertically, then horizontally self.create_v_tunnel(prev_y, new_y, prev_x) self.create_h_tunnel(prev_x, new_x, new_y) # finally, append the new room to the list self.place_entities(new_room, entities) rooms.append(new_room) num_rooms += 1 down_stairs_component = Stairs(self.dungeon_level + 1) down_stairs = Entity(center_of_last_room_x, center_of_last_room_y, '>', libtcod.white, 'Stairs', render_order=RenderOrder.STAIRS, stairs=down_stairs_component) entities.append(down_stairs)
def place_entities(self, room, entities): max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level) max_items_per_room = from_dungeon_level([[1, 1], [2, 4]], self.dungeon_level) # gets random number of monsters number_of_monsters = randint(0, max_monsters_per_room) number_of_items = randint(0, max_items_per_room) monster_chances = { "orc": 80, "troll": from_dungeon_level([[15, 3], [30, 5], [60, 7]], self.dungeon_level), "dragon": from_dungeon_level([[10, 7], [20, 10], [30, 14]], self.dungeon_level) } item_chances = { "health_potion": 35, "lightning_scroll": from_dungeon_level([[25, 4]], self.dungeon_level), "fireball_scroll": from_dungeon_level([[25, 6]], self.dungeon_level), "confusion_scroll": from_dungeon_level([[10, 2]], self.dungeon_level), "betrayal_scroll": from_dungeon_level([[10, 5]], self.dungeon_level), "iron_sword": from_dungeon_level([[5, 4]], self.dungeon_level), "wooden_shield": from_dungeon_level([[15, 8]], self.dungeon_level) } for i in range(number_of_monsters): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): monster_choice = random_choice_from_dict(monster_chances) if monster_choice == "orc": fighter_component = Fighter(hp=20, defense=0, power=4, xp=35) ai_component = BasicMonster() monster = Entity(x, y, "o", libtcod.desaturated_green, "Orc", blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == "troll": fighter_component = Fighter(hp=30, defense=2, power=8, xp=100) ai_component = BasicMonster() monster = Entity(x, y, "T", libtcod.darker_green, "Troll", blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) elif monster_choice == "dragon": fighter_component = Fighter(hp=40, defense=2, power=12, xp=500) ai_component = BasicMonster() monster = Entity(x, y, "D", libtcod.dark_red, "Dragon", blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component) entities.append(monster) for i in range(number_of_items): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([ entity for entity in entities if entity.x == x and entity.y == y ]): item_choice = random_choice_from_dict(item_chances) if item_choice == "health_potion": item_component = Item(use_function=heal, amount=40) item = Entity(x, y, "!", libtcod.violet, "Health Potion", False, render_order=RenderOrder.ITEM, item=item_component) elif item_choice == "fireball_scroll": item_component = Item( use_function=cast_fireball, targeting=True, targeting_message=Message( "Left-click a tile to target, or right-click to cancel.", libtcod.light_cyan), damage=25, radius=3) item = Entity(x, y, "#", libtcod.red, "Fireball Scroll", False, render_order=RenderOrder.ITEM, item=item_component) elif item_choice == "confusion_scroll": item_component = Item( use_function=cast_confuse, targeting=True, targeting_message=Message( "Left-click a tile to target, or right-click to cancel", libtcod.light_cyan)) item = Entity(x, y, "#", libtcod.light_pink, "Confusion Scroll", False, render_order=RenderOrder.ITEM, item=item_component) elif item_choice == "betrayal_scroll": item_component = Item( use_function=cast_betrayal, targeting=True, targeting_message=Message( "Left-click a tile to target, or right-click to cancel", libtcod.light_cyan)) item = Entity(x, y, '#', libtcod.black, "Betrayal Scroll", False, render_order=RenderOrder.ITEM, item=item_component) elif item_choice == "lightning_scroll": item_component = Item(use_function=cast_lightning, damage=40, maximum_range=5) item = Entity(x, y, "#", libtcod.yellow, "Lightning Scroll", False, render_order=RenderOrder.ITEM, item=item_component) elif item_choice == "iron_sword": equippable_component = Equippable(EquipmentSlots.MAIN_HAND, power_bonus=3) item = Entity(x, y, "/", libtcod.silver, "Iron Sword", False, render_order=RenderOrder.ITEM, equippable=equippable_component) elif item_choice == "wooden_shield": equippable_component = Equippable(EquipmentSlots.OFF_HAND, defense_bonus=1) item = Entity(x, y, "[", libtcod.darker_orange, "Wooden Shield", False, render_order=RenderOrder.ITEM, equippable=equippable_component) entities.append(item)
def main(): # Screen settings screen_width = 80 screen_height = 45 # Map creation settings map_width = 80 map_height = 45 # Room creation settings room_max_size = 10 room_min_size = 6 max_rooms = 30 # FOV settings - passed to libtcod library fov_algorithm = 0 fov_light_walls = True fov_radius = 10 # Color Dictionary for entities colors = { 'dark_wall': libtcod.Color(0, 0, 100), 'dark_ground': libtcod.Color(50, 50, 150), 'light_wall': libtcod.Color(130, 110, 50), 'light_ground': libtcod.Color(200, 180, 50) } # Create player entity and entities list - monsters appended at map creation max_monsters_per_room = 3 player = Entity(0, 0, '@', libtcod.white, 'my dude', blocks=True) entities = [player] # Console settings and initialisation libtcod.console_set_custom_font( 'arial10x10.png', libtcod.FONT_TYPE_GRAYSCALE | libtcod.FONT_LAYOUT_TCOD) libtcod.console_init_root(screen_width, screen_height, 'libtcod tutorial revised', False) # Set up the console con = libtcod.console_new(screen_width, screen_height) # Create the map object and trigger dungeon creation game_map = GameMap(map_width, map_height) game_map.make_map(max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities, max_monsters_per_room) fov_recompute = True fov_map = initialize_fov(game_map) # Controller mappings key = libtcod.Key() mouse = libtcod.Mouse() game_state = GameStates.PLAYERS_TURN # Main Loop while not libtcod.console_is_window_closed(): libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse) if fov_recompute: recompute_fov(fov_map, player.x, player.y, fov_radius, fov_light_walls, fov_algorithm) render_all(con, entities, game_map, fov_map, fov_recompute, screen_width, screen_height, colors) # TODO - wouldn't it make more sense to move this under recompute_fov() call? fov_recompute = False libtcod.console_flush() clear_all(con, entities) action = handle_keys(key) move = action.get('move') exit = action.get('exit') fullscreen = action.get('fullscreen') if move and game_state == GameStates.PLAYERS_TURN: dx, dy = move destination_x = player.x + dx destination_y = player.y + dy if not game_map.is_blocked(destination_x, destination_y): target = get_blocking_entities_at_location( entities, destination_x, destination_y) if target: print('You kick the ' + target.name + ' squarely in the nards, much to its dismay') else: player.move(dx, dy) fov_recompute = True game_state = GameStates.ENEMY_TURN if exit: return True if fullscreen: libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen) if game_state == GameStates.ENEMY_TURN: for entity in entities: if entity != player: print('The ' + entity.name + ' scratches itself in an unpleasant fashion.') game_state = GameStates.PLAYERS_TURN
def make_map(self, max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities, max_monsters_per_room, max_items_per_room): rooms = [] num_rooms = 0 center_of_last_room_x = None center_of_last_room_y = None for r in range(max_rooms): #random width and height w = randint(room_min_size, room_max_size) h = randint(room_min_size, room_max_size) #random position without going out of boundaries x = randint(0, map_width - w - 1) y = randint(0, map_height - h - 1) #'Rect' class makes rectangles easier to work with new_room = Rect(x, y, w, h) #run through other rooms and check if they interact with new_room for other_room in rooms: if new_room.intersect(other_room): break else: #if loop did not break, i.e. there were no intersections #paint it to the map's tiles self.create_room(new_room) #center coordinates of new room (new_x, new_y) = new_room.center() center_of_last_room_x = new_x center_of_last_room_y = new_y 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() #flip a coin (0, 1) if randint(0, 1) == 1: #first move horizontally, then vertically self.create_h_tunnel(prev_x, new_x, prev_y) self.create_v_tunnel(prev_y, new_y, new_x) else: #first move vertically, then horizontally self.create_v_tunnel(prev_y, new_y, prev_x) self.create_h_tunnel(prev_x, new_x, new_y) self.place_entities(new_room, entities, max_monsters_per_room, max_items_per_room) #finally, append the new room to the list rooms.append(new_room) num_rooms += 1 stairs_component = Stairs(self.dungeon_level + 1) down_stairs = Entity(center_of_last_room_x, center_of_last_room_y, '>', libtcod.white, 'Stairs', render_order=RenderOrder.STAIRS, stairs=stairs_component) entities.append(down_stairs)
def return_potions(self, x, y): item_chances = { 'a': 10, 'b': from_dungeon_level([[2, 4]], self.dungeon_level), 'c': from_dungeon_level([[3, 4]], self.dungeon_level), 'd': from_dungeon_level([[4, 4]], self.dungeon_level), 'e': from_dungeon_level([[5, 4]], self.dungeon_level), 'f': from_dungeon_level([[6, 4]], self.dungeon_level), 'g': from_dungeon_level([[6, 4]], self.dungeon_level), 'h': from_dungeon_level([[2, 4]], self.dungeon_level), 'i': from_dungeon_level([[2, 4]], self.dungeon_level), 'j': from_dungeon_level([[3, 4]], self.dungeon_level), 'k': from_dungeon_level([[3, 4]], self.dungeon_level) } item_choice = random_choice_from_dict(item_chances) if item_choice == 'a': item_component = Item(use_function=heal, amount=20) item = Entity(x, y, '!', libtcod.violet, 'Lesser Healing Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'b': item_component = Item(use_function=heal, amount=40) item = Entity(x, y, '!', libtcod.violet, 'Healing Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'c': item_component = Item(use_function=heal, amount=60) item = Entity(x, y, '!', libtcod.violet, 'Large Healing Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'd': item_component = Item(use_function=flood, amount=20) item = Entity(x, y, '!', libtcod.violet, 'Lesser Blud Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'e': item_component = Item(use_function=seal, amount=20) item = Entity(x, y, '!', libtcod.violet, 'Lesser Bottle of Blud Storage', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'f': item_component = Item(use_function=flood, amount=40) item = Entity(x, y, '!', libtcod.violet, 'Blud Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'g': item_component = Item(use_function=seal, amount=40) item = Entity(x, y, '!', libtcod.violet, 'Bottle of Blud Storage', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'h': item_component = Item(use_function=flood, amount=60) item = Entity(x, y, '!', libtcod.violet, 'Large Blud Potion', render_order=RenderOrder.ITEM, item=item_component) elif item_choice == 'i': item_component = Item(use_function=seal, amount=60) item = Entity(x, y, '!', libtcod.violet, 'Large Bottle of Blud Storage', render_order=RenderOrder.ITEM, item=item_component) # Return the glass material so we get broken shards out of use item.material = 'glass' return item
def place_entities_at_nook(self, entities, min_monsters, max_monsters, max_items): # 벽 지도 생성 wall_map = np.zeros((self.height, self.width), dtype='uint8') for y in range(self.height): for x in range(self.width): wall_map[y, x] = 1 if self.tiles[y, x].blocked else 0 # 구석 개수 설정 nooks = find_nook(wall_map) monster_num = randint(min_monsters, max_monsters) # 몬스터 배치 monster_chance = {'CI': 80, 'GS': 20, "FA": 10} for j in range(monster_num): ai_comp = BasicAi() choice = random_choice_from_dict(monster_chance) if j < len(nooks): mx = nooks[j][1] my = nooks[j][0] else: # 구석진 곳이 모자르면 지도에서 무작위로 좌표를 뽑아옴 my, mx = self.np_find_empty_cell(entities, wall_map) if choice == 'CI': f_comp = Fighter(hp=10, defense=0, power=3) monster = self.create_monster(mx, my, '~', tcod.flame, '기어다니는 내장', f_comp, ai_comp) elif choice == 'GS': f_comp = Fighter(hp=16, defense=1, power=4) monster = self.create_monster(mx, my, 'S', tcod.dark_green, '거대 거미', f_comp, ai_comp) elif choice == 'FA': f_comp = Fighter(hp=20, defense=0, power=7) monster = self.create_monster(mx, my, '@', tcod.Color(128, 5, 5), '사람을 닮은 무언가', f_comp, ai_comp) entities.append(monster) self.monsters += 1 #계산용 # 아이템 배치, 아직 임시 shuffle(nooks) #item_chance = {'FB':5} item_chance = { 'FJ': 60, 'REG': 30, 'FB': 10, "SC": 10, 'FLW': 10, 'SCF': 5, 'SWD': 5, 'SLD': 5, 'AM': 1 } #'BK': 20 # # for i in range(len(nooks)): kinds = random_choice_from_dict(item_chance) if j < len(nooks): ix = nooks[i][1] iy = nooks[i][0] else: # 구석진 곳이 모자르면 지도에서 무작위로 좌표를 뽑아옴 ix, iy = self.np_find_empty_cell(entities, wall_map) if kinds == 'REG': i_comp = Item(use_function=heal, amount=10) item = self.create_item(ix, iy, '!', tcod.violet, '재생 물약', item=i_comp) elif kinds == 'FJ': i_comp = Item(use_function=heal, amount=15, which='sanity') item = self.create_item(ix, iy, '!', tcod.orange, '과일 주스', item=i_comp) elif kinds == 'SC': i_comp = Item(use_function=cast_spell, damage=(1, 30), maximum_range=8) item = self.create_item(ix, iy, '?', tcod.green, '마법 불꽃의 주문서', item=i_comp) elif kinds == 'FB': i_comp = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( SYS_LOG['target_message'], tcod.light_cyan), damage=(3, 8, 5), radius=3) item = self.create_item(ix, iy, '?', tcod.red, '화염 폭발의 주문서', item=i_comp) elif kinds == 'SCF': scarfs_list = { '보라': tcod.violet, '빨강': tcod.dark_red, '초록': tcod.green, '파랑': tcod.blue } from random import sample pick = sample(list(scarfs_list), 1)[0] if pick == '초록': resist = 60 else: resist = 50 e_comp = Equippable(EquipmentSlots.SCARF, sanity_resistance=resist) item = Entity(ix, iy, '>', scarfs_list[pick], f"{pick}색 목도리", _Equippable=e_comp) elif kinds == 'SWD': e_comp = Equippable(EquipmentSlots.WIELD, attack_power=5) item = Entity(ix, iy, '/', tcod.gray, "검", _Equippable=e_comp) elif kinds == 'SLD': e_comp = Equippable(EquipmentSlots.OUTFIT, defense_power=5) item = Entity(ix, iy, '}', tcod.lighter_gray, "방패", _Equippable=e_comp) elif kinds == 'FLW': e_comp = Equippable(EquipmentSlots.JEWELLERY, sanity_resistance=20) item = Entity(ix, iy, '*', tcod.white, "국화꽃 팔찌", _Equippable=e_comp) elif kinds == "AM": e_comp = Equippable(EquipmentSlots.JEWELLERY, sanity_resistance=-80, attack_power=10) item = Entity(ix, iy, '&', tcod.white, "어딘가 잘못된 목걸이", _Equippable=e_comp) entities.append(item) """
def tick(self, walls, projectiles, debug=False, **kwargs): # if debug: self._printinfo() for p in projectiles: if self.isCollidingWith(p): self.dead = True p.dead = True # For left and right: # If pushed and was not previously pushed: # Add movementModifier in appropriate direction # Note as currently pushed # Change facing direction # If not pushed: # if both directions are held: # take away movement modifier if self.buttons["left"]: if not self.held["left"]: if debug: print("left down") self.velocity[0] -= self._movementModifier self.held["left"] = True self.facing = "left" else: if self.held["left"] and self.held["right"]: self.velocity[0] += self._movementModifier elif self.held["left"]: self.velocity[0] = 0 self.held["left"] = False if self.buttons["right"]: if not self.held["right"]: if debug: print("right down") self.velocity[0] += self._movementModifier self.held["right"] = True self.facing = "right" else: if self.held["right"] and self.held["left"]: self.velocity[0] -= self._movementModifier elif self.held["right"]: self.velocity[0] = 0 self.held["right"] = False if self.buttons["jump"]: if not self.held["jump"] and self.onGround: if debug: print("jump down") self.velocity[1] -= self._jumpModifier self.held["jump"] = True self.onGround = False else: self.held["jump"] = False if self.buttons["down"]: if not self.held["down"]: if debug: print("down down") self.held["down"] = True else: self.held["down"] = False if self.buttons["attack"]: if not self.held["attack"]: self.held["attack"] = True self.shot = True else: self.held["attack"] = False if self.buttons["interact"]: if not self.held["interact"]: pass self.held["interact"] = True else: self.held["interact"] = False collisions = Entity.tick(self, walls, debug=debug) if collisions["right"] and self.held["right"]: self.held["right"] = False if collisions["left"] and self.held["left"]: self.held["left"] = False self.setMod()
def get_state(self): return {"wall_state": self.state, **Entity.get_state(self)}
def update(self, dt): Entity.update(self, dt)
def __init__(self, position, mailbox): Entity.__init__(self, position, mailbox)
def main(): # Screen size screen_width = 80 screen_height = 50 bar_width = 20 panel_height = 7 panel_y = screen_height - panel_height message_x = bar_width + 2 message_width = screen_width - bar_width - 2 message_height = panel_height - 1 # Map size map_width = 80 map_height = 43 # Map Rooms room_max_size = 10 room_min_size = 6 max_rooms = 30 # Visiblity fov_algorithm = 0 fov_light_walls = True fov_radius = 10 max_monsters_per_room = 3 colors = { 'dark_wall': libtcod.Color(0, 0, 100), 'dark_ground': libtcod.Color(50, 50, 150), 'light_wall': libtcod.Color(130, 110, 50), 'light_ground': libtcod.Color(200, 180, 50) } fighter_component = Fighter(hp=30, defense=2, power=5) player = Entity(0, 0, '@', libtcod.white, 'Player', blocks=True, render_order=RenderOrder.ACTOR, fighter=fighter_component) entities = [player] libtcod.console_set_custom_font( 'arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD) libtcod.console_init_root(screen_width, screen_height, 'libtcod tutorial reviesed', False, libtcod.RENDERER_SDL2, 'C', True) game_map = GameMap(map_width, map_height) game_map.make_map(max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities, max_monsters_per_room) fov_recompute = True fov_map = initialize_fov(game_map) message_log = MessageLog(message_x, message_width, message_height) con = libtcod.console_new(screen_width, screen_height) panel = libtcod.console_new(screen_width, panel_height) key = libtcod.Key() mouse = libtcod.Mouse() game_state = GameStates.PLAYERS_TURN while not libtcod.console_is_window_closed(): libtcod.sys_check_for_event( libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse) if fov_recompute: recompute_fov(fov_map, player.x, player.y, fov_radius, fov_light_walls, fov_algorithm) render_all(con, panel, entities, player, game_map, fov_map, fov_recompute, message_log, screen_width, screen_height, bar_width, panel_height, panel_y, mouse, colors) fov_recompute = False libtcod.console_flush() clear_all(con, entities) action = handle_keys(key) move = action.get('move') exit = action.get('exit') fullscreen = action.get('fullscreen') player_turn_results = [] if move and game_state == GameStates.PLAYERS_TURN: dx, dy = move destination_x = player.x + dx destination_y = player.y + dy if not game_map.is_blocked(destination_x, destination_y): target = get_blocking_entities_at_location( entities, destination_x, destination_y) if target: attack_results = player.fighter.attack(target) player_turn_results.extend(attack_results) else: player.move(dx, dy) fov_recompute = True game_state = GameStates.ENEMY_TURN if exit: return True if fullscreen: libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen()) for player_turn_result in player_turn_results: message = player_turn_result.get('message') dead_entity = player_turn_result.get('dead') if message: message_log.add_message(message) if dead_entity: if dead_entity == player: message, game_state = kill_player(dead_entity) else: message = kill_monster(dead_entity) message_log.add_message(message) if game_state == GameStates.ENEMY_TURN: for entity in entities: if entity.ai: enemy_turn_results = entity.ai.take_turn( player, fov_map, game_map, entities) for enemy_turn_result in enemy_turn_results: message = enemy_turn_result.get('message') dead_entity = enemy_turn_result.get('dead') if message: message_log.add_message(message) if dead_entity: if dead_entity == player: message, game_state = kill_player(dead_entity) else: message = kill_monster(dead_entity) message_log.add_message(message) if game_state == GameStates.PLAYER_DEAD: break if game_state == GameStates.PLAYER_DEAD: break else: game_state = GameStates.PLAYERS_TURN
def setUp(self): self.entity = Entity("Monster", 100)
import curses import time from entity import Entity screen = curses.initscr() curses.noecho() #turn off echoing input curses.cbreak() #don't wait for enter key height, width = screen.getmaxyx() win = curses.newwin(height, width, 0, 0) win.keypad(1) curses.curs_set(0) #Hide the blinking cursor player = Entity(10, 10, ord('@')) mob = [20, 20] colors = {'dark_wall': curses.COLOR_MAGENTA} key = curses.KEY_RIGHT while True: win.border(0) win.timeout(100) key = win.getch() if key == ord('q'): curses.nocbreak() screen.keypad(False) curses.echo()