Exemple #1
0
class AttackTest(unittest.TestCase):

    """Test Monster Class attack function"""

    def setUp(self):
        print(self.shortDescription())
        self.test_monster = Monster("The Boogie Monster")

    def test_ideal_attack(self):
        """test ideal attack, won't ko"""
        self.assertEqual(5, self.test_monster.attack(5))

    def test_kod_attack(self):
        """test kod attack"""
        self.test_monster.attack(15)
        self.assertEqual("K.O.'d", self.test_monster.status)

    def test_incorrect_type_attack(self):
        """test if we prevent bad types"""
        with self.assertRaises(TypeError):
            self.test_monster.attack("some bad types")

    def test_negative_healt(self):
        """we should test for negative health catches"""
        pass
class test_attack(unittest.TestCase):
    def setUp(self):
        self.monsta = Monster()
        print(self.shortDescription())

    #Tests if heal function works
    def test_attack_live(self):
        self.monsta.health = 6
        expected = 1
        actual = self.monsta.attack(5)
        self.assertEqual(expected, actual)

    #Heal function should not work if total > 10
    def test_attack_die(self):
        self.monsta.health = 4
        expected = -1
        actual = self.monsta.attack(5)
        self.assertEqual(expected, actual)

    #Tests if invalid output was printed
    @patch ('sys.stdout', new_callable=StringIO)
    def test_attack_die_KO(self, mock_stdout):
        health = self.monsta.health(4)

        expected = "K.O.'d"
        actual = self.monsta.attack(6)
        self.assertNotEqual(mock_stdout.getValue(), text)
Exemple #3
0
class AttackTest(unittest.TestCase):

    """Test Monster Class attack function"""

    def setUp(self):
        print(self.shortDescription())
        self.test_monster = Monster("The Boogie Monster")

    def test_ideal_attack(self):
        """test ideal attack, won't ko"""
        self.assertEqual(5, self.test_monster.attack(5))

    def test_kod_attack(self):
        """test kod attack"""
        self.test_monster.attack(15)
        self.assertEqual("K.O.'d", self.test_monster.status)

    def test_kod_attack_health(self):
        """test kod attack"""
        self.test_monster.attack(15)
        self.assertEqual(-5, self.test_monster.health)

    def test_incorrect_type_attack(self):
        """test if we prevent bad types"""
        with self.assertRaises(TypeError):
            self.test_monster.attack("some bad types")

    def test_negative_healt(self):
        """we should test for negative health catches"""
        pass
Exemple #4
0
class AttackTest(unittest.TestCase):
    """Test the functionality of the Monster class attack function."""

    def setUp(self):
        self.new_monster = Monster("Cookie")

    def tearDown(self):
        del self.new_monster

    def test_attack_stay_alive(self):
        """
        Initialize health to 10. Call function with 7 and check that 3 is
        returned and status is unchanged.
        """
        self.new_monster.health = 10
        original_status = self.new_monster.status

        # Call function
        new_health = self.new_monster.attack(7)

        self.assertEqual(new_health, 3,
                         "Expected 3 for updated health.")
        self.assertEqual(self.new_monster.status, original_status,
                         "Status should have remained {}".
                         format(original_status))

    def test_attack_ko_ed(self):
        """
        Initialize health to 10. Call function with 12 and check that -2 is
        returned and status is "K.O.'d".
        """

        self.new_monster.health = 10

        # Call function
        new_health = self.new_monster.attack(12)

        self.assertEqual(new_health, -2,
                         "Expected 3 for updated health.")
        self.assertEqual(self.new_monster.status, "K.O.'d",
                         "Status should be K.O.'d")
class test_attack(unittest.TestCase):
    def setUp(self):
        self.monsta = Monster()
        self.monsta.health = 5

    #Tests if heal function works
    def test_attack_live(self):
        health = self.monsta.attack(5)

        self.assertEqual(health, 0, "Attack did not work")

    #Heal function should not work if total > 10
    def test_attack_die(self):
        health = self.monsta.attack(6)

        self.assertEqual(health, -1, "Attack did not work")

    #Tests if invalid output was printed
    @patch('sys.stdout', new_callable=StringIO)
    def test_attack_die_KO(self, mock_stdout):
        health = self.monsta.attack(6)

        text = "That is not a valid input"
        self.assertNotEqual(mock_stdout.getValue(), text)
