示例#1
0
def test_skill_check():
    wins = 0
    iters = 1000

    em = EntityManager()
    em.set_component(em.pc, SkillComponent())

    skills = em.get_component(em.pc, SkillComponent)
    # 7 has ~41% odds of success
    skills.skills['melee.swords.dagger'] = SkillSubComponent(7)

    sys = SkillSystem()
    sys.set_entity_manager(em)
    event.register(sys)

    for x in range(iters):
        ch = SkillCheckEvent(em.pc, "melee.swords.dagger")
        event.dispatch(ch)

        if ch.result[2]:
            wins += 1

    # Use a fudge factor, because random
    assert wins >= (iters * 0.38)
    assert wins <= (iters * 0.44)
示例#2
0
文件: base.py 项目: Kromey/roglick
 def explore(self):
     if not self._explored:
         self._explored = True
         if self.feature:
             msg = "You have found a {feature}!".format(
                     feature=self.feature.name)
             event.dispatch(MessageEvent(msg))
示例#3
0
    def move_handler(self, myevent):
        pos = self._entity_manager.get_component(self._entity_manager.pc, PositionComponent)
        pos.x += myevent.dx
        pos.y += myevent.dy

        if myevent.dx and myevent.dy:
            # Diagonal movement costs 1,400 Fatigue
            fatigue = 1400
        else:
            # Orthoganal movement costs 1,000 Fatigue
            fatigue = 1000

        event.dispatch(ActionCompleteEvent(myevent.entity, fatigue))
示例#4
0
文件: health.py 项目: Kromey/roglick
    def execute(self):
        # Can't kill an entity while iterating, so stash a list of deadites
        deadites = []

        for entity, components in self._entity_manager.get_entities_with_component(
                HealthComponent):
            health = components[HealthComponent]

            if health.hp <= 0:
                deadites.append(entity)

        for entity in deadites:
            self._entity_manager.destroy_entity(entity)
            event.dispatch(MessageEvent("{} dies!".format(entity)))
示例#5
0
    def _init_pc(self):
        # Get a random place to put the PC
        x,y = self._world.current_map.get_random_cell()
        pc_pos = components.PositionComponent(x, y)
        pc_sprite = components.SpriteComponent('@')

        self._entities.set_component(self._entities.pc, pc_pos)
        self._entities.set_component(self._entities.pc, pc_sprite)
        self._entities.set_component(self._entities.pc, components.FoVComponent())
        self._entities.set_component(self._entities.pc, components.FatigueComponent())
        self._entities.set_component(self._entities.pc, components.AttributesComponent(15,13,11,9))

        pc_skills = components.SkillsComponent()
        pc_skills['melee.swords.short_sword'] = components.SkillsComponent.Skill(12)
        self._entities.set_component(self._entities.pc, pc_skills)

        event.dispatch(SpawnEntityEvent(self._entities.pc))
示例#6
0
文件: health.py 项目: Kromey/roglick
    def dmg_handler(self, dmg_event):
        try:
            health = self._entity_manager.get_component(dmg_event.defender, HealthComponent)
        except exceptions.NoComponentForEntityError:
            # TODO How do we want to handle damaging Entities with no health?
            return

        dmg = 0
        # Different damage types have different multipliers; apply those now
        dmg += dmg_event.dmg.piercing * 0.8
        dmg += dmg_event.dmg.bludgeoning * 1.0
        dmg += dmg_event.dmg.slashing * 1.5
        dmg += dmg_event.dmg.impaling * 2.0

        # Round down any fractions
        dmg = int(dmg)

        # Now reduce damage from HP
        health.hp -= dmg
        # TODO: Temporary debugging log message
        event.dispatch(MessageEvent("You dealt {} damage to it!".format(dmg)))
示例#7
0
文件: level.py 项目: Kromey/roglick
    def map_handler(self, myevent):
        epos = self._dm._wm._em.get_component(myevent.entity, PositionComponent)

        if myevent.__class__ == MoveEvent:
            tx = epos.x + myevent.dx
            ty = epos.y + myevent.dy

            if not self.map.tiles[tx][ty].passable:
                # Illegal move, prevent this event from continuing
                myevent.stop()

                if self.map.tiles[tx][ty].feature == features.closed_door:
                    # Stopped the movement, but we can open this door
                    event.dispatch(OpenDoorEvent(myevent.entity, tx, ty))
        elif myevent.__class__ == ClimbDownEvent:
            if self.map.tiles[epos.x][epos.y] != features.stairs_down:
                # Can't descend without stairs, dummy!
                myevent.stop()
        elif myevent.__class__ == ClimbUpEvent:
            if self.map.tiles[epos.x][epos.y] != features.stairs_up:
                # Can't ascend without stairs, dummy!
                myevent.stop()
示例#8
0
文件: input.py 项目: Kromey/roglick
    def execute(self):
        """Wait for player input, dispatching appropriate events."""
        pc = self._entity_manager.pc

        pc_fatigue = self._entity_manager.get_component(pc, FatigueComponent)
        if pc_fatigue.fatigue > 0:
            # PC's still fatigued, need to wait until they can act
            return

        event.dispatch(PreInputEvent())

        key = self.get_keypress()

        if key == libtcod.KEY_ESCAPE or libtcod.console_is_window_closed():
            event.dispatch(QuitEvent())  #exit game

        # Movement keys
        if key in self.MOVEMENT_KEYS:
            event.dispatch(MoveEvent(pc, *self.MOVEMENT_KEYS[key]))
        elif key == '>':
            event.dispatch(ClimbDownEvent(pc))
        elif key == '<':
            event.dispatch(ClimbUpEvent(pc))
示例#9
0
    def open_door_handler(self, openevent):
        # Change the door Feature to an open door
        x, y = openevent.x, openevent.y
        self._world.current_map.tiles[x][y].add_feature(features.open_door)

        # Dispatch a new message
        event.dispatch(MessageEvent("You open the door"))

        # We've changed the map, signal that
        event.dispatch(MapChangedEvent())

        # Now dispatch the ActionCompleteEvent; 1000 Fatigue to open a door
        event.dispatch(ActionCompleteEvent(openevent.entity, 1000))