def manualFight():
monster = Monster(skill=getParam("skill"), stamina=getParam("stamina"))
monster_bonus = getParam("monsterBonus")
player_bonus = getParam("playerBonus")
round = getParam("round")
monster_attack = rollDices(dices=2, offset=monster.skill)
player_attack = rollDices(dices=2, offset=player.skill)
if player_attack > monster_attack:
monster.updateStamina(monster_bonus - 2)
winner = "player"
elif monster_attack > player_attack:
player.updateStamina(player_bonus - 2)
winner = "monster"
else:
winner = "nobody"
return render_template(
"manualFight.html",
player=player,
player_bonus=player_bonus,
monster=monster,
monster_bonus=monster_bonus,
round=round,
winner=winner,
)
def make_new_monster(self):
level = self.player.level
assert level > 0
if level > 5 and self.player.location_in_wild == 'forest':
level = 5
elif level > 10 and self.player.location_in_wild == 'orc':
level = 10
elif level < 5 and self.player.location_in_wild == 'orc':
level = 5
elif level > 15 and self.player.location_in_wild == 'plains':
level = 15
elif level < 10 and self.player.location_in_wild == 'plains':
level = 10
if level < 15 and self.player.location_in_wild == 'mountain':
level = 15
# Level scales from 15 to 100 in mountains.
self.monster = Monster(level=level,
location=self.player.location_in_wild)
self.monster.generate_char(boss=False)
self.monster_hp = self.monster.monster_hp
self.monster_mana = self.monster.monster_mana
self.max_monster_hp = self.monster.max_monster_hp
self.monster_buff = self.monster.monster_buff
self.monster_stun_left = self.monster.monster_stun_left
self.turns_to_unbuff_mons = self.monster.turns_to_unbuff_mons
self.monster_damage = self.monster.monster_damage
self.monster_abilities = self.monster.monster_abilities
self.combat()
def __init__(self):
h = Human(100, 35)
m = Monster(100)
while ((h.life > 0) and (m.life > 0)):
w = input("Choose your weapon (Sword or Fireball):")
while (w != "Sword") and (w != "Fireball"):
print("Your choice of weapon is not valid!")
w = input("Choose your weapon (Sword or Fireball):")
h.setWeapon(w)
m.life -= h.damage()
m.printData()
h.life -= m.damage()
h.printData()
if h.life <= 0:
h.loseStatus = True
print("Human lost with below results:")
h.printData()
print("Monster won!")
m.printData()
else:
m.loseStatus = True
print("Monster lost with below results:")
m.printData()
print("Human won!")
h.printData()
def add_monster(self):
monster = Monster(370, 300, 0.2, self.display, self.bricks,
self.gravity)
self.monsters.append(monster)
monster = Monster(320, 300, 0.2, self.display, self.bricks,
self.gravity)
self.monsters.append(monster)
class Test_Attack(unittest.TestCase):
"""Test if the mosnter can be attacked and checks for damage correctly"""
def setUp(self):
self.pawn = Monster("pawn")
print("Running: ", str(self._testMethodName) + "\n " + str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_takes_damage(self):
"""Test if health goes down"""
self.pawn.health = 10
self.assertEqual(self.pawn.attack(3), 7)
def test_is_k_o_d(self):
"""Tests if Status Changes"""
self.pawn.health = 5
self.pawn.attack(5)
self.assertEqual(self.pawn.status, "K.O.'d")
def test_junk_damage(self):
"""Test if it doesn't crash"""
self.pawn.health = 10
self.assertEqual(self.pawn.attack("adf"), 10)
class Test_Attack(unittest.TestCase):
"""Test if the mosnter can be attacked and checks for damage correctly"""
def setUp(self):
self.pawn = Monster("pawn")
print("Running: ", str(self._testMethodName) + "\n " + str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_scores_points(self):
"""Test if victory points goes up"""
self.pawn.victory_points = 10
self.assertEqual(self.pawn.score(5), 15)
def test_winning(self):
"""Tests if Status Changes to WINNING"""
self.pawn.victory_points = 5
self.pawn.score(15)
self.assertEqual(self.pawn.status, "WINNING")
def test_junk_score(self):
"""Test if it doesn't crash on bad data"""
self.pawn.victory_points = 10
self.assertEqual(self.pawn.score("adf"), 10)
class Test_In_Tokyo(unittest.TestCase):
"""Test the in_tokyo function to see if it responds correctly"""
def setUp(self):
self.pawn = Monster("pawn")
print(
"Running: ",
str(self._testMethodName) + "\n " +
str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_is_in_tokyo(self):
"""Can it see if the monsster is in tokyo"""
self.pawn.status = "In Tokyo"
self.assertEqual(self.pawn.in_tokyo(), True)
def test_isnt_in_tokyo(self):
"""Can it see if the monster isn't in tokyo"""
self.pawn.status = "Sleeping"
self.assertEqual(self.pawn.in_tokyo(), False)
def test_isnt_a_string(self):
"""Can it not break if the value is miss set"""
self.pawn.status = 321
self.assertEqual(self.pawn.in_tokyo(), False)
def create_monster(ai_settings, screen, monsters, monster_number, row_number):
# Create an monster and place it in the row.
monster = Monster(ai_settings, screen)
monster_width = monster.rect.width
monster.x = monster_width + 2 * monster_width * monster_number
monster.rect.x = monster.x
monster.rect.y = monster.rect.height + 2 * monster.rect.height * row_number
monsters.add(monster)
def do_combat(self):
monster = Monster(self.player.level,
location=self.player.location_in_wild)
monster.generate_char(boss=False)
combat = Combat(monster, player=self.player)
leave = combat.combat()
return leave
def __init__(self, pos: Vector, level, player):
Monster.__init__(self, pos, level, player)
#other attributes etc inherited from Monster
self.columns = 2
self.spriteSheet = simplegui.load_image(
'https://i.imgur.com/OFzdNYI.png')
self.spriteSheetWidth = 256
self.acc = 1
def get_monster(self, name):
if self.killed == self.depth - 1:
boss = True
if self._boss:
name = self._boss
else:
boss = False
if self.has_monsters():
monster = Monster(self.depth, name, boss)
monster.level = self
return monster
def initMonster():
global monsters
print('初始化怪物...')
monster1 = Monster('哥不灵', 50)
monster2 = Monster('僵尸', 50)
monster3 = Monster('牛头人', 50)
monster4 = Monster('孙铭琦', 200)
monster5 = Monster('纳什男爵', 1000)
monsters.append(monster1)
monsters.append(monster2)
monsters.append(monster3)
monsters.append(monster4)
monsters.append(monster5)
def fightChance():
monster = Monster(skill=getParam("skill"), stamina=getParam("stamina"))
monster_bonus = getParam("monsterBonus")
player_bonus = getParam("playerBonus")
round = getParam("round")
winner = getParam("winner")
chance_result = chance()
if winner == "player":
if chance_result:
monster.updateStamina(-2)
else:
monster.updateStamina(1)
elif winner == "monster":
if chance_result:
player.updateStamina(1)
else:
monster.updateStamina(-1)
return render_template(
"fightChance.html",
player=player,
player_bonus=player_bonus,
monster=monster,
monster_bonus=monster_bonus,
round=round,
winner=winner,
chance_result=chance_result,
)
class TestHero(unittest.TestCase):
def setUp(self):
self.monster = Monster()
def test_damage_true(self):
self.assertEqual(self.monster.damage(), 208)
def test_damage_false(self):
self.assertEqual(self.monster.damage(), 196)
def test_spell_true(self):
self.assertEqual(self.monster.spell(), 161)
def test_spell_false(self):
self.assertEqual(self.monster.spell(), 342)
def __init__ (self, numMonsters): super().__init__() self.numMonsters = numMonsters self.monstersArray = [] for x in range(0,numMonsters): self.monstersArray.append(Monster(randint(0,4))) self.monstersArray[x].add_observer(self)
def __init__(self, filename):
with open(filename, 'r') as f:
l = f.readline().split()
self.width = int(l[0])
self.height = int(l[1])
l = f.readline().split()
self.avatar = Avatar(int(l[0]), int(l[1]), int(l[2]), int(l[3]),
float(l[4]))
self.tiles = [[None for i in range(self.height)]
for j in range(self.width)]
for i in range(self.height - 1, -1, -1):
l = f.readline().split()
for j in range(0, self.width):
self.tiles[j][i] = Tile(l[j])
#print(self.tiles[j][i].name)
self.mons = []
for line in f:
l = line.split()
if len(l) == 6:
m = Monster(self, l[0], int(l[1]), int(l[2]), int(l[3]),
int(l[4]), int(l[5]))
t = threading.Thread(target=m.run)
self.mons.append(m)
t.start()
f.close()
self.lock = threading.Lock()
StdDraw.setCanvasSize(self.width * Tile.SIZE, self.height * Tile.SIZE)
StdDraw.setXscale(0.0, self.width * Tile.SIZE)
StdDraw.setYscale(0.0, self.height * Tile.SIZE)
StdDraw.setFontSize(12)
StdDraw.setPenColor(StdDraw.RED)
def create_monsters(self):
monster_count = 3 + roll_dice(3) - 1
# determining monster levels(by predefined chances), creating monsters
for _ in range(monster_count):
self.monsters.append(Monster(generate_monster_level(self.level)))
# and for the boss
self.boss = Boss(generate_monster_level(self.level))
# let's add the boss to the monsters list, just for simplicity
self.monsters.append(self.boss)
# finding random floors for placing the monsters
placed_floors = []
# this process includes the boss too, hence monster_count+1
while len(placed_floors) < monster_count + 1:
# 63 is the number of empty floors on the map
rolled_dice = roll_dice(63)
if rolled_dice == 1:
continue
if rolled_dice not in placed_floors:
# placing the monster at floor
x, y = self.map.get_nth_floor(rolled_dice)
self.monsters[len(placed_floors) - 1].place(x, y)
placed_floors.append(rolled_dice)
# giving the key to the next area, to one of the 3 monsters
key_holder = roll_dice(monster_count) - 1
self.monsters[key_holder].give_the_key()
def test_hero_properties_default(self):
h = Hero()
h.lvl = 7
h.maxHp = 100
h.nowHp = 75
h.maxXp = 40
h.nowXp = 20
h.gold = 100
h.attackLvl = 5
h.defenseLvl = 6
h.zoneVisitCounts = {ZoneDefinitionFields.ASTEROID_FIELD:3,ZoneDefinitionFields.CAVE:11}
h.zone = Zone(ZoneDefinitionFields.EMPTY_SPACE)
h.monster = Monster(MonsterDefinitionFields.AMBUSH_PIRATES)
h.shipName = "USS KickAss"
self.assertEqual(h.lvl,7)
self.assertEqual(h.maxHp,100)
self.assertEqual(h.nowHp,75)
self.assertEqual(h.maxXp,40)
self.assertEqual(h.nowXp,20)
self.assertEqual(h.gold,100)
self.assertEqual(h.attackLvl,5)
self.assertEqual(h.defenseLvl,6)
self.assertDictEqual(h.zoneVisitCounts,{ZoneDefinitionFields.ASTEROID_FIELD:3,ZoneDefinitionFields.CAVE:11})
self.assertEqual(h.zone.definitionKey,ZoneDefinitionFields.EMPTY_SPACE)
self.assertEqual(h.monster.definitionKey,MonsterDefinitionFields.AMBUSH_PIRATES)
self.assertEqual(h.shipName,"USS KickAss")
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((1280, 800))
self.area = self.screen.get_rect()
self.walls = Wall.gather_walls()
self.my_clock = pygame.time.Clock() # Utility object
self.background = Background() # Objects we put on screen
self.character = Character(self.area)
self.all_but_background = PgGroup((self.character, self.walls))
self.monsters = Monster.spawn_monsters(self.character, self.walls, ((ChampionMeleeMonster, 15), (Monster, 30),
(RangeMonster, 25)))
# So we can call each monster's attack method.
self.monster_group = PgGroup(self.monsters)
# Used to update everything to screen.
self.all_sprites = PgGroup((self.character, self.monsters, self.background, self.walls))
# Used to draw. We separate background so we can ensure it gets pictured before other things.
self.all_but_background.add(self.monsters)
self.time_test = False # Changed things in while loop so need to recreate timetest.
self.time_dict = {'drawmove': 0, 'abilitydraw': 0, 'eventloop': 0, 'attacks': 0, 'collisions': 0,
'move': 0, 'clear/recover': 0, 'drawbars': 0}
self.loop_counter = 0
self.find_key = {K_LSHIFT: 0, K_SPACE: 1, LEFT: 2, RIGHT: 3}
def runGame(self):
self.connectAndLevelUp()
[self.fight(self.heroes[name], Monster()) for name in self.heroes]
if not self.singleConnect:
self.gameTimer = threading.Timer(60 * 6, self.runGame)
self.gameTimer.start()
def monster(self):
if not self._monster:
if self.get_dbFields().MONSTER in self.dict:
self._monster = Monster.construct_model_from_dict(
self.dict[self.get_dbFields().MONSTER])
else:
return None
return self._monster
def test_monster_properties_default(self):
m = Monster(MonsterDefinitionFields.AMBUSH_PIRATES)
m.nowHp = 100
m.maxHp = 150
m.lvl = 15
self.assertEqual(m.nowHp, 100)
self.assertEqual(m.maxHp, 150)
self.assertEqual(m.get_baseXpReward(), 1)
self.assertEqual(m.get_treasureDropRate(), .1)
self.assertEqual(m.definitionKey,
MonsterDefinitionFields.AMBUSH_PIRATES)
self.assertEqual(len(m.get_treasureDrops()), 0)
self.assertEqual(m.get_name(), "Sneaky Ambush Pirates")
self.assertEqual(
m.get_description(), "These Sneaky Pirates hide behind asteroids "
"and surprise you. They're sorta like deadlines.")
def getHouseStatus(self):
"""Prints the Home's Monster Pop and Monster Info"""
print("House Population: " + str(self.player.location.population))
for monsters in self.player.__location.thrall:
if Monster.__instancecheck__(monsters):
print(str(monsters.name) + ": Health: " + str(monsters.health))
print(" ")
def load(self):
FILE = open(self.name, 'r')
for string in FILE:
x = string.split()
monster_name = x[0]
level = int(x[1])
self.dic[monster_name] = Monster(monster_name, level, int(x[2]),
int(x[3]))
return self.dic
def update(self, monster):
num = self.monstersArray.index(monster)
print(self.monstersArray[num].get_name(), "has been slain!")
self.monstersArray.remove(monster)
self.monstersArray.insert(num, Monster(0))
self.monstersArray[num].add_observer(self)
if all( x.get_mtype() is 0 for x in self.monstersArray):
print("House has been cleared!")
super().update(self)
def doFight():
monster = Monster(skill=getParam("skill"), stamina=getParam("stamina"))
monster_bonus = getParam("monsterBonus")
player_bonus = getParam("playerBonus")
rounds = [
{
"player_stamina": player.stamina,
"monster_stamina": monster.stamina,
"player_score": "-",
"monster_score": "-",
"winner": "-",
}
]
round = 0
while monster.stamina > 0 and player.stamina > 0:
round += 1
monster_attack = rollDices(dices=2, offset=monster.skill)
player_attack = rollDices(dices=2, offset=player.skill)
if player_attack > monster_attack:
monster.updateStamina(monster_bonus - 2)
winner = "player"
elif monster_attack > player_attack:
player.updateStamina(player_bonus - 2)
winner = "monster"
else:
winner = "nobody"
rounds.append({
"player_stamina": player.stamina,
"monster_stamina": monster.stamina,
"player_score": player_attack,
"monster_score": monster_attack,
"winner": winner,
})
if player.stamina <= 0:
end = "Le joueur est mort ..."
else:
end = "Le monstre est mort !"
return render_template("fight.html", rounds=rounds, end=end)
def load(self):
file = open(self.name, 'r')
for string in file:
string = string.split()
monster_name = string[0]
level = int(string[1])
self.monster_list[monster_name] = Monster(monster_name, level,
int(string[2]),
int(string[3]))
return self.monster_list
def test_monster_properties_default(self):
m = Monster(MonsterDefinitionFields.AMBUSH_PIRATES)
m.nowHp = 100
m.maxHp = 150
m.lvl = 15
self.assertEqual(m.nowHp,100)
self.assertEqual(m.maxHp,150)
self.assertEqual(m.get_baseXpReward(),1)
self.assertEqual(m.get_treasureDropRate(),.1)
self.assertEqual(m.definitionKey,MonsterDefinitionFields.AMBUSH_PIRATES)
self.assertEqual(len(m.get_treasureDrops()), 0)
self.assertEqual(m.get_name(),"Sneaky Ambush Pirates")
self.assertEqual(m.get_description(),"These Sneaky Pirates hide behind asteroids "
"and surprise you. They're sorta like deadlines.")
def create_LaunchingStage():
global bison, monster, gaugebar, gaugepoint, background, ground, grass
bison = Bison()
monster = Monster()
gaugebar = GaugeBar()
gaugepoint = GaugePoint()
background = Background()
grass = Grass()
ground = Ground()
load_HittingSound()
load_SuccessSound()
pass
class Test_Reset(unittest.TestCase):
"""Checks if the game is in a state where it can advance"""
def setUp(self):
self.pawn = Monster("pawn")
print("Running: ", str(self._testMethodName) + "\n " + str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_reset_status(self):
"""Resets Monsters status to 'Out of Tokyo'"""
self.pawn.status = "K.O.'d"
self.pawn.reset()
self.assertEqual(self.pawn.status, "Out of Tokyo")
def test_reset_health(self):
"""Resets Monsters Health to 10"""
self.pawn.health = 10000
self.pawn.reset()
self.assertEqual(self.pawn.health, 10)
def test_reset_victory(self):
"""Resets Monsters Victory Points to 0"""
self.pawn.victory_points = -12
self.pawn.reset()
self.assertEqual(self.pawn.victory_points, 0)
class Test_Heal(unittest.TestCase):
"""Test that the heal function works"""
def setUp(self):
self.pawn = Monster("pawn")
print("Running: ", str(self._testMethodName) + "\n " + str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_heal_to_ten(self):
"""Test to see if it heals the monster"""
self.pawn.health = 5
self.pawn.heal(5)
self.assertEqual(self.pawn.health, 10)
def test_heal_to_twenty(self):
"""Test to see if it doesn't heal past 10"""
self.pawn.health = 10
self.pawn.heal(10)
self.assertEqual(self.pawn.health, 10)
def test_heal_to_junk_data(self):
"""Test to see if it doesn't crash at junk"""
self.pawn.health = 5
self.pawn.heal('as')
self.assertEqual(self.pawn.health, 5)
class Test_Heal(unittest.TestCase):
"""Test that the heal function works"""
def setUp(self):
self.pawn = Monster("pawn")
print("Running: ", str(self._testMethodName) + "\n " + str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_heal_to_ten(self):
"""Test to see if it heals the monster"""
self.pawn.health = 5
self.pawn.heal(5)
self.assertEqual(self.pawn.health, 10)
def test_heal_to_twenty(self):
"""Test to see if it doesn't heal past 10"""
self.pawn.health = 10
self.pawn.heal(10)
self.assertEqual(self.pawn.health, 10)
def test_heal_to_junk_data(self):
"""Test to see if it doesn't crash at junk"""
self.pawn.health = 5
self.pawn.heal("as")
self.assertEqual(self.pawn.health, 5)
def initialize(self):
# We use the integer 1-7 to represent the keys for corresponding caves, and the integer -1 to represent the artifact.
self._monsters[0] = Monster(1, random.randint(3, 7) * 10)
self._monsters[0].set_pos(4, 1)
self._monsters[0].add_drop_item(2)
self._monsters[0].add_drop_item(3)
self._monsters[1] = Monster(2, random.randint(3, 7) * 10)
self._monsters[1].set_pos(3, 3)
self._monsters[1].add_drop_item(3)
self._monsters[1].add_drop_item(6)
self._monsters[1].add_hint(1)
self._monsters[1].add_hint(5)
self._monsters[2] = Monster(3, random.randint(3, 7) * 10)
self._monsters[2].set_pos(5, 3)
self._monsters[2].add_drop_item(4)
self._monsters[2].add_hint(1)
self._monsters[2].add_hint(2)
self._monsters[3] = Monster(4, random.randint(3, 7) * 10)
self._monsters[3].set_pos(5, 5)
self._monsters[3].add_hint(3)
self._monsters[3].add_hint(6)
self._monsters[4] = Monster(5, random.randint(3, 7) * 10)
self._monsters[4].set_pos(1, 4)
self._monsters[4].add_drop_item(2)
self._monsters[4].add_drop_item(6)
self._monsters[5] = Monster(6, random.randint(3, 7) * 10)
self._monsters[5].set_pos(3, 5)
self._monsters[5].add_drop_item(4)
self._monsters[5].add_drop_item(7)
self._monsters[5].add_hint(2)
self._monsters[5].add_hint(5)
self._monsters[6] = Monster(7, random.randint(3, 7) * 10)
self._monsters[6].set_pos(4, 7)
self._monsters[6].add_drop_item(-1)
self._monsters[6].add_hint(6)
for i in range(7):
self._map.add_object(self._monsters[i])
self._soldier.set_pos(1, 1)
self._soldier.add_key(1)
self._soldier.add_key(5)
self._map.add_object(self._soldier)
self._spring.set_pos(7, 4)
self._map.add_object(self._spring)
class Test_Reset(unittest.TestCase):
"""Checks if the game is in a state where it can advance"""
def setUp(self):
self.pawn = Monster("pawn")
print(
"Running: ",
str(self._testMethodName) + "\n " +
str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_reset_status(self):
"""Resets Monsters status to 'Out of Tokyo'"""
self.pawn.status = "K.O.'d"
self.pawn.reset()
self.assertEqual(self.pawn.status, "Out of Tokyo")
def test_reset_health(self):
"""Resets Monsters Health to 10"""
self.pawn.health = 10000
self.pawn.reset()
self.assertEqual(self.pawn.health, 10)
def test_reset_victory(self):
"""Resets Monsters Victory Points to 0"""
self.pawn.victory_points = -12
self.pawn.reset()
self.assertEqual(self.pawn.victory_points, 0)
def initialize(self):
self.monsters[0] = Monster(1, random.randint(0, 4) * 10 + 30)
self.monsters[0].setPos(4, 1)
self.monsters[0].addDropItem(2)
self.monsters[0].addDropItem(3)
self.monsters[1] = Monster(2, random.randint(0, 4) * 10 + 30)
self.monsters[1].setPos(3, 3)
self.monsters[1].addDropItem(3)
self.monsters[1].addDropItem(6)
self.monsters[1].addHint(1)
self.monsters[1].addHint(5)
self.monsters[2] = Monster(3, random.randint(0, 4) * 10 + 30)
self.monsters[2].setPos(5, 3)
self.monsters[2].addDropItem(4)
self.monsters[2].addHint(1)
self.monsters[2].addHint(2)
self.monsters[3] = Monster(4, random.randint(0, 4) * 10 + 30)
self.monsters[3].setPos(5, 5)
self.monsters[3].addHint(3)
self.monsters[3].addHint(6)
self.monsters[4] = Monster(5, random.randint(0, 4) * 10 + 30)
self.monsters[4].setPos(1, 4)
self.monsters[4].addDropItem(2)
self.monsters[4].addDropItem(6)
self.monsters[5] = Monster(6, random.randint(0, 4) * 10 + 30)
self.monsters[5].setPos(3, 5)
self.monsters[5].addDropItem(4)
self.monsters[5].addDropItem(7)
self.monsters[5].addHint(2)
self.monsters[5].addHint(5)
self.monsters[6] = Monster(7, random.randint(0, 4) * 10 + 30)
self.monsters[6].setPos(4, 7)
self.monsters[6].addDropItem(-1)
self.monsters[6].addHint(6)
self.map.addObject(self.monsters)
self.soldier.setPos(1,1)
self.soldier.addKey(1)
self.soldier.addKey(5)
self.map.addObject(self.soldier)
self.spring.setPos(7, 4)
self.map.addObject(self.spring)
def create_fleet(ai_settings, screen, arrow, monsters):
"""Create a full fleet of aliens."""
# Create an alien and find the number of aliens in a row.
# Spacing between each alien is equal to one alien width.
monster = Monster(ai_settings, screen)
number_monsters_x = get_number_monsters_x(ai_settings, monster.rect.width)
number_rows = get_number_rows(ai_settings, arrow.rect.height,
monster.rect.height)
# Create the fleet of aliens.
for row_number in range(number_rows):
for monster_number in range(number_monsters_x):
create_monster(ai_settings, screen, monsters, monster_number, row_number)
class Test_In_Tokyo(unittest.TestCase):
"""Test the in_tokyo function to see if it responds correctly"""
def setUp(self):
self.pawn = Monster("pawn")
print("Running: ", str(self._testMethodName) + "\n " + str(self.shortDescription()) + "\n")
def tearDown(self):
del self.pawn
def test_is_in_tokyo(self):
"""Can it see if the monsster is in tokyo"""
self.pawn.status = "In Tokyo"
self.assertEqual(self.pawn.in_tokyo(), True)
def test_isnt_in_tokyo(self):
"""Can it see if the monster isn't in tokyo"""
self.pawn.status = "Sleeping"
self.assertEqual(self.pawn.in_tokyo(), False)
def test_isnt_a_string(self):
"""Can it not break if the value is miss set"""
self.pawn.status = 321
self.assertEqual(self.pawn.in_tokyo(), False)
def check_in_and_get_notices(heroPk,accountPk,checkinTimeUtc,utcOffset):
"""
this should be called on page load and should be used to get any notices
for the use
args:
heroPk:
we want a pymongo objectId for the hero table
accountPk:
we want a pymongo objectId for the hero table
checkinTimeUtc:
this needs to be that the user check in and it needs to be utc
utcOffset:
the time-zone offset from UTC, in minutes, for the current locale.
returns:
we return a dict with two elements: 'story' which will be a list of
huge things of text and 'zoneChoice' which is a list of dicts each
of which contain 'zonePk','description'
but zoneChoice may be none.
"""
from Hero import Hero
from Account import Account
hero = Hero.construct_model_from_pk(heroPk)
account = Account.construct_model_from_pk(accountPk)
lastCheckinTime = account.lastCheckInTime
account.lastCheckInTime = checkinTimeUtc
account.save_changes()
if not lastCheckinTime:
messages = build_first_time_checkin_messages(hero)
hero.save_changes()
return messages
if hero.isInZoneLimbo:
autoPickedZoneDict = random.choice(hero.zone.nextZoneReferenceList)
hero.zone = Zone.construct_model_from_dict(autoPickedZoneDict)
hero.monster = Monster.construct_new_monster(hero.zone.definitionKey,hero.zone.lvl)
timeDiffInDays = (checkinTimeUtc - lastCheckinTime)/(60*60*24)
if timeDiffInDays >= 1:
pass
def test_get_random_monster_definitionKey(self): random.choice = MonkeyPatches.mock_choice k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'cloudfortress') k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'mScout') k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'mech') k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'pirate') k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'poisonCloud') k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'smallasteroid') k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'spaceman') k = Monster.get_random_monster_definitionKey(ZoneDefinitionFields.GAS) self.assertEqual(k,'spaceslime') self.assertRaises(StopIteration,Monster.get_random_monster_definitionKey,ZoneDefinitionFields.GAS)
def test_monster_properties_from_dict(self):
hpk = dbHelp.setup_test_hero_using_default_values()
md = dbHelp.create_test_monster_dict()
m = Monster.construct_model_from_dict(md)
self.assertEqual(m.nowHp,100)
self.assertEqual(m.maxHp,150)
self.assertEqual(m.get_baseXpReward(),1)
self.assertEqual(m.get_treasureDropRate(),.1)
self.assertEqual(m.definitionKey,MonsterDefinitionFields.AMBUSH_PIRATES)
self.assertEqual(len(m.get_treasureDrops()), 0)
self.assertEqual(m.get_name(),"Sneaky Ambush Pirates")
self.assertEqual(m.get_description(),"These Sneaky Pirates hide behind asteroids "
"and surprise you. They're sorta like deadlines.")
oldCount = tu.get_record_count_from_table(MonsterDbFields.COLLECTION_NAME)
m.save_changes(hpk)
newcount = tu.get_record_count_from_table(MonsterDbFields.COLLECTION_NAME)
self.assertEqual(oldCount,newcount)
def setUp(self):
self.pawn = Monster("pawn")
print("Running: ", str(self._testMethodName) + "\n " + str(self.shortDescription()) + "\n")
def create_test_monster_obj(monsterkey=None): monsterDict = create_test_monster_dict(monsterkey) monsterObj = Monster.construct_model_from_dict(monsterDict) return monsterObj
def test_construct_new_monster(self): random.choice = MonkeyPatches.mock_choice_first_index random.randint = lambda l,h: 3 m = Monster.construct_new_monster(ZoneDefinitionFields.GAS,10) self.assertEqual(m.lvl,13)
