def __init__(self, parent=None):
super().__init__(parent)
self.DAO = SettingsDAO()
self.langDAO = LangDAO()
self.init_data()
self.init_ui()
def insert_translate(self, strValues: dict, lang: str, objectId: int,
objectType: ObjectType) -> None:
"""
Insert translate for object to database
:param strValues: dictionary of names and values
:param lang: lang of translate
:param objectId: id ob object
:param objectType: objectType of object
"""
if not lang:
lang = SettingsDAO().get_value('language', str)
self.set_many(True)
for name, value in strValues.items():
data = {
'lang': lang,
'target_id': objectId,
'type': objectType.value,
'name': name,
'value': value
}
self.insert('translates', data)
self.insert_many_execute()
self.set_many(False)
def import_xml(self, root) -> list:
"""
Import xml and create objects from given root
:param root: root of lxml tree
:return: list of objects
"""
if not self.OBJECT_TYPE:
raise NotImplementedError('OBJECT_TYPE not defined')
if not self.ROOT_NAME:
raise NotImplementedError('ROOT_NAME not defined')
# if root.tag != self.ROOT_NAME:
# raise ValueError('Root tag name is not ' + self.ROOT_NAME)
langs = self.__get_langs(root)
objects = {}
for lang in langs:
obj = self.OBJECT_TYPE.instance()(None, lang)
objects[lang] = obj
if len(objects) == 0:
defaultLang = SettingsDAO().get_value('language', str)
objects[defaultLang] = self.OBJECT_TYPE.instance()(None,
defaultLang)
# Remap instances for easy finding
xInstances = {}
for key, instance in self.__dict__.items():
if instance.name in xInstances:
if type(xInstances[instance.name]) is not dict:
old = xInstances[instance.name]
xInstances[instance.name] = {}
xInstances[instance.name][old[0]] = old[1]
xInstances[instance.name][key] = instance
else:
xInstances[instance.name] = (key, instance)
for attr in root:
if attr.tag in xInstances:
if attr.tag == 'id':
continue
if type(xInstances[attr.tag]) is dict:
groups = self.__remap_xml_group(attr, xInstances[attr.tag])
for name, root in groups.items():
objects = xInstances[attr.tag][name].set_attributes(
objects, name, root)
else:
objects = xInstances[attr.tag][1].set_attributes(
objects, xInstances[attr.tag][0], attr)
return objects
def save_slot(self) -> None:
"""
Slot activate when click on save button
:return:
"""
oldCode = SettingsDAO().get_value('language')
if self.lang.code != oldCode:
TextDialog(TR().tr('Language_changed'))
self.DAO.set_value('language', self.lang.code)
self.accept()
def set_attributes(self, objects: dict, name: str, attr):
attrList = []
if self.single:
o = self.__instance().import_xml(attr)
for obj in objects.values():
setattr(obj, name, o.popitem()[1])
else:
for a in attr:
o = self.__instance().import_xml(a)
defaultLang = SettingsDAO().get_value('language', str)
attrList.append(o[defaultLang])
for obj in objects.values():
setattr(obj, name, attrList)
return objects
def get_all(self, lang=None) -> list:
"""
Get list of all Party Characters from database, only one lang
:param lang: lang code
:return: list of Party Characters
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
lines = self.database.select_all(self.DATABASE_TABLE)
characters = []
for line in lines:
character = self.get(line['ID'], lang)
characters.append(character)
return characters
def get_all(self, lang=None) -> list:
"""
Get list of effects for selected lang
:param lang: lang of effects
:return: list of effects
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
lines = self.database.select_all(self.DATABASE_TABLE)
effects = []
for line in lines:
character = self.get(line['ID'], lang)
effects.append(character)
return effects
def get_all(self, lang=None) -> list:
"""
Get list of Monsters for selected lang
:param lang: lang of Monsters
:return: list of Monsters
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
lines = self.database.select_all(self.DATABASE_TABLE)
items = []
for line in lines:
item = self.get(line['ID'], lang)
items.append(item)
return items
def get_all(self, lang: str = None) -> list:
"""
Gel list of all Ability context
:param lang: lang of objects
:return: list of Ability context
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
lines = self.database.select_all(self.DATABASE_TABLE)
items = []
for line in lines:
item = self.get(line['ID'], lang)
items.append(item)
return items
def get_all(self, lang: str = None) -> list:
"""
Get list of modifiers for selected lang
:param lang: lang of modifiers
:return: list of modifiers
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
lines = self.database.select_all('Item')
modifiers = []
for line in lines:
item = self.get(line['ID'], lang)
modifiers.append(item)
return modifiers
def get(self,
ability_id: int,
lang=None,
nodeId: int = None,
contextType: ObjectType = None) -> Ability:
"""
Get ability , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param ability_id: id of ability
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Ability object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': ability_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = self.database.select_translate(ability_id,
ObjectType.ABILITY.value,
lang)
drd_class = Classes(data.get('drd_class')) if data.get(
'drd_class') is not None else None
drd_race = Races(
data.get('drd_race')) if data.get('drd_race') is not None else None
ability = Ability(ability_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''),
tr_data.get('chance', ''), drd_race, drd_class,
data.get('level', 1))
if nodeId and contextType:
children = self.treeDAO.get_children_objects(nodeId, contextType)
contexts = []
for child in children:
if child.object.object_type is ObjectType.ABILITY_CONTEXT:
contexts.append(AbilityContextDAO().get(
child.object.id, None, child.id, contextType))
ability.contexts = contexts
return ability
def __init__(self, lang_code=None):
if lang_code is None:
lang_code = SettingsDAO().get_value('language', str)
variables = {}
templatesVariables = {}
exec(
open('resources/translate/translate_' + lang_code + '.py',
encoding='utf-8').read(), variables)
exec(
open('resources/translate/templateTranslate_' + lang_code + '.py',
encoding='utf-8').read(), templatesVariables)
self.translate_dict = variables['translate']
self.templates_translate_dict = templatesVariables['translate']
def init_ui(self):
"""
Init basic ui of main Window
:return:
"""
self.setWindowTitle('DeskChar')
self.setWindowIcon(QtGui.QIcon('resources/icons/char.png'))
self.setMenuWidget(MainMenu())
self.setStatusBar(StatusBar())
self.toolBar = ToolBar(parent=self)
self.setObjectName('MainWindow')
self.centralWidget = QWidget(self)
self.centralWidget.setObjectName('central widget')
self.grid_layout = QGridLayout(self.centralWidget)
self.grid_layout.setObjectName('Grid layout')
self.menuWidget().templates_menu_signal.connect(self.redraw_central_widget)
self.toolBar.templates_tool_signal.connect(self.redraw_central_widget)
self.setCentralWidget(self.centralWidget)
self.setGeometry(200, 50, 800, 800)
self.grview = QtWidgets.QGraphicsView()
self.grview.setRenderHints(self.grview.renderHints() | QtGui.QPainter.Antialiasing | QtGui.QPainter.SmoothPixmapTransform)
self.scene = QtWidgets.QGraphicsScene()
self.grview.setScene(self.scene)
img = 'resources/icons/goblin-{}.png'.format(SettingsDAO().get_value('language'))
if not os.path.isfile(img):
img = 'resources/icons/goblin-en.png'
noMap = QtGui.QPixmap(img)
self.scene.addPixmap(noMap)
self.grview.fitInView(self.scene.sceneRect(), QtCore.Qt.KeepAspectRatio)
self.grid_layout.addWidget(self.grview)
# self.showMaximized()
self.show()
def get(self, message_id: int, lang: str = None) -> Message:
"""
Get Message from database
:param message_id: id of Message
:param lang: lang of spell
:return: Message object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = dict(self.database.select(self.DATABASE_TABLE, {'ID': message_id})[0])
curDate = datetime.fromordinal(data.get('date')) if data.get('date') else None
message = Message(message_id, data['text'], curDate, bool(data['isMine']), data.get('partyCharacterId'),
data.get('characterId'))
return message
def get_data(self, target_id: int, target_type: ObjectType) -> list:
"""
Return list of objects, objects are for one ID but all langs
:param target_id: id of object
:param target_type: Type of object
:return: List of object
"""
data = []
langs = target_type.instance().DAO()().get_languages(target_id)
if not langs:
langs.append(SettingsDAO().get_value('language', str))
for lang in langs:
object = target_type.instance().DAO()().get(target_id, lang)
data.append(object)
return data
def get(self,
effect_id: int,
lang: str = None,
nodeId: int = None,
contextType: ObjectType = None) -> Effect:
"""
Get Effect , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param effect_id: id of Effect
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Effect object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': effect_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = self.database.select_translate(effect_id, self.TYPE.value,
lang)
index = data.get('targetType', 1) if data.get('targetType',
1) is not None else 1
targetType = ModifierTargetTypes(index)
effect = Effect(effect_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''), targetType,
bool(data.get('active', 0)))
if nodeId and contextType:
children = self.treeDAO.get_children_objects(nodeId, contextType)
modifiers = []
for child in children:
if child.object.object_type is ObjectType.MODIFIER:
modifiers.append(ModifierDAO().get(child.object.id, None,
child.id, contextType))
effect.modifiers = modifiers
return effect
def import_from_xml(self,
file_path,
parentType: ObjectType,
parent=None,
strict: bool = False):
"""
Import templates from XML file
:param file_path: path to XML file
:param parentType:
:param strict:
:param parent: parent node id
"""
objects = ParserHandler().import_xml(file_path)
# ObjectDatabase('test.db').set_many(True)
for languages in objects:
defLang = SettingsDAO().get_value('language', str)
if defLang in languages:
leaderObject = languages.pop(defLang)
leaderCode = defLang
else:
leader = languages.popitem()
leaderCode = leader[0]
leaderObject = leader[1]
if strict and leaderObject.object_type != parentType:
continue
if not LangManager().lang_exists(leaderCode):
LangManager().create_lang(leaderCode, leaderCode)
leaderId = leaderObject.DAO()().create(leaderObject)
for lang in languages.values():
if not LangManager().lang_exists(lang.lang):
LangManager().create_lang(lang.lang, lang.lang)
lang.id = leaderId
leaderObject.DAO()().update(lang)
def get_languages(self, id: int) -> list:
"""
Get list of all languages codes for this object
:param id: id of spell
:return: list of langs codes
"""
if self.TYPE is None:
raise ValueError(
'Constant TYPE is not defined in class {}'.format(self))
data = Database(self.DATABASE_DRIVER).select('translates', {
'target_id': id,
'type': self.TYPE.value
})
languages = []
for line in data:
if line['lang'] not in languages:
languages.append(line['lang'])
if len(languages) == 0:
languages.append(SettingsDAO().get_value('language', str))
return languages
def get(self,
character_id: int,
lang: str = None,
nodeId: int = None,
contextType: ObjectType = None) -> PartyCharacter:
"""
Get Party Character by character id, object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param character_id: id of Party Character
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Party Character object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
select = self.database.select(self.DATABASE_TABLE,
{'character_id': character_id})
if not select:
return None
data = dict(select[0])
character = PartyCharacter(data.get('ID'), lang, data['name'], None,
data.get('deviceName', ''),
data.get('MACAddress'))
messages = MessageDAO().get_by_party_character(character.id)
character.messages = messages
# character.character = CharacterDAO().get(data.get('character_id'))
return character
def get(self,
context_id: int,
lang: str = None,
nodeId: int = None,
contextType: ObjectType = None) -> AbilityContext:
"""
Get ability context, object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all subobjects)
If not specified, only basic attributes are set.
:param context_id: id of ability context
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Ability context object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.obj_database.select(self.DATABASE_TABLE,
{'ID': context_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = dict(
self.database.select_translate(context_id, self.TYPE.value, lang))
valueType = ModifierValueTypes(
data['valueType']) if data['valueType'] else None
targetAttribute = CharacterAttributes(
data['targetAttribute']) if data['targetAttribute'] else None
context = AbilityContext(data['ID'], lang, tr_data.get('name', ''),
tr_data.get('description', ''), valueType,
data.get('value', 0), targetAttribute)
return context
def get(self,
spell_id: int,
lang: str = None,
nodeId: int = None,
contextType: ObjectType = None) -> Spell:
"""
Get Spell , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param spell_id: id of Spell
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Spell object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': spell_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = self.database.select_translate(spell_id,
ObjectType.SPELL.value, lang)
drdClassIndex = data.get('drd_class', None)
drdClass = Classes(
drdClassIndex) if drdClassIndex is not None else None
spell = Spell(spell_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''),
tr_data.get('mana_cost_initial', ''),
tr_data.get('mana_cost_continual', ''),
tr_data.get('range', ''), tr_data.get('scope', ''),
data.get('cast_time', 0), tr_data.get('duration', ''),
drdClass)
return spell
def get(self, monster_id: int, lang: str = None, nodeId: int = None, contextType: ObjectType = None) -> Monster:
"""
Get Monster , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param monster_id: id of Monster
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Monster object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': monster_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = self.database.select_translate(monster_id, ObjectType.MONSTER.value,
lang)
monsterRace = MonsterRace(data['monsterRace']) if data['monsterRace'] else None
monsterSize = MonsterSize(data['size']) if data['size'] else None
alignment = Alignment(data['alignment']) if data['alignment'] else None
monster = Monster(data['ID'], lang, tr_data.get('name', ''), tr_data.get('description', ''),
tr_data.get('viability', 0), tr_data.get('offense', ''),
data.get('defense', 0),
data.get('endurance', 0), data.get('rampancy', 0),
data.get('mobility', 0), data.get('perseverance', 0),
data.get('intelligence', 0), data.get('charisma', 0),
alignment, data.get('experience', 0), data.get('hp', 0),
monsterRace, monsterSize)
if nodeId and contextType:
children = self.treeDAO.get_children_objects(nodeId, contextType)
abilities = []
spells = []
items = []
armors = []
moneys = []
containers = []
meleeWeapons = []
rangedWeapons = []
throwableWeapons = []
for child in children:
if child.object.object_type is ObjectType.SPELL:
spell = SpellDAO().get(child.object.id, None, child.id, contextType)
spells.append(spell)
elif child.object.object_type is ObjectType.ABILITY:
ability = AbilityDAO().get(child.object.id, None, child.id, contextType)
abilities.append(ability)
elif child.object.object_type is ObjectType.ITEM:
childItem = ItemDAO().get(child.object.id, None, child.id, contextType)
if isinstance(childItem, Armor):
armors.append(childItem)
elif isinstance(childItem, Container):
containers.append(childItem)
elif isinstance(childItem, Money):
moneys.append(childItem)
elif isinstance(childItem, MeleeWeapon):
meleeWeapons.append(childItem)
elif isinstance(childItem, RangeWeapon):
rangedWeapons.append(childItem)
elif isinstance(childItem, ThrowableWeapon):
throwableWeapons.append(childItem)
else:
items.append(childItem)
monster.abilities = abilities
monster.spells = spells
monster.items = items
monster.armors = armors
monster.moneyList = moneys
monster.containers = containers
monster.meleeWeapons = meleeWeapons
monster.rangedWeapons = rangedWeapons
monster.throwableWeapons = throwableWeapons
return monster
def get(self,
modifier_id: int,
lang: str = None,
nodeId: int = None,
contextType: ObjectType = None) -> Modifier:
"""
Get Modifier , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param modifier_id: id of Modifier
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Modifier object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.obj_database.select(self.DATABASE_TABLE,
{'ID': modifier_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = dict(
self.database.select_translate(modifier_id,
ObjectType.MODIFIER.value, lang))
targetTypeIndex = data.get('targetType', None)
targetType = ModifierTargetTypes(
int(targetTypeIndex)) if targetTypeIndex is not None else None
characterAttributeIndex = data.get('characterTargetAttribute', None)
itemAttributeIndex = data.get('itemTargetAttribute', None)
characterTargetAttribute = CharacterAttributes(
characterAttributeIndex
) if characterAttributeIndex is not None else None
itemTargetAttribute = ItemsAttributes(
itemAttributeIndex) if itemAttributeIndex is not None else None
valueTypeIndex = data.get('valueType', None)
valueType = ModifierValueTypes(
valueTypeIndex) if valueTypeIndex else None
value = data.get('value', 0)
if valueType is ItemsAttributes.WEAPON_MELEE_HANDLING:
value = Handling(value)
elif valueType is ItemsAttributes.WEAPON_WEIGHT:
value = WeaponWeight(value)
elif valueType is ItemsAttributes.ARMOR_SIZE:
valueType = ArmorSize(value)
else:
value = value
modifier = Modifier(modifier_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''), valueType, value,
characterTargetAttribute, itemTargetAttribute,
targetType)
return modifier
def get(self, item_id: int, lang=None, nodeId: int = None, contextType: ObjectType = None) -> Item:
"""
Get Item , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
Returned correct type of item, depend on database, possible classes are:
Item, Container, Armor, Money, MeleeWeapon, RangedWeapon, ThrowableWeapon
:param item_id: id of Item
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Item object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': item_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = dict(self.database.select_translate(item_id, ObjectType.ITEM.value,
lang))
if data['type'] == Items.CONTAINER.value:
item = Container(item_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''),
data.get('parent_id', 0), data.get('weight', 0),
data.get('price', 0),
data.get('capacity', 0), data.get('amount', 1))
elif data['type'] == Items.MELEE_WEAPON.value:
weaponWeightIndex = data.get('weaponWeight', None)
weaponWeight = WeaponWeight(weaponWeightIndex) if weaponWeightIndex else None
handlingIndex = data.get('handling', None)
handling = Handling(handlingIndex) if handlingIndex else None
racialIndex = data.get('racial', None)
racial = Races(racialIndex) if racialIndex else None
item = MeleeWeapon(item_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''), data.get('parent_id', 0),
data.get('weight', 0), data.get('price', 0), data.get('strength', 0),
data.get('rampancy', 0), data.get('defence', 0),
data.get('length', 0), weaponWeight, handling, data.get('amount', 1), data.get('initiative', 0),
racial)
elif data['type'] == Items.THROWABLE_WEAPON.value:
weaponWeightIndex = data.get('weaponWeight', None)
weaponWeight = WeaponWeight(weaponWeightIndex) if weaponWeightIndex else None
racialIndex = data.get('racial', None)
racial = Races(racialIndex) if racialIndex else None
item = ThrowableWeapon(item_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''),
data.get('parent_id', 0), data.get('weight', 0),
data.get('price', 0), data.get('initiative', 0),
data.get('strength', 0), data.get('rampancy', 0),
data.get('rangeLow', 0), data.get('rangeMedium', 0),
data.get('rangeHigh', 0), data.get('defence', 0),
weaponWeight, data.get('amount', 1), racial)
elif data['type'] == Items.RANGED_WEAPON.value:
weaponWeightIndex = data.get('weaponWeight', None)
weaponWeight = WeaponWeight(weaponWeightIndex) if weaponWeightIndex else None
racialIndex = data.get('racial', None)
racial = Races(racialIndex) if racialIndex else None
item = RangeWeapon(item_id, lang, tr_data.get('name', ''),
tr_data.get('description', ''),
data.get('parent_id', 0), data.get('weight', 0),
data.get('price', 0), data.get('initiative', 0),
data.get('strength', 0), data.get('rampancy', 0),
data.get('rangeLow', 0), data.get('rangeMedium', 0),
data.get('rangeHigh', 0), data.get('amount', 1), weaponWeight, racial)
elif data['type'] == Items.ARMOR.value:
sizeIndex = data.get('size', None)
size = ArmorSize(sizeIndex) if sizeIndex else None
item = Armor(item_id, lang, tr_data.get('name', ''), tr_data.get('description', ''),
data.get('parent_id', 0), data.get('price', 0), data.get('quality', 0),
data.get('weightA', 0), data.get('weightB', 0), data.get('weightC', 0),
size, data.get('amount', 1))
elif data['type'] == Items.MONEY.value:
item = Money(item_id, lang, tr_data.get('name', ''), tr_data.get('description', ''),
data.get('parent_id', 0), data.get('copper'), data.get('silver'),
data.get('gold'), data.get('amount', 1))
else:
item = Item(item_id, lang, tr_data.get('name', ''), tr_data.get('description', ''),
data.get('parent_id', 0), data.get('weight', 0), data.get('price', 0),
data.get('amount', 1))
if nodeId and contextType:
objects = PlayerTreeDAO().get_children_objects(nodeId, contextType)
effects = []
armors = []
containers = []
items = []
moneys = []
meleeWeapons = []
rangedWeapons = []
throwableWeapons = []
for one in objects:
if one.object.object_type is ObjectType.ITEM and data['type'] == Items.CONTAINER.value:
childItem = self.get(one.object.id, None, one.id, contextType)
if isinstance(childItem, Armor):
armors.append(childItem)
elif isinstance(childItem, Container):
containers.append(childItem)
elif isinstance(childItem, Money):
moneys.append(childItem)
elif isinstance(childItem, MeleeWeapon):
meleeWeapons.append(childItem)
elif isinstance(childItem, RangeWeapon):
rangedWeapons.append(childItem)
elif isinstance(childItem, ThrowableWeapon):
throwableWeapons.append(childItem)
else:
items.append(childItem)
elif one.object.object_type is ObjectType.EFFECT:
effect = EffectDAO().get(one.object.id, None, one.id, contextType)
effects.append(effect)
if data['type'] is Items.CONTAINER.value:
item.items = items
item.armors = armors
item.moneyList = moneys
item.meleeWeapons = meleeWeapons
item.rangedWeapons = rangedWeapons
item.throwableWeapons = throwableWeapons
item.containers = containers
item.effects = effects
return item
class Settings(QtWidgets.QDialog):
"""
Dialog for creating new item in tree widget
"""
def __init__(self, parent=None):
super().__init__(parent)
self.DAO = SettingsDAO()
self.langDAO = LangDAO()
self.init_data()
self.init_ui()
def init_data(self):
"""
Init settings data from database
:return:
"""
langCode = self.DAO.get_value('language', str)
self.lang = self.langDAO.get_lang_by_code(langCode)
def init_ui(self):
"""
Init basic layout
"""
self.setWindowIcon(QtGui.QIcon('resources/icons/char.png'))
self.setWindowTitle('Settings')
self.layout = QtWidgets.QGridLayout(self)
self.langLabel = QtWidgets.QLabel('Default language:', self)
buttonText = '{} ({})'.format(self.lang.name, self.lang.code)
self.langButton = QtWidgets.QPushButton(buttonText, self)
self.langButton.clicked.connect(self.lang_button_slot)
self.layout.addWidget(self.langLabel, 1, 0)
self.layout.addWidget(self.langButton, 1, 1)
self.layout.addWidget(QHLine(), 2, 0, 1, 2)
self.buttonBox = QtWidgets.QDialogButtonBox()
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel
| QtWidgets.QDialogButtonBox.Save)
self.buttonBox.setObjectName("buttonBox")
self.buttonBox.accepted.connect(self.save_slot)
self.buttonBox.rejected.connect(self.reject)
QtCore.QMetaObject.connectSlotsByName(self)
self.layout.addWidget(self.buttonBox, 3, 0, 1, 2,
QtCore.Qt.AlignHCenter)
def lang_button_slot(self) -> None:
"""
Slot activate when click on language button
:return:
"""
data, result = NewLangTab.get_data()
if result:
self.lang = self.langDAO.get_lang(data['id'])
buttonText = '{} ({})'.format(self.lang.name, self.lang.code)
self.langButton.setText(buttonText)
def save_slot(self) -> None:
"""
Slot activate when click on save button
:return:
"""
oldCode = SettingsDAO().get_value('language')
if self.lang.code != oldCode:
TextDialog(TR().tr('Language_changed'))
self.DAO.set_value('language', self.lang.code)
self.accept()
@staticmethod
def get_data(parent=None) -> None:
"""
Static method to create dialog from presenation
:param parent: parent widget for dialog
:return:
"""
dialog = Settings(parent)
dialog.exec_()
def get(self,
location_id: int,
lang: str = None,
nodeId: int = None,
contextType: ObjectType = None) -> Location:
"""
Get Location , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param location_id: id of Location
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Location object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': location_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = dict(
self.database.select_translate(location_id, self.TYPE.value, lang))
location = Location(data.get('ID'), lang, tr_data.get('name', ''),
tr_data.get('description', ''))
if nodeId and contextType:
children = self.treeDAO.get_children_objects(nodeId, contextType)
locations = []
monsters = []
characters = []
items = []
armors = []
moneys = []
containers = []
meleeWeapons = []
rangedWeapons = []
throwableWeapons = []
maps = []
for child in children:
if child.object.object_type is ObjectType.LOCATION:
childLocation = self.get(child.object.id, None, child.id,
contextType)
locations.append(childLocation)
elif child.object.object_type is ObjectType.MONSTER:
monster = MonsterDAO().get(child.object.id, None, child.id,
contextType)
monsters.append(monster)
elif child.object.object_type is ObjectType.CHARACTER:
character = CharacterDAO().get(child.object.id, None,
child.id, contextType)
characters.append(character)
elif child.object.object_type is ObjectType.MAP:
map = MapDAO().get(child.object.id)
maps.append(map)
elif child.object.object_type is ObjectType.ITEM:
childItem = ItemDAO().get(child.object.id, None, child.id,
contextType)
if isinstance(childItem, Armor):
armors.append(childItem)
elif isinstance(childItem, Container):
containers.append(childItem)
elif isinstance(childItem, Money):
moneys.append(childItem)
elif isinstance(childItem, MeleeWeapon):
meleeWeapons.append(childItem)
elif isinstance(childItem, RangeWeapon):
rangedWeapons.append(childItem)
elif isinstance(childItem, ThrowableWeapon):
throwableWeapons.append(childItem)
else:
items.append(childItem)
location.items = items
location.armors = armors
location.moneyList = moneys
location.containers = containers
location.meleeWeapons = meleeWeapons
location.rangedWeapons = rangedWeapons
location.throwableWeapons = throwableWeapons
location.locations = locations
location.monsters = monsters
location.characters = characters
location.maps = maps
return location
def get(self,
scenario_id: int,
lang: str = None,
nodeId: int = None,
contextType: ObjectType = None) -> Scenario:
"""
Get Scenario , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param scenario_id: id of Scenario
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Scenario object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': scenario_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = dict(
self.database.select_translate(scenario_id, self.TYPE.value, lang))
scenarioDate = date.fromordinal(
data.get('date')) if data.get('date') else None
scenario = Scenario(data.get('ID'), lang, tr_data.get('name', ''),
tr_data.get('description', ''), scenarioDate)
if nodeId and contextType:
children = self.treeDAO.get_children_objects(nodeId, contextType)
abilities = []
spells = []
effects = []
locations = []
partyCharacters = []
for child in children:
if child.object.object_type is ObjectType.ABILITY:
ability = AbilityDAO().get(child.object.id, None, child.id,
contextType)
abilities.append(ability)
elif child.object.object_type is ObjectType.SPELL:
spell = SpellDAO().get(child.object.id, None, child.id,
contextType)
spells.append(spell)
elif child.object.object_type is ObjectType.EFFECT:
effect = EffectDAO().get(child.object.id, None, child.id,
contextType)
effects.append(effect)
elif child.object.object_type is ObjectType.LOCATION:
location = LocationDAO().get(child.object.id, None,
child.id, contextType)
locations.append(location)
elif child.object.object_type is ObjectType.CHARACTER:
character = CharacterDAO().get(child.object.id, None,
child.id, contextType)
partyCharacter = PartyCharacterDAO().get(character.id)
if not partyCharacter:
partyCharacter = PartyCharacter()
partyCharacter.character = character
partyCharacters.append(partyCharacter)
# Search non connected party character
chars = self.database.select('PartyCharacter',
{'scenario_id': scenario_id})
for char in chars:
if char['character_id'] is None:
partyCharacters.append(PartyCharacterDAO().get_by_id(
char['ID']))
scenario.spells = spells
scenario.abilities = abilities
scenario.effects = effects
scenario.locations = locations
scenario.party = partyCharacters
return scenario
def get(self, character_id: int, lang: str = None, nodeId: int = None, contextType: ObjectType = None) -> Character:
"""
Get Character , object transable attributes depends on lang
If nodeId and contextType is specified, whole object is returned (with all sub objects)
If not specified, only basic attributes are set.
:param character_id: id of Character
:param lang: lang of object
:param nodeId: id of node in tree, where object is located
:param contextType: object type of tree, where is node
:return: Character object
"""
if lang is None:
lang = SettingsDAO().get_value('language', str)
data = self.database.select(self.DATABASE_TABLE, {'ID': character_id})
if not data:
return None
else:
data = dict(data[0])
tr_data = self.database.select_translate(character_id, ObjectType.CHARACTER.value,
lang)
drdClass = Classes(data.get('drdClass')) if data.get('drdClass') is not None else None
drdRace = Races(data.get('drdRace')) if data.get('drdRace') is not None else None
alignment = Alignment(data.get('alignment')) if data.get('alignment') is not None else None
character = Character(data.get('ID'), lang, tr_data.get('name', ''),
tr_data.get('description', ''), data.get('agility', 0),
data.get('charisma', 0), data.get('intelligence', 0),
data.get('mobility', 0), data.get('strength', 0),
data.get('toughness', 0), data.get('age', 0), data.get('height', 0),
data.get('weight', 0), data.get('level', 0), data.get('xp', 0),
data.get('maxHealth', 0), data.get('maxMana', 0), drdClass, drdRace,
alignment, data.get('currentHealth', 0), data.get('currentMana', 0))
if nodeId and contextType:
children = self.treeDAO.get_children_objects(nodeId, contextType)
abilities = []
spells = []
effects = []
for child in children:
if child.object.object_type is ObjectType.SPELL:
spell = SpellDAO().get(child.object.id, None, child.id, contextType)
spells.append(spell)
elif child.object.object_type is ObjectType.ABILITY:
ability = AbilityDAO().get(child.object.id, None, child.id, contextType)
abilities.append(ability)
elif child.object.object_type is ObjectType.EFFECT:
effect = EffectDAO().get(child.object.id, None, child.id, contextType)
effects.append(effect)
elif child.object.object_type is ObjectType.ITEM and child.object.type is Items.CONTAINER and child.object.parent_id == -1:
inventory = ItemDAO().get(child.object.id, None, child.id, contextType)
character.inventory = inventory
elif child.object.object_type is ObjectType.ITEM and child.object.type is Items.CONTAINER and child.object.parent_id == -2:
ground = ItemDAO().get(child.object.id, None, child.id, contextType)
character.ground = ground
character.spells = spells
character.abilities = abilities
character.effects = effects
return character