Exemple #6
0
    def spawn_monster(self):
        """Spawn a monster """
        """PRE:/
           POST: New object of class Monster. Add to the attribut 
        """
        monster = Monster(self)

        monster2 = Monster(self)
        monster2.rect.y = random.randint(100, 200)
        monster2.rect.x = 1300
        monster2.velocity = 1.5
        monster2.attack = 50
        monster2.image = pygame.image.load('im/dragon.png')

        self.all_monsters.add(monster, monster2)
Exemple #7
0
class test_heal(unittest.TestCase):
    def setUp(self):
        self.monsta = Monster()
        self.monsta.health = 5

    #Tests if monster heals
    def test_valid_heal(self):
        health = self.monsta.heal(5)

        self.assertEqual(health, 10, "Heal did not work")

    #Monster should not heal if sum > 10
    def test_invalid_heal(self):
        health = self.monsta.heal(6)

        self.assertNotEqual(health, 11, "Heal should not have worked")

    #Tests invalid output
    @patch('sys.stdout', new_callable=StringIO)
    def test_attack_die_KO(self, mock_stdout):
        health = self.monsta.attack(6)

        text = "Invalid heal amount"
        self.assertNotEqual(mock_stdout.getValue(), text)
Exemple #8
0
class test_heal(unittest.TestCase):
    def setUp(self):
        self.monsta = Monster()
        self.monsta.health = 5

    #Tests if monster heals
    def test_valid_heal(self):
        health = self.monsta.heal(5)

        self.assertEqual(health, 10, "Heal did not work")

    #Monster should not heal if sum > 10
    def test_invalid_heal(self):
        health = self.monsta.heal(6)

        self.assertNotEqual(health, 11, "Heal should not have worked")

    #Tests invalid output
    @patch ('sys.stdout', new_callable=StringIO)
    def test_attack_die_KO(self, mock_stdout):
        health = self.monsta.attack(6)

        text = "Invalid heal amount"
        self.assertNotEqual(mock_stdout.getValue(), text)
from monster import Monster

# Create monsters
player_name = input("What is your monster called? ")
you = Monster(player_name)
bad_guy = Monster("Doombeast")

# Describe the HP of both players
you.describe()
bad_guy.describe()

# Continue while both players are alive
while you.is_alive() and bad_guy.is_alive():

    # Monster's turn
    if bad_guy.is_alive():
        bad_guy.attack(you)
        you.describe()

    # Is the player now dead?
    if you.is_alive() == False:
        print("You lost :(")
    else:
        you.attack(bad_guy)

        # Describe the outcome
        bad_guy.describe()

        if bad_guy.is_alive() == False:
            print("You win!")
Exemple #10
0
you.describe()
you.describe_item()
bad_guy.describe()
bad_guy.describe_item()

# Continue while both players are alive
while you.is_alive() and bad_guy.is_alive():

    # Would you like to attack or defend?
    action = input("Would you like to attack (a) or defend (d)?")
    if action == "d":
        you.defend()

    # Monster's turn
    if bad_guy.is_alive():
        bad_guy.attack(you)
        you.describe()

    # Is the player now dead?
    if you.is_alive() == False:
        print("You lost :(")
    else:
        if action == "a":
            you.attack(bad_guy)
        elif action != "d":
            print("I don't know how to " + action)

        # Describe the outcome
        bad_guy.describe()

        if bad_guy.is_alive() == False:
Exemple #11
0
print(json.dumps(response, indent=2))

answer = response["output"]["generic"][0]["text"]
#print(actions[answer])

# Player picks up an item
if answer == 'pick-up':
    print('successfully picked up item')
    player.add_inventory('key')
    print(player.__dict__)
else:
    print('did not pick up')

# Monster attacks player
print('A monster jumped out and attack you.')
if monster.attack(player) <= 0:
    print('Game over.')
else:
    print(player.__dict__)

# Delete session
response = assistant.delete_session(assistant_id, session_id).get_result()

# Intents: Looking around (describe environment), Interact with object (picking up, putting down/activating/using), attacking
# For picking up actions think of an inventory system that keeps track of what you have picked up so far.
# Maybe add entities to Watson and only allow users to progress through the story by interacting with them.

