class SpellTest(unittest.TestCase): def setUp(self): self.my_spell = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2) def test_create_spell(self): self.assertTrue(isinstance(self.my_spell, Spell)) def test_get_name(self): self.assertEqual(self.my_spell.get_name(), "Fireball") def test_get_damage(self): self.assertEqual(self.my_spell.get_damage(), 30) def test_get_mana_cost(self): self.assertEqual(self.my_spell.get_mana_cost(), 50) def test_get_cast_range(self): self.assertEqual(self.my_spell.get_cast_range(), 2) def test_dunder_str(self): self.assertEqual(str(self.my_spell), "Fireball") def test_dunder_repr(self): self.assertEqual(repr(self.my_spell), "Fireball")
def __init__(self, name, manaCost, power, tough, ctype, subtype=""): Spell.__init__(self, name, manaCost) self.power = power self.tough = tough self.ctype = ctype self.subtype = subtype self.summoningSickness = True self.attacking = False self.blocking = False
class WeaponTest(unittest.TestCase): def setUp(self): self.spell = Spell("Abracadabra", 100, 11, 15) def test_damage(self): self.assertEqual(self.spell.get_damage(), 100) def test_name(self): self.assertEqual(self.spell.get_name(), 'Abracadabra') def test_mana_cost(self): self.assertEqual(self.spell.get_mana_cost(), 11) def test_cast_range(self): self.assertEqual(self.spell.get_cast_range(), 15)
def __str__(self): ret = Spell.__str__(self) sub = "" if self.subtype != "": sub = " " + self.subtype ret = ret + " | Creature - %s%s | %d/%d"%(self.ctype, sub, self.power, self.tough) return ret
def __init__(self, group_inst, callback): builder = gtk.Builder() builder.add_from_file(GLADE_GTXT) self.callback = callback self.group_doc = builder.get_object('group_text') self.group_title = builder.get_object('group_title') self.group_inst = group_inst self.buffer = builder.get_object('overview1').get_buffer() pango_font = pango.FontDescription("monospace") builder.get_object('overview1').modify_font(pango_font) self.__prj_preview = PreviewEditor( self.buffer, builder.get_object('scroll_webkit1')) self.buffer.set_text(group_inst.docs) self.group_title.set_text(group_inst.title) builder.get_object("overview1").connect("key-press-event", self.on_key_press_event) builder.get_object("button2").connect("button-press-event", self._save) builder.get_object("button3").connect("button-press-event", self._cancel) builder.get_object('title').set_text(group_inst.name) if PREVIEW_ENABLED: self.__prj_preview.enable() else: self.__prj_preview.disable() self.__spell = Spell(builder.get_object('overview1')) self.group_doc.connect('delete-event', self.on_delete_event) self.group_doc.connect('destroy-event', self.on_destroy_event) self.group_doc.show()
class QueryHandler: def __init__(self): self.sp = Spell(settings.SPELL_WORDS_NUM) self.index = DirectIndex(settings.DIRECT_INDEX_PATH) self.searcher = Searcher(os.path.join(settings.INVERSE_INDEX_DIR, "index.txt"), os.path.join(settings.INVERSE_INDEX_DIR, "dict.txt"), os.path.join(settings.INVERSE_INDEX_DIR, "urls.txt")) self.snippet_builder = SnippetBuilder() def get_search_results(self, query): index = self.index searcher = self.searcher query_result_ids = searcher.search(query.encode("utf-8"), return_urls_only=True) query_result = list() for url_id in query_result_ids[10]: record = index.record_by_id(randrange(300)) try: snippet = self.snippet_builder.build_snippet(record, query.encode("utf-8")) except Exception as e: snippet = u" SnipetBuilder упал" + e.message query_result.append({"url": url_id[1], "snippet": snippet, "image": record.img_url, "title": record.title}) return query_result def spell(self, query): return self.sp.spell(query)
def setUp(self): self.spell = Spell(0, 200, 200, 200) self.caster = Character(1000, 1000, 'Horde') self.victime = Character(1000, 1000, 'Aliance') self.health_spell_on_caster = 1200 self.mana_after_cast = 800 self.health_spell_on_target = 800
def __init__(self): self.sp = Spell(settings.SPELL_WORDS_NUM) self.index = DirectIndex(settings.DIRECT_INDEX_PATH) self.searcher = Searcher(os.path.join(settings.INVERSE_INDEX_DIR, "index.txt"), os.path.join(settings.INVERSE_INDEX_DIR, "dict.txt"), os.path.join(settings.INVERSE_INDEX_DIR, "urls.txt")) self.snippet_builder = SnippetBuilder()
class GroupDocEditor(object): def __init__(self, group_inst): builder = gtk.Builder() builder.add_from_file(GLADE_GTXT) self.group_doc = builder.get_object('group_text') self.group_title = builder.get_object('group_title') self.group_inst = group_inst self.buffer = builder.get_object('overview1').get_buffer() pango_font = pango.FontDescription("monospace") builder.get_object('overview1').modify_font(pango_font) self.__prj_preview = PreviewEditor( self.buffer, builder.get_object('scroll_webkit1')) self.buffer.set_text(group_inst.docs) self.group_title.set_text(group_inst.title) builder.get_object("button2").connect("button-press-event", self._save) builder.get_object("button3").connect("button-press-event", self._cancel) builder.get_object('title').set_text(group_inst.name) if PREVIEW_ENABLED: self.__prj_preview.enable() else: self.__prj_preview.disable() self.__spell = Spell(builder.get_object('overview1')) self.group_doc.connect('delete-event', self.on_delete_event) self.group_doc.connect('destroy-event', self.on_destroy_event) self.group_doc.show() def on_destroy_event(self, obj): self.__spell.detach() def on_delete_event(self, obj, event): self.__spell.detach() def _cancel(self, obj, data): self.group_doc.destroy() def _save(self, obj, data): self.group_inst.docs = self.buffer.get_text( self.buffer.get_start_iter(), self.buffer.get_end_iter(), False) self.group_inst.title = self.group_title.get_text() self.group_doc.destroy()
class TestSpell(unittest.TestCase): def setUp(self): self.spell = Spell(0, 200, 200, 200) self.caster = Character(1000, 1000, 'Horde') self.victime = Character(1000, 1000, 'Aliance') self.health_spell_on_caster = 1200 self.mana_after_cast = 800 self.health_spell_on_target = 800 def test_spell_on_self(self): self.spell.cast(self.caster, self.caster) self.assertEqual(self.caster.health, self.health_spell_on_caster) self.assertEqual(self.caster.mana, self.mana_after_cast) def test_spell_on_victime(self): self.spell.cast(self.caster, self.victime) self.assertEqual(self.caster.mana, self.mana_after_cast) self.assertEqual(self.victime.health, self.health_spell_on_target)
def parseList(self): content = urlopen(self.parseurl).read().decode() soup = BeautifulSoup(content, 'html.parser') spells = soup.find_all('input',attrs={'name':'select_sorts[]'}) for s in spells: matches = re.match('^(\d+)-(.+)$', s.parent.text.strip()) if matches: lvl = matches.group(1) name = matches.group(2).strip() slug = s['value'].strip().replace('\'', '') spell = Spell(slug, lvl, self.sPath) self.list.add(spell) for spell in self.list: try: spell.parseSpell() except: print('parseSpell Error: the spell '+ spell.slug +' parsing raised an Error : ', sys.exc_info()[0])
def setUp(self): self.hero = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) self.weapon = Weapon(name="The Axe of Destiny", damage=20) self.spell = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2)
class SpellTest(unittest.TestCase): def setUp(self): self.spell = Spell("Froze", 20, 10, 3) def test_is_instance(self): self.assertTrue(isinstance(self.spell, Spell)) def test_valid_members(self): self.assertEqual(self.spell.name, "Froze") self.assertEqual(self.spell.damage, 20) self.assertEqual(self.spell.mana_cost, 10) self.assertEqual(self.spell.cast_range, 3) def test_str(self): name = self.spell.name damage = self.spell.damage mana_cost = self.spell.mana_cost cast_range = self.spell.cast_range expected = "{} with damage: {}, mana_cost: {}, cast_range: {}" expected = expected.format(name, damage, mana_cost, cast_range) self.assertEqual(str(self.spell), expected) def test_get_functions(self): self.assertEqual(self.spell.get_name(), "Froze") self.assertEqual(self.spell.get_damage(), 20) self.assertEqual(self.spell.get_mana_cost(), 10) self.assertEqual(self.spell.get_cast_range(), 3) def test_prepare_json(self): data = { "name": "Froze", "damage": 20, "mana_cost": 10, "cast_range": 3 } self.assertEqual(self.spell.prepare_json(), data)
def select_all_library_spells(): conn = create_connection() cur = conn.cursor() cur.execute("SELECT * FROM spell_library") query_result = cur.fetchall() conn.close() spellList = [] for row in query_result: spell = Spell(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13]) spellList.append(spell) # print(row) return spellList
def __init__(self, map_file, treasure_file, enemy_file): with open(map_file, 'r') as f: self.map = f.readlines() self.map = [list(x[:-1]) for x in self.map] self.hero = None with open(treasure_file, 'r') as f2: treasure_dictionary = json.load(f2) self.weapons = treasure_dictionary["weapons"] self.weapons = [Weapon(**weapon) for weapon in self.weapons] self.spells = treasure_dictionary["spells"] self.spells = [Spell(**spell) for spell in self.spells] with open(enemy_file, 'r') as f3: enemy_dictionary = json.load(f3) self.enemies = [Enemy(**enemy) for enemy in enemy_dictionary["enemies"]]
def test_hero_attack(self): w = Weapon('noj', 20) self.hero.equip(w) self.hero.attack(by='weapon') self.assertTrue(self.hero.can_attack()) self.assertEqual(self.hero.damage, self.hero.phisical_damage + self.hero.damage) s = Spell("BatkaAttack", 30, 50, 2) self.hero.learn(s) self.hero.attack(by='magic') self.assertEqual(self.hero.damage, self.hero.magic_damage) self.hero.attack(by='RKO') self.assertRaises(Exception)
def test_hero_move_with_as_and_learned_spell_should_return_true_and_as( self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) s = Spell('fireball', 25, 15, 3) h.learn(s) enemy = Enemy(health=100, mana=40, damage=60) enemy.x = 3 enemy.y = 3 fight = Fight(enemy) status = fight.hero_move(h, 'as') self.assertTrue(status)
def test_hero_move_with_as_and_learned_spell_but_not_enough_mana_should_return_false_and_not_enough_mana( self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=50, mana_regeneration_rate=2) enemy = Enemy(health=100, mana=40, damage=60) spell = Spell(name='Test Magiq', damage=40, mana_cost=60, cast_range=1) enemy.x = 3 enemy.y = 3 h.learn(spell) fight = Fight(enemy) status, error = fight.hero_move(h, 'as') self.assertFalse(status) self.assertEqual(error, 'not enough mana')
def __init__(self, game, tx, ty, group): super().__init__(game, tx, ty, group, True) for i in range(2): self.init_sprite('character_d_'+str(i)+'.png', group) self.particle_hitbox = (2,-1,14,16) self.hitbox = (0,0,7,3) self.target_min_dist = 1.5 self.target_max_dist = 4 self.health = 8 self.attack_dt = 1.6 self.speed = random.random() * 0.4 + 0.3 self.attack_period = 1.2 self.anim_dead = 0 self.target = self.game.world.character self.override_enemy = True self.spells = [Spell(game, i) for i in list(Spell.TYPE.keys())]
def test_enemy_move_with_same_x_level_as_hero_and_y_in_range_to_attack_with_spell_should_reduce_hero_health( self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) s = Spell('fireball', damage=45, mana_cost=15, cast_range=3) enemy = Enemy(health=100, mana=40, damage=20) enemy.x = 3 enemy.y = 2 enemy.learn(s) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(h.health, 55)
def get_treasure(cls, treasure): # treasure is the treasure as string kind = treasure.split(':')[0].rstrip( ' ') # ':' splits the kind of treasure and it's description descr = treasure.split(':')[1] if kind == "weapon": from weapon import Weapon return Weapon.create_weapon(descr) if kind == "spell": from spell import Spell return Spell.create_spell(descr) elif kind == "mana": from mana import Mana return Mana(int(descr)) elif kind == "health": from health import Health return Health(int(descr)) else: raise ValueError("Not correct kind of treasure.")
def hero_attack(self, by): if by == "spell": if Spell.in_range(): if Hero.can_cast() == True and self.fattack == True: self.fattack = False # след боя трябва да стане пак True print(self.msg1) Enemies(take_damege()) # Трябва да се добави боя elif Hero.can_cast(): # Трябва да се добави боя else: return self.hero_attack("weapon") # Май така беше да се испълни функцията else: print("Nothing in casting range {}".format(self.cast_range)) if by == "weapon": # Трябва да се добави боя pass
def test_enemy_with_same_x_as_hero_and_y_in_range_to_attack_choose_normal_attack_reduces_hero_health_2( self): # test with spell only and enemy dmg > spell dmg h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) enemy = Enemy(health=100, mana=40, damage=60) enemy.x = 3 enemy.y = 2 s = Spell('fireball', damage=45, mana_cost=15, cast_range=3) enemy.learn(s) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(h.health, 40)
def test_enemy_move_with_same_x_as_hero_and_y_in_range_to_attack_choose_spell_not_weapon_reduces_hero_health( self): h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) s = Spell('fireball', damage=55, mana_cost=15, cast_range=3) enemy = Enemy(health=100, mana=40, damage=20) weapon = Weapon(name='Pruchka', damage=50) enemy.x = 3 enemy.y = 2 enemy.learn(s) enemy.equip(weapon) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(h.health, 45)
def test_from_engl393_ritual_end(): test_info = { 'level_and_type': "1st-level divination (Ritual)", 'cast_time': "1 action", 'range': "10 feet", 'components': "V, S", 'duration': "30 minutes", 'descr_n': "This is my description", } spell = Spell.from_engl393("testName", test_info) assert spell.Level == 1 assert spell.School == "Divination" assert spell.CastTime == "1 action" assert spell.Range == "10 feet" assert spell.Components == ['V', 'S'] assert spell.Duration == "30 minutes" assert spell.Description == "This is my description" assert spell.AtHigherLevels == "" assert spell.Ritual == True
def test_enemy_with_same_y_as_hero_and_x_in_range_to_attack_choose_normal_attack_reduces_hero_health_5( self): # test with weapon and spell and enemy dmg > spell dmg > weapon dmg h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) enemy = Enemy(health=100, mana=40, damage=60) enemy.x = 2 enemy.y = 3 weapon = Weapon(name='Pruchka', damage=50) s = Spell('fireball', damage=45, mana_cost=15, cast_range=3) enemy.learn(s) enemy.equip(weapon) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(h.health, 40)
def test_enemy_with_bigger_weapon_dmg_and_not_enough_range_should_change_x_to_hero( self): # hero is on the right side of enemy and in the same y level h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) enemy = Enemy(health=100, mana=40, damage=20) enemy.x = 1 enemy.y = 3 weapon = Weapon(name='Pruchka', damage=50) s = Spell('fireball', damage=45, mana_cost=15, cast_range=1) enemy.learn(s) enemy.equip(weapon) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(enemy.x, 2)
def test_enemy_with_bigger_basic_dmg_and_not_enough_range_should_change_y_to_hero_2( self): # hero is on the same x as enemy but on higher y level h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) enemy = Enemy(health=100, mana=40, damage=20) enemy.x = 3 enemy.y = 5 weapon = Weapon(name='Pruchka', damage=0) s = Spell('fireball', damage=0, mana_cost=15, cast_range=1) enemy.learn(s) enemy.equip(weapon) fight = Fight(enemy) h.x = 3 h.y = 3 fight.enemy_move(h) self.assertEqual(enemy.y, 4)
def get_random_treasure(creature): treasure_types = ["health", "mana", "weapon", "spell"] random_treasure = random.choice(treasure_types) if random_treasure == "health": health_treasure = random.randint(-10, creature.max_health) creature.take_healing(health_treasure) if creature.health == 0: message = "Found potion with {} health. Our hero is dead!" message = message.format(health_treasure) print(message) elif creature.health != 0: message = "Found potion with {} health. Now health is {}" message = message.format(health_treasure, creature.health) print(message) elif random_treasure == "mana": mana_treasure = random.randint(-10, creature.max_mana) creature.take_mana(mana_treasure) if creature.mana == 0: message = "Found potion with {} mana. Our hero have not mana!" message = message.format(mana_treasure) print(message) elif creature.mana != 0: message = "Found potion with {} mana. Now mana is {}" message = message.format(mana_treasure, creature.mana) print(message) elif random_treasure == "weapon": weapon_treasure = Weapon.load("weapons.json") creature.equip(weapon_treasure) print("Our hero equipped: {}".format(str(weapon_treasure))) elif random_treasure == "spell": spell_treasure = Spell.load("spells.json") creature.equip(spell_treasure) print("Our hero equipped: {}".format(str(spell_treasure)))
def play_game(): battle_map = Dungeon(map_file="level1.txt", treasure_file="treasures_file.json", enemy_file="enemies.json") hero_name = input('ENTER YOUR BATTLE NAME: ') hero_title = input('ENTER YOUR TITLE: ') hero = Hero(name=hero_name, title=hero_title, health=100, mana=50, mana_regeneration_rate=5) name = hero.known_as() print( 'Welcome {} to level1. Wish you luck, you will need it!'.format(name)) start_weapon = Weapon(name='Pruchka', damage=25) start_spell = Spell(name='Vqtur', damage=30, mana_cost=35, cast_range=2) hero.equip(start_weapon) hero.learn(start_spell) battle_map.spawn(hero) battle_map.print_map() print(colored('TUTORIAL', 'cyan', attrs=['bold'])) commands() print(colored('To see the commands use "help"', 'cyan', attrs=['bold'])) game_cycle_level(battle_map, hero) if hero.is_alive() is False: return 0 start_level2 = input('Do you want to play on level2? [y/n] ').lower() if start_level2[0] == 'y': battle_map = Dungeon(map_file="level2.txt", treasure_file="treasures_file.json", enemy_file="enemies.json") battle_map.spawn(hero) battle_map.print_map() game_cycle_level(battle_map, hero) print('GOOD JOB! YOU BEAT THE WHOLE GAME!') else: print('Ha,ha,ha. You are a coward')
class Player: def __init__(self, renderer, factory): self.renderer = renderer self.factory = factory self.sprite_size = 128 x = int((WindowSize.WIDTH / 2) - (self.sprite_size / 2)) y = int((WindowSize.HEIGHT / 2) - (self.sprite_size / 2)) self.sprite_position = x, y self.player_sprites = [ RESOURCES.get_path("player_standing.png"), RESOURCES.get_path("player_walking.png"), RESOURCES.get_path("player_casting.png") ] self.sprite_sheets = {} self.sprites = [] self.facing = Facing.LEFT_DOWN self.last_facing = self.facing self.motion_type = MotionType.STANDING self.last_motion_type = self.motion_type self.frame_index = 0 self.player_pos = [0, 0] self.init_sprite_sheet() self.spell = None self.spell_max_life = 100 self.spell_life = 0 self.inventory = None def init_sprite_sheet(self): for motion_type in range(MotionType.COUNT): self.loads_image(self.player_sprites[motion_type], motion_type) def loads_image(self, file_path, motion_type): sprite_sheets = self.sprite_sheets.get(file_path) if not sprite_sheets: sprite_surface = self.factory.from_image(file_path) self.sprite_sheets[motion_type] = sprite_surface def update(self, motion_type, facing, elapsed_time): self.sprites.clear() self.motion_type = motion_type self.facing = facing if (self.motion_type == MotionType.CASTING) and (self.frame_index >= 29): if not self.spell_life: self.spell_life = self.spell_max_life self.spell = Spell(self.renderer, self.factory, "fireball", self.facing) else: self.frame_index += 1 if self.spell_life: self.spell_life -= 1 self.spell.update(elapsed_time) self.sprites.append(self.spell.get_sprite()) else: self.spell = None if self.inventory: self.inventory.update(elapsed_time) self.inventory.draw() if (self.facing != self.last_facing) or (self.motion_type != self.last_motion_type): self.frame_index = 0 if self.frame_index == (self.sprite_sheets[self.motion_type].size[0] / self.sprite_size): self.frame_index = 0 self.last_facing = self.facing self.last_motion_type = self.motion_type sprite_sheet = self.sprite_sheets[self.motion_type] sprite_crop = [ self.frame_index * self.sprite_size, self.facing * self.sprite_size, self.sprite_size, self.sprite_size ] sprite = sprite_sheet.subsprite(sprite_crop) sprite.position = self.sprite_position self.sprites.append(sprite) """ renderer = self.renderer src_rect = SDL_Rect() src_rect.x = frame_index * sprite_size src_rect.y = facing * sprite_size src_rect.w = sprite_size src_rect.h = sprite_size dest_rect = SDL_Rect() dest_rect.x = int((WindowSize.WIDTH / 2) - (sprite_size / 2)) dest_rect.y = int((WindowSize.HEIGHT / 2) - (sprite_size / 2)) dest_rect.w = sprite_size dest_rect.h = sprite_size SDL_RenderCopy(renderer, sprite.texture, src_rect, dest_rect) """ def toggle_inventory(self): if self.inventory: self.inventory = None else: renderer = self.renderer self.inventory = Inventory(renderer) def get_sprites(self): return self.sprites
def castSpell(self, rx, ry, color): direction = vecFromDirection(self.getDirection()) x, y = (self.pos.x + self.gfx.rect.width / 2, self.pos.y + self.gfx.rect.height / 2) self.castedSpells.append(Spell(x, y, rx, ry, direction, color))
class FightTests(unittest.TestCase): def setUp(self): self.spell = Spell(name="Fireball", damage=5, mana_cost=20, cast_range=1) self.weapon = Weapon(name="The Axe of Destiny", damage=10) self.hero = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) self.map = [['.', '.', '#', '#', '.', 'S', '.', '.', '.', 'T'], ['#', 'T', '#', '#', '.', '.', '#', '#', '#', '.'], ['#', '.', '#', '#', '#', 'E', '#', '#', '#', 'E'], ['#', '.', 'E', '.', '.', '.', '#', '#', '#', '.'], ['#', '#', '#', 'T', '#', 'T', '#', '#', '#', 'G']] self.enemies = { "2,5": { "damage": 10, "health": 40, "mana": 20, "weapon": None, "spell": self.spell.to_json() }, "2,9": { "damage": 10, "health": 40, "mana": 20, "weapon": self.weapon.to_json(), "spell": None }, "3,2": { "damage": 10, "health": 40, "mana": 20, "weapon": None, "spell": None } } self.treasures = { "1,1": { "class": "Potion", "type": "mana", "amount": 50 }, "0,9": { "class": "Potion", "type": "health", "amount": 50 }, "4,3": { "class": "Weapon", "name": "The Axe of Destiny", "damage": 10 }, "4,5": { 'class': "Spell", 'name': 'Fireball', 'damage': 5, 'mana_cost': 20, 'cast_range': 1 } } self.json_data = { "map": self.map, "enemies": self.enemies, "treasures": self.treasures } self.dungeon = Dungeon(self.json_data) self.dungeon.spawn(self.hero) self.fight = Fight(dungeon=self.dungeon, enemy_pos=(2, 5)) def test_init_initializing_correctly(self): self.assertEqual(self.fight.dungeon, self.dungeon) self.assertEqual(self.fight.enemy, Enemy.from_json(self.enemies['2,5'])) self.assertEqual(self.fight.enemy_pos, (2, 5)) def test_init_raises_Assertion_error_when_there_is_no_enemy_on_the_given_pos( self): with self.assertRaises(AssertionError): Fight(dungeon=self.dungeon, enemy_pos=(0, 1)) def test__range_between(self): self.assertEqual(self.fight._range_between(), 2) def test__direction_to_enemy_without_arguments(self): with self.subTest('Hero is up from enemy'): self.assertEqual(self.fight._direction_to_enemy(), (1, 0)) with self.subTest('Hero is down from enemy'): self.fight.dungeon._hero_pos = (3, 5) self.assertEqual(self.fight._direction_to_enemy(), (-1, 0)) def test__direction_to_enemy_with_argument(self): self.fight.enemy_pos = (3, 2) with self.subTest('Hero is left from enemy'): self.fight.dungeon._hero_pos = (3, 1) self.assertEqual(self.fight._direction_to_enemy(False), (0, 1)) with self.subTest('Hero is right from enemy'): self.fight.dungeon._hero_pos = (3, 5) self.assertEqual(self.fight._direction_to_enemy(False), (0, -3)) def test_hero_move_moves_hero_on_the_map_towards_enemy(self): self.fight.hero_move() self.assertEqual(self.fight.dungeon._map[1][5], self.hero) def test_enemy_move_moves_enemy_on_the_map_towards_hero(self): self.fight.enemy_move() self.assertEqual(self.fight.dungeon._map[1][5], self.fight.enemy) self.assertEqual(self.fight.enemy_pos, (1, 5)) def test_player_makes_move_one_of_the_players_move_when_hero_has_to_move( self): self.fight.player_makes_move(self.dungeon._hero) self.assertEqual(self.fight.dungeon._map[1][5], self.hero) def test_player_makes_move_one_of_the_players_move_when_enemy_has_to_move( self): self.fight.player_makes_move(self.fight.enemy) self.assertEqual(self.fight.dungeon._map[1][5], self.fight.enemy) def test_player_makes_move_hero_attacks(self): self.fight.dungeon._hero.learn(self.spell) self.fight.enemy_move() self.fight.player_makes_move(self.fight.dungeon._hero) self.assertEqual(self.fight.enemy.get_health(), 35) def test_player_makes_move_enemy_attacks(self): self.fight.hero_move() self.fight.player_makes_move(self.fight.enemy) self.assertEqual(self.fight.dungeon._hero.get_health(), 85) def test_fight(self): spell = Spell(name="Fireball", damage=20, mana_cost=4, cast_range=1) self.fight.dungeon._hero.learn(spell) print() self.fight.dungeon.print_map() self.fight.fight() self.assertEqual(self.fight.dungeon._hero.get_health(), 85) self.assertEqual(self.fight.dungeon._hero_pos, (1, 5)) self.assertFalse(self.fight.enemy.is_alive()) def test_fight_hero_is_dead(self): self.hero._health = 10 with self.assertRaises(HeroIsDeadError): self.fight.fight()
def setUp(self): self.spell = Spell(name="Fireball", damage=5, mana_cost=20, cast_range=1) self.weapon = Weapon(name="The Axe of Destiny", damage=10) self.hero = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) self.map = [['.', '.', '#', '#', '.', 'S', '.', '.', '.', 'T'], ['#', 'T', '#', '#', '.', '.', '#', '#', '#', '.'], ['#', '.', '#', '#', '#', 'E', '#', '#', '#', 'E'], ['#', '.', 'E', '.', '.', '.', '#', '#', '#', '.'], ['#', '#', '#', 'T', '#', 'T', '#', '#', '#', 'G']] self.enemies = { "2,5": { "damage": 10, "health": 40, "mana": 20, "weapon": None, "spell": self.spell.to_json() }, "2,9": { "damage": 10, "health": 40, "mana": 20, "weapon": self.weapon.to_json(), "spell": None }, "3,2": { "damage": 10, "health": 40, "mana": 20, "weapon": None, "spell": None } } self.treasures = { "1,1": { "class": "Potion", "type": "mana", "amount": 50 }, "0,9": { "class": "Potion", "type": "health", "amount": 50 }, "4,3": { "class": "Weapon", "name": "The Axe of Destiny", "damage": 10 }, "4,5": { 'class': "Spell", 'name': 'Fireball', 'damage': 5, 'mana_cost': 20, 'cast_range': 1 } } self.json_data = { "map": self.map, "enemies": self.enemies, "treasures": self.treasures } self.dungeon = Dungeon(self.json_data) self.dungeon.spawn(self.hero) self.fight = Fight(dungeon=self.dungeon, enemy_pos=(2, 5))
class EnemyTests(unittest.TestCase): def setUp(self): self.e = Enemy(health=100, mana=100, damage=50) self.w = Weapon(name='The Axe of Destiny', damage=20) self.s = Spell(name='Fireball', damage=30, mana_cost=60, cast_range=2) self.e.equip(self.w) self.e.learn(self.s) def test_can_cast(self): self.assertTrue(self.e.can_cast()) self.e._mana = 29 self.assertFalse(self.e.can_cast()) def test_attack(self): self.assertEqual(self.e.attack(by='weapon'), 70) self.assertEqual(self.e.attack(by='spell'), 80) with self.assertRaises(NotEnoughManaError): self.e.attack(by='spell') def test_take_mana(self): self.assertFalse(self.e.take_mana()) def test_eq_returns_false_when_enemy1_super_different_than_enemy2_super(self): enemy1 = Enemy(health=100, mana=100, damage=50) enemy2 = Enemy(health=200, mana=100, damage=50) self.assertNotEqual(enemy1, enemy2) def test_eq_returns_false_when_enemy1_damage_different_than_enemy2_damage(self): enemy1 = Enemy(health=100, mana=100, damage=50) enemy2 = Enemy(health=100, mana=100, damage=75) self.assertNotEqual(enemy1, enemy2) def test_eq_returns_true_when_supers_are_equal_and_damages_are_equal(self): enemy1 = Enemy(health=100, mana=100, damage=50) enemy2 = Enemy(health=100, mana=100, damage=50) self.assertEqual(enemy1, enemy2) def test_to_json(self): expected = { 'damage': 50, 'health': 100, 'mana': 100, 'weapon': self.w.to_json(), 'spell': self.s.to_json() } self.assertDictEqual(self.e.to_json(), expected) def test_from_json(self): json_dict = { 'damage': 50, 'health': 100, 'mana': 100, 'weapon': self.w.to_json(), 'spell': self.s.to_json() } self.assertEqual(self.e, Enemy.from_json(json_dict))
class TestsHero(unittest.TestCase): def setUp(self): self.hero1 = Hero( name='Toni', title='Pythonslayer', health=250, mana=1000, mana_regeneration_rate=25, ) self.hero2 = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) self.spell = Spell(name="Fireball", damage=30, mana_cost=110, cast_range=2) self.weapon = Weapon(name="The Axe of Destiny", damage=20) def test_init_working_correctly(self): with self.subTest('hero1'): self.assertEqual(self.hero1._name, 'Toni') self.assertEqual(self.hero1._title, 'Pythonslayer') self.assertEqual(self.hero1._health, 250) self.assertEqual(self.hero1._max_health, 250) self.assertEqual(self.hero1._mana, 1000) self.assertEqual(self.hero1._max_mana, 1000) self.assertEqual(self.hero1._mana_regeneration_rate, 25) self.assertEqual(self.hero1._weapon, None) self.assertEqual(self.hero1._spell, None) def test_known_as(self): with self.subTest('hero1'): self.assertEqual(self.hero1.known_as(), 'Toni the Pythonslayer') with self.subTest('hero2'): self.assertEqual(self.hero2.known_as(), 'Bron the Dragonslayer') def test_can_cast(self): with self.subTest('spell is None'): self.assertFalse(self.hero1.can_cast()) with self.subTest('when mana is not enough'): self.hero2._spell = self.spell self.assertFalse(self.hero2.can_cast()) with self.subTest('when mana is not enough'): self.hero1._spell = self.spell self.assertTrue(self.hero1.can_cast()) def test_attack_raises_exceptions_correctly(self): with self.subTest('when by == weapon and hero\'s weapon is None'): with self.assertRaises(NotEquippedError): self.hero1.attack(by='weapon') with self.subTest('when by == spell and hero\'s spell is None'): with self.assertRaises(NotEquippedError): self.hero1.attack(by='spell') with self.subTest('when by is not \'weapon\' or \'spell\''): with self.assertRaises(TypeError): self.hero1.attack(by='foot') with self.subTest('when spell costs more then current mana'): with self.assertRaises(NotEnoughManaError): self.hero1.learn(self.spell) for x in range(0, 20): self.hero1.attack(by='spell') def test_attack_returns_correct_damage(self): with self.subTest('\'by\' == \'spell\''): self.hero1._spell = self.spell damage = self.hero1.attack(by='spell') self.assertEqual(damage, 30) self.assertEqual(self.hero1._mana, 890) with self.subTest('\'by\' == \'weapon\''): self.hero2._weapon = self.weapon damage = self.hero2.attack(by='weapon') self.assertEqual(damage, 20) def test_eq_returns_false_when_hero1_super_different_than_hero2_super( self): hero3 = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) hero3.learn(self.spell) self.assertNotEqual(self.hero2, hero3) def test_eq_returns_false_when_hero1_has_different_attr_than_hero2_super( self): hero3 = Hero(name="Toni", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) self.assertNotEqual(self.hero2, hero3) def test_eq_returns_true_when_super_and_all_attrs_are_the_same(self): hero3 = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) self.assertEqual(self.hero2, hero3) def test_to_json(self): self.hero1.learn(self.spell) expected = { 'name': 'Toni', 'title': 'Pythonslayer', 'mana_regeneration_rate': 25, 'health': 250, 'mana': 1000, 'weapon': None, 'spell': self.spell.to_json() } self.assertDictEqual(self.hero1.to_json(), expected) def test_from_json(self): self.hero1.equip(self.weapon) json_dict = { 'name': 'Toni', 'title': 'Pythonslayer', 'mana_regeneration_rate': 25, 'health': 250, 'mana': 1000, 'weapon': self.weapon.to_json(), 'spell': None } self.assertEqual(self.hero1, Hero.from_json(json_dict))
def setUp(self): self.spell = Spell("Froze", 20, 10, 3)
def __init__(self, showbase): self.showbase=showbase self.ready=False self.showbase.num_warlocks=1 self.showbase.which=0 # this will have its own chat i guess, just game server only (no channels or anything just the one chat, all to all) # also i guess all the players data (usernames, maybe others) will need to be collected here from the server for the chat/scoreboard/whatever # and whenever a new person joins/leaves an update will be sent to all the clients (like with the all chat i guess) # these will need to be created in here from data passed from the server (where it will be procedurally generated) # once it receives a 'preround' state change it should create all the required shit (warlocks per person and the Game() class and whatnot) # then client will switch to preround state # spell0 spell0=Spell() spell0.damage=10 spell0.target_knockback=20 spell0.self_knockback=0 spell0.range=25 spell0.speed=15 spell0.aoe=False spell0.aoe_range=0 spell0.targeting=False spell0.casting_time=0 spell0.interruptable=False spell0.model="media/spells/blockyball" # spell1 spell1=Spell() spell1.damage=25 spell1.target_knockback=10 spell1.self_knockback=0 spell1.range=50 spell1.speed=25 spell1.aoe=False spell1.aoe_range=0 spell1.targeting=False spell1.casting_time=0 spell1.interruptable=False spell1.model="media/spells/pointyball" # spell2 spell2=Spell() spell2.damage=50 spell2.target_knockback=10 spell2.self_knockback=30 spell2.range=50 spell2.speed=15 spell2.aoe=False spell2.aoe_range=0 spell2.targeting=False spell2.casting_time=0 spell2.interruptable=False spell2.model="media/spells/blockyball" # spell3 spell3=Spell() spell3.model="media/spells/pointyball" showbase.spells=[] showbase.spells.append(spell0) showbase.spells.append(spell1) showbase.spells.append(spell2) showbase.spells.append(spell3) self.background = OnscreenImage( image = 'media/gui/lobby/lobby.png', parent = render2d ) # Send Message Button self.send_button = DirectButton( command = self.send_message, frameSize = (-3, 3, -.5, 1), pos = (0.0, 0.0, .3), scale = .1, text = "Send", ) # Text box for message entry self.entry = DirectEntry( focusInCommand = self.clearText, frameSize = (-3, 3, -.5, 1), initialText = "Chat:", parent = self.send_button, pos = (0, 0, -1.5), text = "" , text_align = TextNode.ACenter, ) # button to tell server client is ready self.ready_button = DirectButton( command = self.toggle_ready, frameSize = (-3, 3, -.5, 1), pos = (0.0, 0.0, -.3), scale = .1, text = "Ready?", ) # button to tell server client is not ready self.unready_button = DirectButton( command = self.toggle_unready, frameSize = (-3, 3, -.5, 1), pos = (0.0, 0.0, -.3), scale = .1, text = "Unready?", ) # hide unready button until ready self.unready_button.hide() # button to quit game self.quit_button = DirectButton( command = showbase.quit, frameSize = (-4,-1,0,0),#-3, 3, -.5, 1), pos = (-1.0, 0.0, -1.0), scale = .1, text = "QUIT!", ) # Add the game loop procedure to the task manager. taskMgr.doMethodLater(1.0, self.update_lobby, 'Update Lobby')
def __init__(self, dbase, register, bit_field, modified, top_builder): self.__db = dbase self.__modified = modified self.__register = register self.__bit_field = bit_field self.__builder = gtk.Builder() self.__top_builder = top_builder self.__builder.add_from_file(GLADE_BIT) self.__top_window = self.__builder.get_object("editfield") self.__control_obj = self.__builder.get_object('control') self.__name_obj = self.__builder.get_object("field_name") self.__register_obj = self.__builder.get_object("register_name") self.__output_obj = self.__builder.get_object("output") self.__type_obj = self.__builder.get_object('type') self.__input_obj = self.__builder.get_object("input") self.__reset_obj = self.__builder.get_object("reset_value") self.__static_obj = self.__builder.get_object('static') self.__text_buffer = self.__builder.get_object("descr").get_buffer() self.__value_tree_obj = self.__builder.get_object('values') self.__output_enable_obj = self.__builder.get_object("outen") self.__side_effect_obj = self.__builder.get_object("side_effect") self.__verilog_obj = self.__builder.get_object('verilog_code') self.__volatile_obj = self.__builder.get_object('volatile') self.__col = None self.__top_window.set_title( "Edit Bit Field - [%02x] %s" % (register.address, register.register_name)) self.__spell = Spell(self.__builder.get_object("descr")) self.__top_window.set_icon_from_file( os.path.join(INSTALL_PATH, "media", "flop.svg")) (input_enb, control_enb) = TYPE_TO_ENABLE[bit_field.field_type] self.__input_obj.set_sensitive(input_enb) self.__control_obj.set_sensitive(control_enb) pango_font = pango.FontDescription("monospace") self.__builder.get_object("descr").modify_font(pango_font) self.build_values_list() self.__list_model = gtk.ListStore(str, str, str) self.__model_selection = self.__value_tree_obj.get_selection() self.__value_tree_obj.set_model(self.__list_model) self.__used_tokens = set() for value in self.__bit_field.values: self.__used_tokens.add(value[1]) self.__list_model.append(row=value) self.__initialize_from_data(bit_field) self.__output_obj.set_sensitive(self.__output_enable_obj.get_active()) self.__check_data() self.__text_buffer.connect('changed', self.__description_changed) try: edge = "posedge" if self.__db.reset_active_level else "negedge" condition = "" if self.__db.reset_active_level else "~" be_level = "" if self.__db.byte_strobe_active_level else "~" name_map = {'MODULE': self.__db.module_name, 'BE_LEVEL': be_level, 'RESET_CONDITION': condition, 'RESET_EDGE': edge } text = REG[TYPE_TO_ID[bit_field.field_type].lower()] % name_map except KeyError: text = "" if USE_HIGHLIGHT: buff = CodeBuffer(lang=SyntaxLoader("verilog")) self.__verilog_obj.set_buffer(buff) else: self.__verilog_obj.modify_font(pango_font) buff = self.__verilog_obj.get_buffer() buff.set_text(text) self.__builder.connect_signals(self) self.__top_window.show_all()
def preround_loop(self,task): print "Preround State" self.game_time=0 self.tick=0 self.showbase.num_warlocks=len(self.users) # i guess this shit should be in the pregame part, so people can choose their spells based of these # also it will need to be created in there from data passed from the server (where it will be procedurally generated) # spell0 spell0=Spell() spell0.damage=10 spell0.target_knockback=20 spell0.self_knockback=0 spell0.range=25 spell0.speed=15 spell0.aoe=False spell0.aoe_range=0 spell0.targeting=False spell0.casting_time=0 spell0.interruptable=False spell0.model="media/spells/blockyball" # spell1 spell1=Spell() spell1.damage=25 spell1.target_knockback=10 spell1.self_knockback=0 spell1.range=50 spell1.speed=25 spell1.aoe=False spell1.aoe_range=0 spell1.targeting=False spell1.casting_time=0 spell1.interruptable=False spell1.model="media/spells/pointyball" # spell2 spell2=Spell() spell2.damage=50 spell2.target_knockback=10 spell2.self_knockback=30 spell2.range=50 spell2.speed=15 spell2.aoe=False spell2.aoe_range=0 spell2.targeting=False spell2.casting_time=0 spell2.interruptable=False spell2.model="media/spells/blockyball" # spell3 spell3=Spell() spell3.model="media/spells/pointyball" # maybe this shit too, or this can stay here and just pass in an array of spells self.showbase.spell_man=SpellManager(self.showbase.num_warlocks) # until the Game() class is created in here which i think it should self.showbase.spell_man.add_spell(spell0) self.showbase.spell_man.add_spell(spell1) self.showbase.spell_man.add_spell(spell2) self.showbase.spell_man.add_spell(spell3) self.game=Game(self.showbase,game_tick) for u in range(self.showbase.num_warlocks): self.users[u]['warlock']=self.game.warlock[u] taskMgr.doMethodLater(0.5, self.game_loop, 'Game Loop') return task.done
class BitFieldEditor(object): """ Bit field editing class. """ def __init__(self, dbase, register, bit_field, modified, top_builder): self.__db = dbase self.__modified = modified self.__register = register self.__bit_field = bit_field self.__builder = gtk.Builder() self.__top_builder = top_builder self.__builder.add_from_file(GLADE_BIT) self.__top_window = self.__builder.get_object("editfield") self.__control_obj = self.__builder.get_object('control') self.__name_obj = self.__builder.get_object("field_name") self.__register_obj = self.__builder.get_object("register_name") self.__output_obj = self.__builder.get_object("output") self.__type_obj = self.__builder.get_object('type') self.__input_obj = self.__builder.get_object("input") self.__reset_obj = self.__builder.get_object("reset_value") self.__static_obj = self.__builder.get_object('static') self.__text_buffer = self.__builder.get_object("descr").get_buffer() self.__value_tree_obj = self.__builder.get_object('values') self.__output_enable_obj = self.__builder.get_object("outen") self.__side_effect_obj = self.__builder.get_object("side_effect") self.__verilog_obj = self.__builder.get_object('verilog_code') self.__volatile_obj = self.__builder.get_object('volatile') self.__col = None self.__top_window.set_title( "Edit Bit Field - [%02x] %s" % (register.address, register.register_name)) self.__spell = Spell(self.__builder.get_object("descr")) self.__top_window.set_icon_from_file( os.path.join(INSTALL_PATH, "media", "flop.svg")) (input_enb, control_enb) = TYPE_TO_ENABLE[bit_field.field_type] self.__input_obj.set_sensitive(input_enb) self.__control_obj.set_sensitive(control_enb) pango_font = pango.FontDescription("monospace") self.__builder.get_object("descr").modify_font(pango_font) self.build_values_list() self.__list_model = gtk.ListStore(str, str, str) self.__model_selection = self.__value_tree_obj.get_selection() self.__value_tree_obj.set_model(self.__list_model) self.__used_tokens = set() for value in self.__bit_field.values: self.__used_tokens.add(value[1]) self.__list_model.append(row=value) self.__initialize_from_data(bit_field) self.__output_obj.set_sensitive(self.__output_enable_obj.get_active()) self.__check_data() self.__text_buffer.connect('changed', self.__description_changed) try: edge = "posedge" if self.__db.reset_active_level else "negedge" condition = "" if self.__db.reset_active_level else "~" be_level = "" if self.__db.byte_strobe_active_level else "~" name_map = {'MODULE': self.__db.module_name, 'BE_LEVEL': be_level, 'RESET_CONDITION': condition, 'RESET_EDGE': edge } text = REG[TYPE_TO_ID[bit_field.field_type].lower()] % name_map except KeyError: text = "" if USE_HIGHLIGHT: buff = CodeBuffer(lang=SyntaxLoader("verilog")) self.__verilog_obj.set_buffer(buff) else: self.__verilog_obj.modify_font(pango_font) buff = self.__verilog_obj.get_buffer() buff.set_text(text) self.__builder.connect_signals(self) self.__top_window.show_all() def __initialize_from_data(self, bit_field): """ Initializes the dialog's data fields from the object """ self.__register_obj.set_text("<b>%s</b>" % self.__register.register_name) self.__register_obj.set_use_markup(True) start = self.__bit_field.start_position stop = self.__bit_field.stop_position if start == stop: name = bit_field.field_name else: name = "%s[%d:%d]" % (bit_field.field_name, stop, start) self.__name_obj.set_text(name) self.__type_obj.set_text(TYPE_TO_DESCR[bit_field.field_type]) if bit_field.reset_type == BitField.RESET_NUMERIC: self.__reset_obj.set_text("%x" % bit_field.reset_value) else: self.__reset_obj.set_text(bit_field.reset_parameter) (input_enb, control_enb) = TYPE_TO_ENABLE[bit_field.field_type] if input_enb and not bit_field.input_signal: bit_field.input_signal = "%s_DATA_IN" % bit_field.field_name if control_enb and not bit_field.control_signal: bit_field.control_signal = "%s_LOAD" % bit_field.field_name self.__output_obj.set_text(bit_field.output_signal) self.__input_obj.set_text(bit_field.input_signal) self.__volatile_obj.set_active(bit_field.volatile) self.__static_obj.set_active(bit_field.output_is_static) self.__side_effect_obj.set_active(bit_field.output_has_side_effect) self.__text_buffer.set_text(bit_field.description) self.__output_enable_obj.set_active(bit_field.use_output_enable) self.__control_obj.set_text(self.__bit_field.control_signal) def on_help_clicked(self, obj): HelpWindow(self.__top_builder, "bitfield_value_help.rst") def on_property_help_clicked(self, obj): HelpWindow(self.__top_builder, "bitfield_signal_prop_help.rst") def on_signal_help_clicked(self, obj): HelpWindow(self.__top_builder, "bitfield_signal_help.rst") def on_output_changed(self, obj): self.__bit_field.output_signal = obj.get_text() self.__check_data() self.__modified() def on_input_changed(self, obj): self.__bit_field.input_signal = obj.get_text() self.__check_data() self.__modified() def on_volatile_changed(self, obj): self.__bit_field.volatile = obj.get_active() self.__modified() def on_static_toggled(self, obj): self.__bit_field.output_is_static = obj.get_active() self.__modified() def on_control_changed(self, obj): self.__bit_field.control_signal = obj.get_text() self.__check_data() self.__modified() def build_values_list(self): """ Builds the columns associated with the list view """ render = gtk.CellRendererText() render.set_property('editable', True) render.connect('edited', self.__change_val) column = gtk.TreeViewColumn('Value', render, text=0) column.set_min_width(50) self.__value_tree_obj.append_column(column) self.__col = column render = gtk.CellRendererText() render.set_property('editable', True) render.connect('edited', self.__change_text) column = gtk.TreeViewColumn('Token', render, text=1) column.set_min_width(100) self.__value_tree_obj.append_column(column) render = gtk.CellRendererText() render.set_property('editable', True) render.connect('edited', self.__change_description) column = gtk.TreeViewColumn('Description', render, text=2) self.__value_tree_obj.append_column(column) def on_add_clicked(self, obj): """ Called with the add button is clicked. Search the existing values in the list, finding the next highest value to use as the default. """ start = self.__bit_field.start_position stop = self.__bit_field.stop_position last = len(self.__list_model) max_values = 2 ** (stop - start + 1) if last >= max_values: ErrorMsg("Maximum number of values reached", "The width of the field only allows for %d values" % last) return try: largest = max([int(val[0], 16) for val in self.__list_model if val[0] != ""]) except ValueError: largest = -1 last -= 1 if (last == -1 or self.__list_model[last][0] or self.__list_model[last][1] or self.__list_model[last][2]): if largest >= max_values: new_val = "" else: new_val = "%x" % (largest + 1,) node = self.__list_model.append(row=(new_val, '', '')) path = self.__list_model.get_path(node) else: path = (last, ) self.__value_tree_obj.set_cursor(path, focus_column=self.__col, start_editing=True) self.__modified() def on_remove_clicked(self, obj): # IGNORE:W0613 - obj is unused """ Called with the remove button is clicked """ self.__list_model.remove(self.__model_selection.get_selected()[1]) self.__update_values() self.__modified() def __change_val(self, text, path, new_text): # IGNORE:W0613 """ Called with the value has changed value field. Checks to make sure that value is a valid hex value, and within the correct range. """ new_text = new_text.strip() start = self.__bit_field.start_position stop = self.__bit_field.stop_position maxval = (2 ** (stop - start + 1)) - 1 try: if new_text == "" or int(new_text, 16) > maxval: return except ValueError: return node = self.__list_model.get_iter(path) self.__list_model.set_value(node, 0, new_text) self.__update_values() self.__modified() def on_side_effect_toggled(self, obj): self.__bit_field.output_has_side_effect = obj.get_active() self.__modified() def __update_values(self): new_list = [] for row in self.__list_model: new_list.append((row[0], row[1], row[2])) self.__bit_field.values = new_list def __change_text(self, text, path, new_text): """ Updates the data model when the text value is changed in the model. """ if new_text in self.__used_tokens: ErrorMsg("Duplicate token", 'The token "%s" has already been used' % new_text) else: node = self.__list_model.get_iter(path) old_text = self.__list_model.get_value(node, 1) self.__list_model.set_value(node, 1, new_text) if old_text and old_text in self.__used_tokens: self.__used_tokens.remove(old_text) if new_text: self.__used_tokens.add(new_text) self.__update_values() self.__modified() def __change_description(self, text, path, new_text): """ Updates the data model when the text value is changed in the model. """ node = self.__list_model.get_iter(path) try: new_text.decode("ascii") except: ErrorMsg("Invalid ASCII characters detected", "Look for strange punctuations, like dashs and " "quotes that look valid, but are not actual " "ascii characters.") self.__list_model.set_value(node, 2, new_text) self.__update_values() self.__modified() def on_output_enable_toggled(self, obj): """ Enables the output field based on the output enable field """ active = self.__output_enable_obj.get_active() self.__bit_field.use_output_enable = active self.__output_obj.set_sensitive(obj.get_active()) self.__check_data() self.__modified() def on_descr_key_press_event(self, obj, event): """ Called on a double click event. If we detect a double click with the first button, we call the edit_register method. """ if event.keyval == gtk.keysyms.F10: bounds = self.__text_buffer.get_selection_bounds() if bounds: old_text = self.__text_buffer.get_text(bounds[0], bounds[1]) new_text = " ".join(old_text.replace("\n", " ").split()) self.__text_buffer.delete(bounds[0], bounds[1]) self.__text_buffer.insert(bounds[0], new_text) self.__modified() return True return False def on_destroy_event(self, obj): self.__spell.detach() def on_delete_event(self, obj, event): self.__spell.detach() def on_close_clicked(self, obj): """ Saves the data from the interface to the internal BitField structure """ self.__top_window.destroy() def __description_changed(self, obj): self.__bit_field.description = self.__text_buffer.get_text( self.__text_buffer.get_start_iter(), self.__text_buffer.get_end_iter(), False) self.__modified() def __check_data(self): """ Checks the input signal validity """ input_error = False output_error = False control_error = False if control_error is False: clear_error(self.__control_obj) if input_error is False: clear_error(self.__input_obj) if output_error is False: clear_error(self.__output_obj)
def setUp(self): self.my_spell = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2)
class GroupDocEditor(object): def __init__(self, group_inst, callback): builder = gtk.Builder() builder.add_from_file(GLADE_GTXT) self.callback = callback self.group_doc = builder.get_object('group_text') self.group_title = builder.get_object('group_title') self.group_inst = group_inst self.buffer = builder.get_object('overview1').get_buffer() pango_font = pango.FontDescription("monospace") builder.get_object('overview1').modify_font(pango_font) self.__prj_preview = PreviewEditor( self.buffer, builder.get_object('scroll_webkit1')) self.buffer.set_text(group_inst.docs) self.group_title.set_text(group_inst.title) builder.get_object("overview1").connect("key-press-event", self.on_key_press_event) builder.get_object("button2").connect("button-press-event", self._save) builder.get_object("button3").connect("button-press-event", self._cancel) builder.get_object('title').set_text(group_inst.name) if PREVIEW_ENABLED: self.__prj_preview.enable() else: self.__prj_preview.disable() self.__spell = Spell(builder.get_object('overview1')) self.group_doc.connect('delete-event', self.on_delete_event) self.group_doc.connect('destroy-event', self.on_destroy_event) self.group_doc.show() def on_key_press_event(self, obj, event): if event.keyval == gtk.keysyms.F12: clean_format_if_needed(obj) return True return False def on_destroy_event(self, obj): self.__spell.detach() def on_delete_event(self, obj, event): self.__spell.detach() def _cancel(self, obj, data): self.group_doc.destroy() def _save(self, obj, data): new_docs = self.buffer.get_text( self.buffer.get_start_iter(), self.buffer.get_end_iter(), False) new_title = self.group_title.get_text() if self.group_inst.docs != new_docs: self.group_inst.docs = new_docs self.callback(True) if self.group_inst.title != new_title: self.group_inst.title = new_title self.callback(True) self.group_doc.destroy()
from spellbook import Spellbook from spell import Spell if __name__ == "__main__": testSpellbook = Spellbook() spell = Spell() spell.name = "Fireball" spell.magic_cost = 10 spell.effect = 'Healing' spell.description = "A firey ball of fire fly from you hands." spell2 = Spell() spell2.name = "Heading Hands" spell2.description = "Your hands tingle with healing energy and stuff" testSpellbook.inventory.add(spell) testSpellbook.inventory.add(spell2) choice = testSpellbook.chooseSpell()
def setUp(self): self.spell = Spell("Abracadabra", 100, 11, 15)
def train(run_name, speaker, start_epoch, stop_epoch, img_c, img_w, img_h, frames_n, absolute_max_string_len, minibatch_size): DATASET_DIR = os.path.join(CURRENT_PATH, speaker, 'datasets') OUTPUT_DIR = os.path.join(CURRENT_PATH, speaker, 'results') LOG_DIR = os.path.join(CURRENT_PATH, speaker, 'logs') curriculum = Curriculum(curriculum_rules) lip_gen = BasicGenerator(dataset_path=DATASET_DIR, minibatch_size=minibatch_size, img_c=img_c, img_w=img_w, img_h=img_h, frames_n=frames_n, absolute_max_string_len=absolute_max_string_len, curriculum=curriculum, start_epoch=start_epoch).build() lipnet = LipNet(img_c=img_c, img_w=img_w, img_h=img_h, frames_n=frames_n, absolute_max_string_len=absolute_max_string_len, output_size=lip_gen.get_output_size()) lipnet.summary() adam = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) # the loss calc occurs elsewhere, so use a dummy lambda func for the loss lipnet.model.compile(loss={ 'ctc': lambda y_true, y_pred: y_pred }, optimizer=adam) # load weight if necessary if start_epoch > 0: weight_file = os.path.join( OUTPUT_DIR, os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1))) lipnet.model.load_weights(weight_file) spell = Spell(path=PREDICT_DICTIONARY) decoder = Decoder(greedy=PREDICT_GREEDY, beam_width=PREDICT_BEAM_WIDTH, postprocessors=[labels_to_text, spell.sentence]) # define callbacks statistics = Statistics(lipnet, lip_gen.next_val(), decoder, 256, output_dir=os.path.join(OUTPUT_DIR, run_name)) visualize = Visualize(os.path.join(OUTPUT_DIR, run_name), lipnet, lip_gen.next_val(), decoder, num_display_sentences=minibatch_size) tensorboard = TensorBoard(log_dir=os.path.join(LOG_DIR, run_name)) csv_logger = CSVLogger(os.path.join( LOG_DIR, "{}-{}.csv".format('training', run_name)), separator=',', append=True) checkpoint = ModelCheckpoint(os.path.join(OUTPUT_DIR, run_name, "weights{epoch:02d}.h5"), monitor='val_loss', save_weights_only=True, mode='auto', period=1) lipnet.model.fit_generator(generator=lip_gen.next_train(), steps_per_epoch=lip_gen.default_training_steps, epochs=stop_epoch, validation_data=lip_gen.next_val(), validation_steps=2, callbacks=[ checkpoint, statistics, visualize, lip_gen, tensorboard, csv_logger ], initial_epoch=start_epoch, verbose=1, max_q_size=5, workers=2, pickle_safe=True)
def test_string_representation_with_spell(self): from spell import Spell self.hero.learn_spell(Spell("Fire", 20, 4, 2)) expected_string = """Bron the Dragonslayer: \ health 100, mana 100\nspell: Fire: damage 20, mana 4, range 2\n""" self.assertEqual(str(self.hero), expected_string)
def init_spells(self): return [Spell(Inventory(2, 0, 0, 0)), Spell(Inventory(-1, 1, 0, 0)), Spell(Inventory(0, -1, 1, 0)), Spell(Inventory(0, 0, -1, 1))]
class HeroTest(unittest.TestCase): def setUp(self): self.hero = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2) self.weapon = Weapon(name="The Axe of Destiny", damage=20) self.spell = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2) def test_exists_class(self): self.assertTrue(isinstance(self.hero, Hero)) def test_hero_known_as(self): self.assertTrue(self.hero.known_as(), "Bron the DragonSlayer") def test_hero_is_alive(self): self.assertTrue(self.hero.is_alive(), True) def test_is_hero_not_alive(self): self.hero.reduce_health(100) self.assertFalse(self.hero.is_alive()) def test_hero_can_cast(self): self.assertTrue(self.hero.can_cast(), True) def test_hero_can_cast_false(self): self.hero.reduce_mana(100) self.assertFalse(self.hero.can_cast()) def test_mana_regeneration_rate(self): self.assertEqual(self.hero.mana_regeneration_rate(), 2) def test_hero_take_damage(self): damage_points = 20 self.hero.take_damage(damage_points) self.assertEqual(self.hero.get_health(), 80) def test_hero_take_healing(self): healing_points = 20 damage_points = 90 self.hero.take_damage(damage_points) self.hero.take_healing(healing_points) self.assertTrue(self.hero.get_health(), 30) def test_hero_take_mana(self): damage_points = 50 mana_points = 40 new_mana_points = 20 self.hero.take_damage(damage_points) self.hero.reduce_mana(mana_points) self.assertTrue(self.hero.take_mana(new_mana_points), 80) def test_hero_weapon(self): weapon_equipment = [] weapon_equipment.append(self.weapon) self.assertEqual(weapon_equipment[0], self.weapon) def test_hero_can_equip_with_weapon(self): self.hero.equip(self.weapon) self.assertEqual(str(self.hero.weapon_equipment[0]), self.weapon.get_name()) def test_hero_spell(self): learned_spell = [] learned_spell.append(self.spell) self.assertEqual(learned_spell[0], self.spell) def test_hero_can_learn_new_spell(self): self.hero.learn(self.spell) self.assertEqual(str(self.hero.learned_spell[0]), self.spell.get_name()) def test_hero_attack_with_spell(self): self.hero.learn(self.spell) self.assertEqual(self.hero.attack(by="spell"), self.spell.get_damage()) def test_hero_attack_with_weapon(self): self.hero.equip(self.weapon) self.assertEqual(self.hero.attack(by="weapon"), self.weapon.get_damage())
def __init__(self, name, color): Spell.__init__(self, name, None) self.color = color
def test_can_cast_not_enough_mana(self): self.setUp() n = self.test_soldier n.learn_spell(Spell('Fireball', damage=50, mana_cost=120, cast_range=3)) self.assertFalse(n.can_cast())
def test_get_damage_source_weapon_and_spell(self): self.setUp() n = self.test_soldier n.equip_weapon(self.default_weapon) n.learn_spell(Spell(name='asd', damage=20, mana_cost=30, cast_range=2)) self.assertEqual(n.get_damage_source(), 'spell')
def _startSpell(conn): spell = Spell(conn) spell.main()
def setUp(self): self.test_soldier = Unit(health=200, mana=100) self.default_weapon = Weapon() self.default_spell = Spell()
from spell import Spell # from <file> import <Class> cat_summoned = "You reach into your pocket for a can of tuna and " \ "crack it open. A cat pops into existence beside you in a puff of smoke!" summon = Spell("Summon Cat", "Conjuration", 1, 4, cat_summoned) # The spell "Summon Cat" belongs to the school of "Conjuration", # has a level of 1 and can be cast 4 times per day. cat_effects = "You throw a bag of catnip at a nearby, unfortunate soul, " \ "and a giant cat comes crashing down on them from the heavens above!" cataclysm = Spell("Cataclysm", "Conjuration", 6, 2, cat_effects) # The spell "Cataclysm" belongs to the school of "Conjuration", # has a level of 6 and can be cast 2 times per day. # use the spells summon.cast() cataclysm.cast()
from dungeon import Dungeon from hero import Hero from fight import Fight from weapon import Weapon from spell import Spell from enemy import Enemy from time import sleep h = Hero(name="Bron", title="Dragonslayer", health=20, mana=100) weapon = Weapon("weapon", 30) h.equip(weapon) spell = Spell() h.learn(spell) enemy = Enemy(health=100, mana=100, damage=20) map = Dungeon('level1.txt') # print('Prepare the map for the final fight') # sleep(2) print('A long time ago our hero {} was born in Sofia.'.format(h.name)) print() sleep(4) print('At the same time evil was born in the northwest.') print() sleep(4) print('And now we have to prepare the map for the final fight') sleep(4) print() print('The map') map.print_map()
def current_position(self): Spell.position(self.dungeon, self.rol, self.col)