def __init__(self,
name,
sprite,
hp,
defense,
res,
strength,
classes,
equipments,
race,
gold,
lvl,
skills,
alterations,
compl_sprite=None):
Character.__init__(self, name, (), sprite, hp, defense, res, strength,
classes, equipments, 'MANUAL', lvl, skills,
alterations, race, gold, compl_sprite)
self.state = PlayerState.WAITING_SELECTION
self.old_pos = ()
self._selected = False
# Sprite displayed when player cannot be selected
self.sprite_unavaible = self.sprite.copy()
color_image = pg.Surface(self.sprite.get_size()).convert_alpha()
color_image.fill(LIGHT_GREY)
self.sprite_unavaible.blit(color_image, (0, 0),
special_flags=pg.BLEND_RGBA_MULT)
# Memorize normal state sprite
self.normal_sprite = self.sprite
# Memorize the current action performed by the player, it must be a value of CharacterMenu
self.current_action = None
def move(self):
if self.state is PlayerState.ON_MOVE:
Character.move(self)
if not self.on_move:
self.state = PlayerState.WAITING_POST_ACTION
return True
return False
def minimal_setup_for_game():
pg.init()
font.init_fonts()
# Window parameters
pg.display.set_mode((MAIN_WIN_WIDTH, MAIN_WIN_HEIGHT))
# Load some data
races = Loader.load_races()
classes = Loader.load_classes()
Character.init_data(races, classes)
def setUpClass(cls):
super(TestStartScreen, cls).setUpClass()
pg.init()
font.init_fonts()
cls.save_url = "saves/main_save.xml"
cls.level_class = Level
cls.buttons = []
cls.buttons.append(Rect(NEW_GAME_BUTTON_POS[0], NEW_GAME_BUTTON_POS[1], BUTTON_SIZE[0], BUTTON_SIZE[1]))
cls.buttons.append(Rect(LOAD_GAME_BUTTON_POS[0], LOAD_GAME_BUTTON_POS[1], BUTTON_SIZE[0], BUTTON_SIZE[1]))
cls.buttons.append(Rect(OPTIONS_BUTTON_POS[0], NEW_GAME_BUTTON_POS[1], BUTTON_SIZE[0], BUTTON_SIZE[1]))
cls.buttons.append(Rect(EXIT_GAME_BUTTON_POS[0], NEW_GAME_BUTTON_POS[1], BUTTON_SIZE[0], BUTTON_SIZE[1]))
races = Loader.load_races()
classes = Loader.load_classes()
Character.init_data(races, classes)
def test_init_character(self):
name = 'character_test'
pos = (3, 2)
sprite = 'imgs/characs/jist.png'
hp = 10
defense = 4
res = 3
strength = 2
classes = ['innkeeper']
equipments = []
strategy = 'STATIC'
lvl = 3
skills = []
alterations = []
race = 'human'
gold = 500
interaction = {
'dialog': [
"Hurry up ! Leave the village from the west, and enter the necropolis.",
"The clock is ticking... The ogre's bones must be returned to their original place."
],
'join_team':
False
}
character_test = Character(name, pos, sprite, hp, defense, res,
strength, classes, equipments, strategy,
lvl, skills, alterations, race, gold,
interaction)
self.assertEqual(equipments, character_test.equipments)
self.assertEqual(classes, character_test.classes)
self.assertEqual(race, character_test.race)
self.assertEqual(gold, character_test.gold)
self.assertFalse(character_test.join_team)
self.assertEqual(int, type(character_test.constitution))
def save(self, tree_name):
# Build XML tree
tree = Character.save(self, tree_name)
# Save if turn is finished or not
state = etree.SubElement(tree, 'turnFinished')
state.text = str(self.turn_is_finished())
return tree
def random_character_entity(min_hp=10,
max_defense=10,
max_res=10,
name=None,
lvl=None,
equipments=None,
classes=None,
race=None,
interaction=None):
attrs = random_character_attributes(min_hp, max_defense, max_res, name,
lvl, equipments, classes, race,
interaction)
return Character(attrs['name'], attrs['pos'], attrs['sprite'], attrs['hp'],
attrs['defense'], attrs['res'], attrs['strength'],
attrs['classes'], attrs['equipments'], attrs['strategy'],
attrs['lvl'], attrs['skills'], [], attrs['race'],
attrs['gold'], attrs['interaction'])
def load_ally(ally, from_save, gap_x, gap_y):
name = ally.find('name').text.strip()
infos = etree.parse('data/characters.xml').find(name)
entity_attributes = load_artificial_entity(ally, infos, from_save, gap_x,
gap_y)
# Static data character
race = infos.find('race').text.strip()
classes = [infos.find('class').text.strip()]
interaction_el = infos.find('interaction')
dialog = []
for talk in interaction_el.findall('talk'):
dialog.append(talk.text.strip())
interaction = {
'dialog': dialog,
'join_team': interaction_el.find('join_team') is not None
}
# Dynamic data character
dynamic_data = infos
if from_save:
dynamic_data = ally
gold = int(dynamic_data.find('gold').text.strip())
equipments = []
for eq in dynamic_data.findall('equipment/*'):
if from_save:
eq_loaded = load_item(eq)
else:
eq_loaded = parse_item_file(eq.text.strip)
equipments.append(eq_loaded)
if from_save:
skills = [(load_skill(skill.text.strip())
if not skill.text.strip() in skills_infos else
skills_infos[skill.text.strip()])
for skill in dynamic_data.findall('skills/skill/name')]
else:
skills = Character.classes_data[
classes[0]]['skills'] + Character.races_data[race]['skills']
loaded_ally = Character(
entity_attributes['name'], entity_attributes['position'],
entity_attributes['sprite'], entity_attributes['hp'],
entity_attributes['defense'], entity_attributes['resistance'],
entity_attributes['strength'], classes, equipments,
entity_attributes['strategy'], entity_attributes['level'], skills,
entity_attributes['alterations'], race, gold, interaction)
inventory = infos.find('inventory')
if inventory is not None:
for it in inventory.findall('item'):
if from_save:
item_loaded = load_item(it)
else:
item_loaded = parse_item_file(it.text.strip())
loaded_ally.set_item(item_loaded)
if from_save:
current_hp = int(ally.find('current_hp').text.strip())
loaded_ally.hp = current_hp
xp = int(ally.find('exp').text.strip())
loaded_ally.earn_xp(xp)
else:
# Up stats according to current lvl
loaded_ally.stats_up(entity_attributes['level'] - 1)
# Restore hp due to lvl up
loaded_ally.healed()
return loaded_ally
# Window parameters
pg.display.set_caption("In the name of the Five Cats")
screen = pg.display.set_mode((MAIN_WIN_WIDTH, MAIN_WIN_HEIGHT))
# Load constant sprites
Destroyable.init_constant_sprites()
Breakable.init_constant_sprites()
Movable.init_constant_sprites()
Sidebar.init_constant_sprites()
Level.init_constant_sprites()
# Load some data
races = Loader.load_races()
classes = Loader.load_classes()
Character.init_data(races, classes)
clock = pg.time.Clock()
start_screen = StartScreen(screen)
quit_game = False
while not quit_game:
for e in pg.event.get():
if e.type == pg.QUIT:
quit_game = True
elif e.type == pg.MOUSEMOTION:
start_screen.motion(e.pos)
elif e.type == pg.MOUSEBUTTONUP:
if e.button == 1 or e.button == 3:
quit_game = start_screen.click(e.button, e.pos)
def set_move(self, pos):
Character.set_move(self, pos)
self.state = PlayerState.ON_MOVE
self.old_pos = self.pos
def display(self, screen):
Character.display(self, screen)
if self.state in range(PlayerState.WAITING_MOVE,
PlayerState.WAITING_TARGET + 1):
screen.blit(Player.SELECTED_DISPLAY, self.pos)
def new_turn(self):
Character.new_turn(self)
self.state = PlayerState.WAITING_SELECTION
self.sprite = self.normal_sprite
for eq in self.equipments:
eq.unset_grey()
def attack(self, ent):
damages = Character.attack(self, ent)
self.state = PlayerState.FINISHED
return damages
def unequip(self, eq):
unequipped = Character.unequip(self, eq)
if unequipped:
self.state = PlayerState.WAITING_POST_ACTION_UNCANCELLABLE
return unequipped
def equip(self, eq):
equipped = Character.equip(self, eq)
if equipped > -1:
self.state = PlayerState.WAITING_POST_ACTION_UNCANCELLABLE
return equipped
def use_item(self, item):
used, result_msgs = Character.use_item(self, item)
if used:
self.state = PlayerState.WAITING_POST_ACTION_UNCANCELLABLE
return used, result_msgs