# Questions:
# How do we do settings?
# We wanted the system to figure out the wording details: maybe have our NLP-model automatically upload intents to Watson to generate the wording. Want ways to have same meaning but with new flavor.
# For the first timebox: Have simple structure by filling up conversation nodes.
Exemple #12
0
 def attack(self, target):
     """Attack the target."""
     Monster.attack(self, Object.obj_dict[target])
class Room(object):
    def __init__(self, difficulty, player):

        self.hasMonster = False
        self.hasBoss = False
        self.hasChest = False
        self.isDone = False
        self.difficulty = difficulty
        self.settings = Settings()
        self.goal = self.settings.getGoal()
        self.player = player
        self.chest = Chest(self.player)
        self.monster = Monster()
        self.inspected = False
        self.handler = Stringhandler()
        self.boss = Endboss()
        self.endboss = self.boss.randomBoss(player)

    # Sets up a new Room and displays some "Intro Text"
    def newRoom(self):
        self.isDone = False
        string = "\n\n#######################################"+"\n\n"+\
        self.handler.strRoom("intro",self)+"\n\n"+\
        "#######################################"+"\n\n"
        for char in string:
            time.sleep(uniform(0.05, 0.01))
            sys.stdout.write('\033[35m' + char)
            sys.stdout.flush()

        print Fore.WHITE

        # Decides whether the room gets a monster or a chest
        if int(self.player.level) <= int(self.goal):
            rnd = random.randint(0, 10)
            if rnd > 1:
                self.hasMonster = True
            else:
                self.hasChest = True

            # Setup monster
            if self.hasMonster:
                if self.difficulty == "easy":
                    self.monster.setup(1, self.player.level)
                else:
                    self.monster.setup(2, self.player.level)

            # Setup chest
            elif self.hasChest:
                if self.difficulty == "easy":
                    self.chest.level = random.randint(1, 10)
                    return self.handler.strActions("roomEmpty", self.player,
                                                   self)
                else:
                    self.chest.level = random.randint(1, 10)
            else:
                self.finish()
        else:
            self.hasBoss = True

            return self.boss.spawn(self.player)

    def getRoom(self, difficulty, player):
        return Room(difficulty, player)

    def getBoss(self):
        return self.boss

    # If the player has used "look around" the room should be set to inspected
    def inspectRoom(self):
        self.inspected = True

    # Kills the monster in this Room, required for the player to be able to continue -> Room set to "Done"
    def killMonster(self):
        self.monster.kill()
        self.player.lvlUp()
        self.finish()

    def attackMonster(self, player):
        room = self
        return self.monster.attack(room, player)

    # Opens the chest, required for the player to be able to continue -> Room set to "Done"
    def openChest(self):
        self.finish()
        return self.chest.open(self.player)

    def is_done(self):
        return self.isDone

    def finish(self):
        self.isDone = True
        if self.hasChest:
            self.chest.is_opened = True
Exemple #14
0
def monster_fight(p):
    print("You encountered a Monster!")
    m = Monster(abs(int(rd.gauss(p.level * 100, p.level * 100 / 2))),
                abs(int(rd.gauss(p.level * 10, p.level * 10 / 2))))
    m.printSelf()
    win = -1
    while True:
        print()
        i = input(
            "Your move! Attack(1), Drink Potions(2), Try to Run(3), Check Stats(4): "
        )
        if is_int(i):
            i = int(i)
        else:
            continue
        if i == 1:
            last_hp = m.remaining_hp
            p.attack(m)
            print("You attacked! Monster's hp fell from ", last_hp, " to ",
                  m.remaining_hp)
        elif i == 2:
            t = False
            j = 0
            while not t:
                print("You have ", p.potions, " potions.")
                if p.potions == 0:
                    break
                j = input("How many do you want to drink (20hp per 1): ")
                if is_int(j):
                    j = int(j)
                    t = p.drink_potion(j)
            if j == 0:
                continue
            print("You drank ", j, " potions! Your new hp is ", p.remaining_hp)
        elif i == 3:
            dev = p.luck - p.level
            if dev < abs(int(rd.gauss(0, dev))):
                print("You were able to run away!")
                break
            else:
                print("You failed to run away!")
        elif i == 4:
            p.printSelf()
            continue
        else:
            continue

        if (m.remaining_hp <= 0):
            win = 1
            break

        last_hp = p.remaining_hp
        m.attack(p)
        print("The monster attacked you! Your hp fell from ", last_hp, " to ",
              p.remaining_hp)

        if (p.remaining_hp <= 0):
            win = 0
            break

    if win == 1:
        p.get_experience(m)
        del m
    elif win == 0:
        print("You Lost! The game is over!")
        exit()
Exemple #15
0
 def attack(self, target):
     """Attack the target."""
     Monster.attack(self, Object.obj_dict[target])
Exemple #16
0
class World:
    def run(self):
        self.player = Monster(name='Player')
        self._load_history(self.player)

        monster = random.choice(list(monsters.viewkeys()))
        self.monster = Monster(monsters[monster][0], monster, description=monsters[monster][1])
        self.ui = UI(self.player)
        self.ui.monster = self.monster

        self.ui.welcome()
        
        a = 1
        while a != 0:
            self._load_history(self.monster)

            a = self.run_loop()

            if a != 0:
                self.ui.update_display()

            self._save_history(self.player)
            self._save_history(self.monster)
            
            monster = random.choice(list(monsters.viewkeys()))
            self.monster = Monster(monsters[monster][0], monster, description=monsters[monster][1])
            self.ui.monster = self.monster

    def run_loop(self):
        player_move = "Run"
        while player_move.lower() != ACTION_QUIT:

            if self.player.offbalance:
                moves = [MOVE_BASH, MOVE_DEFEND]
            else:
                moves = [MOVE_ATTACK, MOVE_BASH, MOVE_DEFEND]
            if self.monster.offbalance:
                monster_moves = [MOVE_BASH, MOVE_DEFEND]
            else:
                monster_moves = [MOVE_ATTACK, MOVE_BASH, MOVE_DEFEND]

            player_move = self.ui.player_move(moves)

            if player_move == ACTION_QUIT:
                break
            if player_move not in moves:
                self.ui.msg = "I don't understand your input, try again."
                self.ui.update_display()
                continue

            monster_move = self.monster.attack(monster_moves, self.player)
            
            self.ui.monster.move = monster_move
            self.ui.player.move = player_move

            if player_move + monster_move in action_table:
                outcome = action_table[player_move + monster_move]
                self.monster.take_damage(outcome[2])
                self.monster.offbalance = outcome[3]
                self.player.take_damage(outcome[0])
                self.player.offbalance = outcome[1]
            else:
                outcome = action_table[monster_move + player_move]
                self.monster.take_damage(outcome[0])
                self.monster.offbalance = outcome[1]
                self.player.take_damage(outcome[2])
                self.player.offbalance = outcome[3]

            # record the moves just made for the AI
            self.player.history.append(player_move)
            self.monster.history.append(monster_move)

            self.ui.update_display()

            if self.player.is_dead() and self.monster.is_dead():
                self.ui.msg = "You have slain the foul " + self.monster.name + ", but it appears that, in its dying throes, the " + self.monster.name + "has also slain you."
                return 0
            elif self.player.is_dead():
                self.ui.msg = "Oh no! You seem to have perished!"
                return 0
            elif self.monster.is_dead():
                self.ui.msg = "You have slain the " + self.monster.name + "."
                return 1
        return 0

    def _load_history(self, monster):
        name = 'player'
        if monster.name.lower() != 'player':
            name = 'monster'

        try:
            f = open(name + '.moves', 'r+')
            monster.history = pickle.load(f)
            f.close()
        except Exception:
            pass

    def _save_history(self, monster):
        name = 'player'
        if monster.name.lower() != 'player':
            name = 'monster'

        try:
            f = open(name + '.moves', 'w+')
            print monster.name
            print len(monster.history)
            pickle.dump(monster.history, f)
            f.close()
        except Exception:
            pass
Exemple #17
0
        # Check for death.
        if enemy.is_dead():

            #The player has won.
            game_end("You won!")
            
    elif action == "2":
        # Do a especial attack.
        player.special_attack(enemy)

        # Check for death.
        if enemy.is_dead():

            #The player has won.
            game_end("You won!")

    elif action == "3":
        game_end("You just surrendered. Too bad! Waluigi time!")

    # Enemy's turn.
    enemy.attack(player)
    enemy_last_action = "\n\tThe " + enemy.get_name() + " attacked!\n"
    
    # Check for death.
    if player.is_dead():
        # The player has lost.
        game_end("You lost. Try again.")


    turn_count += 1