def showNames(self): """ Zeigt den resultierenden Namen an. Einmal der Name, wie er später auf der Schaltfläche zu sehen sein wird, die diesen Dialog aufruft, einmal den vollständigen Namen mit allen Bestandteilen. """ forenames = self.ui.lineEdit_additionalForenames.text().split( " " ) forenames.insert( 0, self.ui.lineEdit_firstName.text() ) self.ui.label_displayFull.setText( Identity.displayNameFull( self.ui.lineEdit_surname.text(), forenames ) ) self.ui.label_displayDisplay.setText( Identity.displayNameDisplay( self.ui.lineEdit_surname.text(), self.ui.lineEdit_firstName.text(), self.ui.lineEdit_nickname.text() ) ) self.ui.label_displayHonorific.setText( Identity.displayNameHonor( self.ui.lineEdit_firstName.text(), self.ui.lineEdit_honorificName.text() ) ) self.ui.label_displaySuper.setText( self.ui.lineEdit_specialName.text() )
def updateButtonText( self ): """ Aktualisiert die Anzeige des Namens. """ nameStr = Identity.displayNameDisplay(self.__character.identity.surname, self.__character.identity.firstname, self.__character.identity.nickname) nameDisplay = nameStr if not nameStr: nameStr = self.tr("Name") self.ui.pushButton_name.setText( nameStr ) for item in Config.GENDERS: if self.__character.identity.gender == item[0]: self.ui.pushButton_name.setIcon(QIcon(item[1])) break self.nameChanged.emit(nameDisplay)
def __init__(self, character, parent=None): super(NameDialog, self).__init__(parent) self.ui = Ui_NameDialog() self.ui.setupUi(self) self.__character = character self.nameDict = { "Human": "", "Changeling": "AKA", "Mage": "Shadow Name", "Vampire": "AKA", "Werewolf": "Deed Name", } ## Die Identitäten werden nur kopiert. Überschrieben werden sie erst, wenn man den Dialog bestätigt. ## Unschöner Hack, da deepcopy zum Programmabsturz führt. #realIdentity = copy.deepcopy(self.__character.realIdentity) self.identityLcl = Identity() self.identityLcl._name = copy.deepcopy(self.__character.identity._name) self.identityLcl._gender = copy.deepcopy(self.__character.identity._gender) #falseIdentities = copy.deepcopy(self.__character.falseIdentities) for item in Config.GENDERS[1:]: self.ui.comboBox_gender.addItem( QIcon(item[1]), item[0] ) self.ui.lineEdit_firstName.textChanged.connect(self.updateForenames) self.ui.lineEdit_additionalForenames.textChanged.connect(self.updateForenames) self.ui.lineEdit_surname.textChanged.connect(self.updateSurname) self.ui.lineEdit_honorificName.textChanged.connect(self.updateHonorificName) self.ui.lineEdit_nickname.textChanged.connect(self.updateNickname) self.ui.lineEdit_specialName.textChanged.connect(self.updateSpecialName) self.ui.comboBox_gender.currentIndexChanged[str].connect(self.updateGender) self.ui.lineEdit_firstName.textChanged.connect(self.showNames) self.ui.lineEdit_additionalForenames.textChanged.connect(self.showNames) self.ui.lineEdit_surname.textChanged.connect(self.showNames) self.ui.lineEdit_honorificName.textChanged.connect(self.showNames) self.ui.lineEdit_nickname.textChanged.connect(self.showNames) self.ui.lineEdit_specialName.textChanged.connect(self.showNames) self.ui.buttonBox.accepted.connect(self.saveNames) self.ui.buttonBox.rejected.connect(self.reject) #self.__character.speciesChanged.connect(self.renameSpecialNameLabel) self.renameSpecialNameLabel(self.__character.species) self.selectIdentity()
def updateButtonText(self): """ Aktualisiert die Anzeige des Namens. """ nameStr = Identity.displayNameDisplay( self.__character.identity.surname, self.__character.identity.firstname, self.__character.identity.nickname) nameDisplay = nameStr if not nameStr: nameStr = self.tr("Name") self.ui.pushButton_name.setText(nameStr) for item in Config.GENDERS: if self.__character.identity.gender == item[0]: self.ui.pushButton_name.setIcon(QIcon(item[1])) break self.nameChanged.emit(nameDisplay)
class StorageCharacter(QObject): """ @brief In dieser Klasse werden sämtliche Daten des gerade geöffneten Charakters gespeichert. Wird ein Wert durch das Programm geändert, muß der Wert tatsächlich in dieser Klasse verändert werden. Denn der Inhalt dieser Klasse wird beim Speichern in eine Datei geschrieben und beim Laden wird diese Klasse aufgefüllt. Die Anzeige nimmt all ihre Daten aus dieser Klasse. Außerdem bietet diese Klasse angenehme Zugriffsfunktionen aus den Informationen, welche zum Programmstart aus den Template-Dateien geladen werden. """ eraChanged = Signal(str) dateBirthChanged = Signal(object) dateBecomingChanged = Signal(object) dateGameChanged = Signal(object) speciesChanged = Signal(str) virtueChanged = Signal(str) viceChanged = Signal(str) breedChanged = Signal(str) bonusChanged = Signal(object) kithChanged = Signal(str) factionChanged = Signal(str) organisationChanged = Signal(str) partyChanged = Signal(str) descriptionChanged = Signal(str) powerstatChanged = Signal(int) moralityChanged = Signal(int) derangementChanged = Signal(int, str) #traitChanged = Signal(object) #traitsChanged = Signal(object) #ageChanged = Signal(int) ageChanged = Signal((int, ), (str, )) ageBecomingChanged = Signal(int) #ageCategoryChanged = Signal(str, int, int) # (<Child|Adult>, <neues Alter>, <altes Alter>) heightChanged = Signal(float) weightChanged = Signal(float) eyesChanged = Signal(str) hairChanged = Signal(str) nationalityChanged = Signal(str) pictureChanged = Signal(QPixmap) weaponAdded = Signal(str, str) weaponRemoved = Signal(str, str) weaponsChanged = Signal() armorChanged = Signal(str, bool) equipmentAdded = Signal(str) equipmentRemoved = Signal(str) equipmentChanged = Signal() automobileAdded = Signal(str, str) automobileRemoved = Signal(str, str) automobilesChanged = Signal() extraordinaryItemAdded = Signal(str, str) extraordinaryItemRemoved = Signal(str, str) extraordinaryItemsChanged = Signal() magicalToolChanged = Signal(str) nimbusChanged = Signal(str) paradoxMarksChanged = Signal(str) companionNameChanged = Signal(str) companionPowerChanged = Signal(int) companionFinesseChanged = Signal(int) companionResistanceChanged = Signal(int) companionSizeChanged = Signal(int) companionSpeedFactorChanged = Signal(int) companionFuelChanged = Signal(int) companionNuminaChanged = Signal(object) companionBanChanged = Signal(str) ## Dieses Signal enthält alle möglichen Gründe, um eine Eigenschaft zu verstecken, oder sie zu zeigen. species, age, era, breed, faction traitVisibleReasonChanged = Signal(str, str, str, str, str) # Eine Liste sämtlicher verfügbaren Eigenschaften. # # { # Typ1: { # Kategorie1: { # Name1: { "bla": blub, ... } # Name2: { "bla": blub, ... } # Name3: { "bla": blub, ... } # ... # }, # Kategorie2: { # Name1: { "bla": blub, ... } # ... # }, # ... # }, # ... # } __traits = {} # Eine Liste der Waffen. # # { # "melee": [ weapon1, weapon2 ... ], # "thrown": [ weapon1, weapon2 ... ], # "ranged": [ weapon1, weapon2 ... ], # } __weapons = {} # Eine Liste der Fahrzeuge. # # { # Typ1: [ item1, item2 ... ], # Typ2: [ item1, item2 ... ], # ... # } __automobiles = {} # Eine Liste der magischen Gegenstände. # # { # Typ1: [ item1, item2 ... ], # Typ2: [ item1, item2 ... ], # ... # } __extraordinaryItems = {} def __init__(self, template, parent=None): """ \todo Eigentlich benötigt Subpower keinen eigenen Datentyp. Da die ganzen Zusatzinformationen ja nur im Template zu stehen haben und nicht auch für den Charakter bekannt sein müssen. Der Wert "level" ist aber interessant und gilt für andere Klassen nicht. """ super(StorageCharacter, self).__init__(parent) self.__storage = template self.isLoading = False self.__modified = False self.__dateBirth = QDate(1, 1, 1) self.__dateBecoming = QDate(1, 1, 1) self.__dateGame = QDate(1, 1, 1) self.__age = 0 self.__ageBecoming = 0 self.__species = "" self.__virtue = "" self.__vice = "" self.__breed = "" self.__bonus = {} self.__kith = "" self.__faction = "" self.__organisation = "" self.__party = "" self.__height = 0.0 self.__weight = 0.0 self.__eyes = "" self.__hair = "" self.__nationality = "" self.__description = "" self.__powerstat = 0 self.__morality = 0 self.__era = "" self.__picture = None self.__armor = { "name": "", "dedicated": False, } self.__equipment = [] self.__magicalTool = "" self.identity = Identity() self.__derangements = {} self.__nimbus = "" self.__paradoxMarks = "" self.__vinculi = [] for i in range(Config.VINCULI_COUNT_MAX): vinculum = AbstractTrait() self.__vinculi.append(vinculum) vinculum.traitChanged.connect(self.setModified) self.__companionName = "" self.__companionPower = 0 self.__companionFinesse = 0 self.__companionResistance = 0 self.__companionSize = 0 self.__companionSpeedFactor = 0 self.__companionFuel = 0 self.__companionInfluences = [] for i in range(Config.COMPANION_INFLUENCES_MAX): companionInfluence = AbstractTrait() self.__companionInfluences.append(companionInfluence) companionInfluence.traitChanged.connect(self.setModified) self.__companionNumina = [] self.__companionBan = "" self.dateBirthChanged.connect(self.__calcAge) self.dateGameChanged.connect(self.__calcAge) self.dateBirthChanged.connect(self.__calcAgeBecoming) self.dateBecomingChanged.connect(self.__calcAgeBecoming) self.weaponAdded.connect(self.weaponsChanged) self.weaponRemoved.connect(self.weaponsChanged) self.equipmentAdded.connect(self.automobilesChanged) self.equipmentRemoved.connect(self.equipmentChanged) self.automobileAdded.connect(self.automobilesChanged) self.automobileRemoved.connect(self.automobilesChanged) self.extraordinaryItemAdded.connect(self.extraordinaryItemsChanged) self.extraordinaryItemRemoved.connect(self.extraordinaryItemsChanged) # Die Eigenschaften in den Charakter laden. self.__traits = {} # Eigenschaften setzen. for typ in self.__storage.traits.keys(): self.__traits.setdefault(typ, {}) for item in template.traits[typ]: self.__traits[typ].setdefault(item, {}) for subitem in template.traits[typ][item].items(): #Debug.debug(subitem) val = 2 # Dies mache ich, damit beim initialen Charakter-Reset, auch alle Voraussetzungen überprüft werden. # Eigenschaften, die Zusaztext erhalten können (bspw. Language), werden mehrfach in das Dictionary eingefügt. Aber da ein Dictonary immer nur einen Eintrag desselben Namens haben kann, muß selbiger um ein numerisches Suffix erweitert werden. loop = 1 custom = False customText = None if typ != "Subpower" and subitem[1]["custom"]: loop = Config.MULTIPLE_TRAITS_MAX custom = True for i in range(loop): trait = None if typ == "Subpower": trait = SubPowerTrait(self, subitem[1]["name"], val) trait.level = subitem[1]["level"] trait.powers = subitem[1]["powers"] else: if typ == "Attribute" or typ == "Skill": trait = BonusTrait(self, subitem[1]["name"], val) else: trait = StandardTrait(self, subitem[1]["name"], val) trait.age = subitem[1]["age"] trait.era = subitem[1]["era"] trait.custom = custom trait.customText = customText trait.identifier = subitem[0] trait.species = subitem[1]["species"] trait.cheap = subitem[1]["cheap"] #if typ == "Subpower" and trait.species == "Werewolf": #Debug.debug(subitem[1]["name"], subitem[1]["only"]) trait.only = subitem[1]["only"] if "prerequisites" in subitem[1] and subitem[1][ "prerequisites"]: trait.hasPrerequisites = True trait.prerequisitesText = subitem[1][ "prerequisites"] # In der Eigenschaft steht der richtige Name aber im Dictionary der Name mit einem numerischen Suffix, damit die Eigenschaft häufiger auftauchen kann. dictKey = subitem[0] if custom: dictKey = "{}{}".format(subitem[0], i) self.__traits[typ][item].setdefault(dictKey, trait) # Wenn sich eine Eigenschaft ändert, gilt der Charakter als modifiziert. trait.traitChanged.connect(self.setModified) #if typ == "Subpower": #Debug.debug(self.__traits[typ][item]) self.bonusChanged.connect(self.__changeBonusTrait) # Sobald irgendein Aspekt des Charakters verändert wird, muß festgelegt werden, daß sich der Charkater seit dem letzten Speichern verändert hat. # Es ist Aufgabe der Speicher-Funktion, dafür zu sorgen, daß beim Speichern diese Inforamtion wieder zurückgesetzt wird. self.identity.identityChanged.connect(self.setModified) self.eraChanged.connect(self.setModified) self.dateBirthChanged.connect(self.setModified) self.dateBecomingChanged.connect(self.setModified) self.dateGameChanged.connect(self.setModified) # Unerwünschte Wirkung #self.speciesChanged.connect(self.clearUnusableTraits) self.speciesChanged.connect(self.setModified) self.virtueChanged.connect(self.setModified) self.viceChanged.connect(self.setModified) self.breedChanged.connect(self.setModified) self.kithChanged.connect(self.setModified) self.bonusChanged.connect(self.setModified) self.factionChanged.connect(self.setModified) self.partyChanged.connect(self.setModified) self.descriptionChanged.connect(self.setModified) self.powerstatChanged.connect(self.setModified) self.moralityChanged.connect(self.setModified) self.derangementChanged.connect(self.setModified) self.pictureChanged.connect(self.setModified) self.weaponsChanged.connect(self.setModified) self.armorChanged.connect(self.setModified) self.equipmentChanged.connect(self.setModified) self.automobilesChanged.connect(self.setModified) self.extraordinaryItemsChanged.connect(self.setModified) self.magicalToolChanged.connect(self.setModified) self.nimbusChanged.connect(self.setModified) self.paradoxMarksChanged.connect(self.setModified) self.companionPowerChanged.connect(self.setModified) self.companionFinesseChanged.connect(self.setModified) self.companionResistanceChanged.connect(self.setModified) self.companionSizeChanged.connect(self.setModified) self.companionSpeedFactorChanged.connect(self.setModified) self.companionFuelChanged.connect(self.setModified) self.companionNuminaChanged.connect(self.setModified) self.companionBanChanged.connect(self.setModified) self.ageChanged.connect(self.deselctTraitsWithWrongAge) self.speciesChanged.connect(self.__emitTraitVisibleReasonChanged) self.ageChanged.connect(self.__emitTraitVisibleReasonChanged) self.eraChanged.connect(self.__emitTraitVisibleReasonChanged) self.breedChanged.connect(self.__emitTraitVisibleReasonChanged) self.factionChanged.connect(self.__emitTraitVisibleReasonChanged) #connect (self, SIGNAL(realIdentityChanged(cv_Identity)), self, SLOT(emitNameChanged(cv_Identity))); def __emitTraitVisibleReasonChanged(self): ageText = Config.getAge(self.age) self.traitVisibleReasonChanged.emit(self.species, ageText, self.era, self.breed, self.faction) def __getEra(self): """ Gibt die Ära aus, in welcher der Charakter zuhause ist. """ return self.__era def setEra(self, era): """ Legt die Ära fest, in welcher der Charakter zuhause ist. """ if (self.__era != era): self.__era = era #Debug.debug("Ära verändert zu {}".format(era) ) self.eraChanged.emit(era) era = property(__getEra, setEra) def __getDateBirth(self): """ Geburtsdatum des Charakters. """ #Debug.debug(self.__dateBirth) return self.__dateBirth def setDateBirth(self, date): if (self.__dateBirth != date): self.__dateBirth = date self.dateBirthChanged.emit(date) dateBirth = property(__getDateBirth, setDateBirth) def __getDateBecoming(self): """ Das Datum, an welchem sich der Charakters zu einem übernatürlichen Wesen veränderte. """ return self.__dateBecoming def setDateBecoming(self, date): if (self.__dateBecoming != date): self.__dateBecoming = date self.dateBecomingChanged.emit(date) dateBecoming = property(__getDateBecoming, setDateBecoming) def __getDateGame(self): """ Das aktuelle Datum im Spiel. """ return self.__dateGame def setDateGame(self, date): if (self.__dateGame != date): self.__dateGame = date self.dateGameChanged.emit(date) dateGame = property(__getDateGame, setDateGame) @property def age(self): """ Alter des Charakters. """ return self.__age @property def ageBecoming(self): """ Alter des Charakters bei der Veränderung. """ return self.__ageBecoming def __getSpecies(self): """ Gibt die Spezies des Charakters aus. """ return self.__species def setSpecies(self, species): """ Legt die Spezies des Charakters fest. """ if (self.__species != species): self.__species = species #Debug.debug("Spezies in Speicher verändert zu {}!".format(species)) self.speciesChanged.emit(species) species = property(__getSpecies, setSpecies) @property def derangements(self): """ Eine Liste aller Identitäten des Charkaters. Die Identität an Indexposition 0 ist die echte Identität. """ return self.__derangements @derangements.setter def derangements(self, derangements): """ Eine Liste aller Identitäten des Charkaters. Die Identität an Indexposition 0 ist die echte Identität. """ #Debug.debug(derangements) if derangements and self.__derangements != derangements: self.__derangements = derangements ## Jetzt müssen in der richtigen Reihenfolge (hoch nach tief) die Signale gesandt werden. keys = self.__derangements.keys() #Debug.debug(keys, range(min(keys), max(keys)+1)[::-1]) for i in range(min(keys), max(keys) + 1)[::-1]: if i in keys: self.derangementChanged.emit(i, self.__derangements[i]) def setDerangement(self, moralityValue, derangement): """ Legt die Geistesstörung für den zugehörigen Moralwert fest. """ #Debug.debug(moralityValue, type(moralityValue)) if moralityValue not in self.__derangements: if derangement: self.__derangements[moralityValue] = derangement #Debug.debug(derangement, moralityValue) self.derangementChanged.emit(moralityValue, derangement) elif self.__derangements[moralityValue] != derangement: # Wird als Geistesstörung ein leerer String übergeben, wird dieser Eintrag aus der Liste gelöscht. Dennoch wird das Signal einer Änderung mit dem leeren String gesandt. if derangement: self.__derangements[moralityValue] = derangement #Debug.debug(derangement, moralityValue) else: del self.__derangements[moralityValue] self.derangementChanged.emit(moralityValue, derangement) @property def picture(self): """ Charakterbild. """ return self.__picture @picture.setter def picture(self, image): if self.__picture != image: self.__picture = image self.pictureChanged.emit(image) @property def weapons(self): """ Die Liste aller Waffen des Charakters. """ return self.__weapons def addWeapon(self, weapon, category): """ Fügt der Waffenliste eine Waffe hinzu. """ if category not in self.__weapons: self.__weapons.setdefault(category, []) if weapon not in self.__weapons[category]: self.__weapons[category].append(weapon) self.weaponAdded.emit(weapon, category) def deleteWeapon(self, weapon, category): """ Entfernt besagte Waffe aus der Waffenliste. """ if category in self.__weapons: self.__weapons[category].remove(weapon) self.weaponRemoved.emit(weapon, category) @property def armor(self): """ Die Rüstung (Name) des Charakters """ return self.__armor def setArmor(self, name, dedicated=False): if self.__armor["name"] != name or self.__armor[ "dedicated"] != dedicated: self.__armor["name"] = name self.__armor["dedicated"] = dedicated self.armorChanged.emit(name, dedicated) @property def equipment(self): """ Gegenstände im Besitz des Charakters. """ return self.__equipment def addEquipment(self, item): #Debug.debug(item) if item not in self.__equipment: self.__equipment.append(item) self.equipmentAdded.emit(item) def deleteEquipment(self, item): if item in self.__equipment: self.__equipment.remove(item) self.equipmentRemoved.emit(item) @property def automobiles(self): """ Die Liste aller Fahrzeuge des Charakters. """ return self.__automobiles def addAutomobile(self, automobile, category): """ Fügt der Liste ein Fahrzeug hinzu. """ if category not in self.__automobiles: self.__automobiles.setdefault(category, []) if automobile not in self.__automobiles[category]: self.__automobiles[category].append(automobile) self.automobileAdded.emit(automobile, category) def deleteAutomobile(self, automobile, category): """ Entfernt besagtes Fahrzeug aus der Liste. """ if category in self.__automobiles: self.__automobiles[category].remove(automobile) self.automobileRemoved.emit(automobile, category) @property def extraordinaryItems(self): """ Die Liste aller magischen Gegenstände des Charakters. """ return self.__extraordinaryItems def addExtraordinaryItem(self, extraordinaryItem, typ): """ Fügt der Liste der magischen Gegenstände einen hinzu. """ if typ not in self.__extraordinaryItems: self.__extraordinaryItems.setdefault(typ, []) if extraordinaryItem not in self.__extraordinaryItems[typ]: self.__extraordinaryItems[typ].append(extraordinaryItem) self.extraordinaryItemAdded.emit(extraordinaryItem, typ) def deleteExtraordinaryItem(self, extraordinaryItem, typ): """ Entfernt besagten magischen Gegenstand aus der Liste. """ if typ in self.__extraordinaryItems: self.__extraordinaryItems[typ].remove(extraordinaryItem) self.extraordinaryItemRemoved.emit(extraordinaryItem, typ) def __getMagicalTool(self): """ Magisches Werkzeug. """ return self.__magicalTool def setMagicalTool(self, tool): if self.__magicalTool != tool: self.__magicalTool = tool self.magicalToolChanged.emit(tool) magicalTool = property(__getMagicalTool, setMagicalTool) def __getNimbus(self): """ Der Nimbus eines Magiers. """ return self.__nimbus def setNimbus(self, nimbus): if self.__nimbus != nimbus: self.__nimbus = nimbus self.nimbusChanged.emit(nimbus) nimbus = property(__getNimbus, setNimbus) def __getParadoxMarks(self): """ Die Paradoxzeichen eines Magiers. """ return self.__paradoxMarks def setParadoxMarks(self, paradoxMarks): if self.__paradoxMarks != paradoxMarks: self.__paradoxMarks = paradoxMarks self.paradoxMarksChanged.emit(paradoxMarks) paradoxMarks = property(__getParadoxMarks, setParadoxMarks) @property def vinculi(self): """ Die Vinculi eines Vampirs """ return self.__vinculi def __getCompanionName(self): return self.__companionName def setCompanionName(self, name): if self.__companionName != name: self.__companionName = name self.companionNameChanged.emit(name) companionName = property(__getCompanionName, setCompanionName) def __getCompanionPower(self): return self.__companionPower def setCompanionPower(self, power): if self.__companionPower != power: self.__companionPower = power self.companionPowerChanged.emit(power) companionPower = property(__getCompanionPower, setCompanionPower) def __getCompanionFinesse(self): return self.__companionFinesse def setCompanionFinesse(self, finesse): if self.__companionFinesse != finesse: self.__companionFinesse = finesse self.companionFinesseChanged.emit(finesse) companionFinesse = property(__getCompanionFinesse, setCompanionFinesse) def __getCompanionResistance(self): return self.__companionResistance def setCompanionResistance(self, resistance): if self.__companionResistance != resistance: self.__companionResistance = resistance self.companionResistanceChanged.emit(resistance) companionResistance = property(__getCompanionResistance, setCompanionResistance) def __getCompanionSize(self): return self.__companionSize def setCompanionSize(self, size): if self.__companionSize != size: self.__companionSize = size self.companionSizeChanged.emit(size) companionSize = property(__getCompanionSize, setCompanionSize) def __getCompanionSpeedFactor(self): return self.__companionSpeedFactor def setCompanionSpeedFactor(self, speedFactor): if self.__companionSpeedFactor != speedFactor: self.__companionSpeedFactor = speedFactor self.companionSpeedFactorChanged.emit(speedFactor) companionSpeedFactor = property(__getCompanionSpeedFactor, setCompanionSpeedFactor) def __getCompanionFuel(self): return self.__companionFuel def setCompanionFuel(self, fuel): if self.__companionFuel != fuel: self.__companionFuel = fuel self.companionFuelChanged.emit(fuel) companionFuel = property(__getCompanionFuel, setCompanionFuel) @property def companionInfluences(self): """ Die Einflüsse eines Vertrauten-Geistes. """ return self.__companionInfluences @property def companionNumina(self): return self.__companionNumina @companionNumina.setter def companionNumina(self, numina): if self.__companionNumina != numina: self.__companionNumina = numina self.companionNuminaChanged.emit(numina) def appendCompanionNumen(self, numen): self.__companionNumina.append(numen) def removeCompanionNumen(self, numen): self.__companionNumina.remove(numen) def __getCompanionBan(self): return self.__companionBan def setCompanionBan(self, ban): if self.__companionBan != ban: self.__companionBan = ban self.companionBanChanged.emit(ban) companionBan = property(__getCompanionBan, setCompanionBan) @property def traits(self): return self.__traits #def __setTraits(self, traits): #if self.__traits != traits: #self.__traits = traits #self.traitsChanged.emit(traits) @property def subPowers(self): return self.__subPowers def __calcAge(self): """ Zur Berechnung des Alters werden Geburtstag und Datum im Spiel herangezogen. """ age = Calc.years(self.dateBirth, self.dateGame) if self.__age != age: ageCtagoryChanged = False if Config.getAge(self.__age) != Config.getAge(age): ageCtagoryChanged = True self.__age = age self.ageChanged.emit(age) if ageCtagoryChanged: self.ageChanged[str].emit(Config.getAge(age)) def __calcAgeBecoming(self): """ Zur Berechnung des Alters zum Zeitpunkt der Veränderung (Erwachen, Kuß, erste Verwandlung etc.) werden Geburtsdatum und Datum der Veränderung genutzt. """ age = Calc.years(self.dateBirth, self.dateBecoming) if self.__ageBecoming != age: self.__ageBecoming = age self.ageBecomingChanged.emit(age) def __getVirtue(self): """ Tugend des Charakters """ return self.__virtue def setVirtue(self, virtue): """ Verändert die Tugend. Bei einer Veränderung wird das Signal virtueChanged() ausgesandt. """ if (self.__virtue != virtue): self.__virtue = virtue self.virtueChanged.emit(virtue) virtue = property(__getVirtue, setVirtue) def __getVice(self): """ Laster des Charakters """ return self.__vice def setVice(self, vice): """ Verändert das Laster. Bei einer Veränderung wird das Signal viceChanged() ausgesandt. """ if (self.__vice != vice): self.__vice = vice self.viceChanged.emit(vice) vice = property(__getVice, setVice) def __getBreed(self): """ Brut (Seeming, Path, Clan, Auspice) des Charakters. """ return self.__breed def setBreed(self, breed): """ Verändert die Brut. Bei einer Veränderung wird das Signal breedChanged() ausgesandt. """ if self.__breed != breed: self.__breed = breed self.breedChanged.emit(breed) breed = property(__getBreed, setBreed) def __getBonus(self): """ Bonuseigenschaft """ return self.__bonus def setBonus(self, bonus): """ Verändert die Bonuseigenschaft. Die Bonuseigenschaft wird folgendermaßen gespeichert. Der Eintrag für die Spezialisierung ist optional. { "type": Typ, "name": Name, "specialty": Gewählte Spezialisierung, } """ #Debug.debug(bonus) if (self.__bonus != bonus): #Debug.debug(bonus) self.__bonus = bonus self.bonusChanged.emit(bonus) bonus = property(__getBonus, setBonus) def __changeBonusTrait(self, bonus): """ Ändert die Bonuseigenschaft. \todo Wenn die Erschaffungsphase vorüber ist, sollte die Bonuseigenschaft nichtmehr verändert werden können und die davon betroffene Eigenscahft wie eine normale Eigenschaft mit erhöhtem Wert, zusätzlicher Spezialisierung betrachtet werden. """ ## Alle bisherigen Bonuseigenschaften löschen, denn es kann immer nur eine solche geben. for typ in self.traits: for category in self.traits[typ]: for identifier in self.traits[typ][category]: if type(self.traits[typ][category] [identifier]) == BonusTrait: self.traits[typ][category][identifier].clearBonus() if bonus: for category in self.traits[bonus["type"]]: if bonus["name"] in self.traits[ bonus["type"]][category].keys(): if type(self.traits[bonus["type"]][category][ bonus["name"]]) == BonusTrait: if bonus["type"] == "Attribute": self.traits[bonus["type"]][category][ bonus["name"]].bonusValue = 1 #Debug.debug("Bonuseigenschaft {} verändert!".format(self.traits[bonus["type"]][category][bonus["name"]].name)) elif bonus["type"] == "Skill" and "specialty" in bonus: self.traits[bonus["type"]][category][ bonus["name"]].bonusSpecialties = [ bonus["specialty"] ] #Debug.debug("Bonuseigenschaft {} verändert!".format(self.traits[bonus["type"]][category][bonus["name"]].name)) break def __getKith(self): """ Kith der Wechselbälger """ return self.__kith def setKith(self, kith): """ Verändert das Kith. """ if (self.__kith != kith): self.__kith = kith self.kithChanged.emit(kith) kith = property(__getKith, setKith) def __getFaction(self): """ Fraktion (Court, Order, Covenant, Tribe) des Charakters. """ return self.__faction def setFaction(self, faction): """ Verändert die Fraktion. Bei einer Veränderung wird das Signal factionChanged() ausgesandt. """ if (self.__faction != faction): self.__faction = faction self.factionChanged.emit(faction) faction = property(__getFaction, setFaction) def __getOrganisation(self): """ Organisation (Entitlement, Legacy, Bloodline, Lodge) des Charakters. """ return self.__organisation def setOrganisation(self, organisation): """ Verändert die Organisation. Bei einer Veränderung wird das Signal organisationChanged() ausgesandt. """ if (self.__organisation != organisation): self.__organisation = organisation self.organisationChanged.emit(organisation) organisation = property(__getOrganisation, setOrganisation) def __getParty(self): """ Name der Freundesgruppe des Charakters. """ return self.__party def setParty(self, party): if (self.__party != party): self.__party = party self.partyChanged.emit(party) party = property(__getParty, setParty) def __getHeight(self): """ Größe des Charakters in m. """ return self.__height def setHeight(self, height): if (self.__height != height): self.__height = height self.heightChanged.emit(height) height = property(__getHeight, setHeight) def __getWeight(self): """ Gewicht des Charakters in kg. """ return self.__weight def setWeight(self, weight): if (self.__weight != weight): self.__weight = weight self.weightChanged.emit(weight) weight = property(__getWeight, setWeight) def __getEyes(self): """ Beschreibung der Augen des Charakters. """ return self.__eyes def setEyes(self, eyes): if (self.__eyes != eyes): self.__eyes = eyes self.eyesChanged.emit(eyes) eyes = property(__getEyes, setEyes) def __getHair(self): """ Beschreibung der Haare des Charakters. """ return self.__hair def setHair(self, hair): if (self.__hair != hair): self.__hair = hair self.hairChanged.emit(hair) hair = property(__getHair, setHair) def __getNationality(self): """ Die Nationalität des Charakters. """ return self.__nationality def setNationality(self, nationality): if (self.__nationality != nationality): self.__nationality = nationality self.nationalityChanged.emit(nationality) nationality = property(__getNationality, setNationality) @property def description(self): """ Name der Freundesgruppe des Charakters. """ return self.__description @description.setter def description(self, text): if (self.__description != text): self.__description = text self.descriptionChanged.emit(text) def __getPowerstat(self): """ Gibt den Wert des Super-Attributs aus. """ return self.__powerstat def setPowerstat(self, value): """ Verändert den Wert des Super-Attributs. Bei einer Veränderung wird das Signal powerstatChanged() ausgesandt. """ if (self.__powerstat != value): self.__powerstat = value self.powerstatChanged.emit(value) powerstat = property(__getPowerstat, setPowerstat) def __getMorality(self): """ Gibt den Wert der Moral aus. """ return self.__morality def setMorality(self, value): """ Verändert den Wert der Moral. Bei einer Veränderung wird das Signal moralityChanged() ausgesandt. """ if (self.__morality != value): self.__morality = value #Debug.debug("Moral verändert auf {}".format(value)) self.moralityChanged.emit(value) morality = property(__getMorality, setMorality) def resetCharacter(self): ## Der Charkater wird umorganisiert, ohne daß wir haufenweise Warnhinweise haben wollen. self.isLoading = True # Standardspezies ist der Mensch. self.species = Config.SPECIES_INITIAL # Zeitalter festlegen. self.era = Config.ERA_INITIAL ## Anfangsdatum setzen. self.dateGame = QDate.currentDate() self.dateBirth = QDate(self.dateGame.year() - Config.AGE_INITIAL, self.dateGame.month(), self.dateGame.day()) self.dateBecoming = QDate(self.dateGame.year() - Config.AGE_ADULT, self.dateGame.month(), self.dateGame.day()) # Löschen aller Identitäten. self.identity.reset() #Debug.debug(self.__storage.virtues[0]) #Debug.debug(self.__storage.virtues[0]["name"]) self.virtue = self.__storage.virtues[0]["name"] self.vice = self.__storage.vices[0]["name"] self.breed = "" self.bonus = "" self.kith = "" self.faction = "" self.height = 1.60 self.weight = 60 self.eyes = "" self.hair = "" self.nationality = "" # Nicht notwendig, da ja schon die Spezies gewechselt wird, was automatisch diese Felder zurücksetzt. #self.breed = self.__storage.breeds(Config.SPECIES_INITIAL)[0] self.__derangements = {} self.party = "" self.description = "" # Menschen haben eine Leere liste, also kann ich auch die Indizes nicht ändern. #// setBreed(storage.breedNames(species()).at(0)); #// setFaction(storage.breedNames(species()).at(0)); # Attribute und andere Eigenschaften auf Anfangswerte setzen. for item in self.__traits: val = 0 if item == "Attribute": val = 1 for subitem in self.__traits[item]: for subsubitem in self.__traits[item][subitem].values(): subsubitem.value = val subsubitem.customText = "" subsubitem.specialties = [] self.morality = Config.TRAIT_MORALITY_VALUE_DEFAULT # Übernatürliche Eigenschaft festlegen. self.powerstat = Config.TRAIT_POWERSTAT_VALUE_DEFAULT # Beim Löschen ist darauf zu achten, daß ich nicht aus der Liste löschen kann, über die ich iteriere. Sonst wird nicht alles gelöscht. for category in self.__weapons: ## Kopie erstellen weaponList = self.__weapons[category][:] for weapon in weaponList: self.deleteWeapon(category, weapon) self.setArmor(name="") ## Kopie erstellen eqipmentList = self.__equipment[:] for item in eqipmentList: self.deleteEquipment(item) for category in self.__automobiles: ## Kopie erstellen automobileList = self.__automobiles[category][:] for automobile in automobileList: self.deleteAutomobile(category, automobile) for typ in self.__extraordinaryItems: ## Kopie erstellen extraordinaryItemList = self.__extraordinaryItems[typ][:] for item in extraordinaryItemList: self.deleteExtraordinaryItem(typ, item) self.magicalTool = "" self.nimbus = "" self.paradoxMarks = "" for vinculum in self.__vinculi: vinculum.name = "" vinculum.value = 0 self.companionName = "" self.companionPower = 0 self.companionFinesse = 0 self.companionResistance = 0 self.companionSize = 0 self.companionSpeedFactor = 0 self.companionFuel = 0 for companionInfluence in self.__companionInfluences: companionInfluence.name = "" companionInfluence.value = 0 self.companionNumina = [] self.companionBan = "" self.picture = QPixmap() ## Fertig mit dem Laden der enuen Werte. self.isLoading = False def isModifed(self): return self.__modified def setModified(self, sw=True): if (self.__modified != sw): self.__modified = sw # Unerwünschte Funktion. #def clearUnusableTraits(self, species): #""" #Beim Wechsel der Spezies werden zahlreiche Eigenschaften für den Charakter unnutzbar. Diese werden auf den Wert 0 gesetzt. #\todo Möglicherweise will ich das garnicht. Dann kan ich beim Zurücksetzen der Spezies wieder die zuvor gewählten Powers darstellen. Es muß natürlich darauf geachtet werden, daß beim Speichern nur eigenschaft der richtigen Spezies gespeichert werden und auf dem Charakterbogen auch nur die verwendbaren Werte auftauchen. #""" ### Es müssen nur bei ein paar Typen die Eigenschaft durchsucht werden. #typesToClear = ( "Merit", "Flaw", "Power", ) #for typ in typesToClear: #for item in self.__traits[typ]: #for subitem in self.__traits[typ][item].values(): #if subitem.species and subitem.species != species and subitem.value != 0: ##Debug.debug("Setze {} auf 0.".format(subitem.name)) #subitem.value = 0 def checkPrerequisites(self, trait): """ Diese Funktion überprüft, ob die Voraussetzungen der Eigenschaft "trait" erfüllt sind oder nicht. \todo Den SyntaxError sollte ich nicht verstecken! """ ConnectPrerequisites.checkPrerequisites(trait, self.__storage, self) def deselctTraitsWithWrongAge(self, age): """ \todo Man sollte nicht bei jedem Alterswechsel über alle Eigenschaften laufen, sondern zu Beginn des Programms alle Eigenschaften mit "Kid" bzw. "Adult" mit ageChanged verknüpfen. """ for typ in self.__traits: for category in self.__traits[typ]: for trait in self.__traits[typ][category].values(): if type( trait ) == StandardTrait and trait.age and trait.age != Config.getAge( self.age) and trait.value > 0: trait.value = 0
def __init__(self, template, parent=None): """ \todo Eigentlich benötigt Subpower keinen eigenen Datentyp. Da die ganzen Zusatzinformationen ja nur im Template zu stehen haben und nicht auch für den Charakter bekannt sein müssen. Der Wert "level" ist aber interessant und gilt für andere Klassen nicht. """ super(StorageCharacter, self).__init__(parent) self.__storage = template self.isLoading = False self.__modified = False self.__dateBirth = QDate(1, 1, 1) self.__dateBecoming = QDate(1, 1, 1) self.__dateGame = QDate(1, 1, 1) self.__age = 0 self.__ageBecoming = 0 self.__species = "" self.__virtue = "" self.__vice = "" self.__breed = "" self.__bonus = {} self.__kith = "" self.__faction = "" self.__organisation = "" self.__party = "" self.__height = 0.0 self.__weight = 0.0 self.__eyes = "" self.__hair = "" self.__nationality = "" self.__description = "" self.__powerstat = 0 self.__morality = 0 self.__era = "" self.__picture = None self.__armor = { "name": "", "dedicated": False, } self.__equipment = [] self.__magicalTool = "" self.identity = Identity() self.__derangements = {} self.__nimbus = "" self.__paradoxMarks = "" self.__vinculi = [] for i in range(Config.VINCULI_COUNT_MAX): vinculum = AbstractTrait() self.__vinculi.append(vinculum) vinculum.traitChanged.connect(self.setModified) self.__companionName = "" self.__companionPower = 0 self.__companionFinesse = 0 self.__companionResistance = 0 self.__companionSize = 0 self.__companionSpeedFactor = 0 self.__companionFuel = 0 self.__companionInfluences = [] for i in range(Config.COMPANION_INFLUENCES_MAX): companionInfluence = AbstractTrait() self.__companionInfluences.append(companionInfluence) companionInfluence.traitChanged.connect(self.setModified) self.__companionNumina = [] self.__companionBan = "" self.dateBirthChanged.connect(self.__calcAge) self.dateGameChanged.connect(self.__calcAge) self.dateBirthChanged.connect(self.__calcAgeBecoming) self.dateBecomingChanged.connect(self.__calcAgeBecoming) self.weaponAdded.connect(self.weaponsChanged) self.weaponRemoved.connect(self.weaponsChanged) self.equipmentAdded.connect(self.automobilesChanged) self.equipmentRemoved.connect(self.equipmentChanged) self.automobileAdded.connect(self.automobilesChanged) self.automobileRemoved.connect(self.automobilesChanged) self.extraordinaryItemAdded.connect(self.extraordinaryItemsChanged) self.extraordinaryItemRemoved.connect(self.extraordinaryItemsChanged) # Die Eigenschaften in den Charakter laden. self.__traits = {} # Eigenschaften setzen. for typ in self.__storage.traits.keys(): self.__traits.setdefault(typ, {}) for item in template.traits[typ]: self.__traits[typ].setdefault(item, {}) for subitem in template.traits[typ][item].items(): #Debug.debug(subitem) val = 2 # Dies mache ich, damit beim initialen Charakter-Reset, auch alle Voraussetzungen überprüft werden. # Eigenschaften, die Zusaztext erhalten können (bspw. Language), werden mehrfach in das Dictionary eingefügt. Aber da ein Dictonary immer nur einen Eintrag desselben Namens haben kann, muß selbiger um ein numerisches Suffix erweitert werden. loop = 1 custom = False customText = None if typ != "Subpower" and subitem[1]["custom"]: loop = Config.MULTIPLE_TRAITS_MAX custom = True for i in range(loop): trait = None if typ == "Subpower": trait = SubPowerTrait(self, subitem[1]["name"], val) trait.level = subitem[1]["level"] trait.powers = subitem[1]["powers"] else: if typ == "Attribute" or typ == "Skill": trait = BonusTrait(self, subitem[1]["name"], val) else: trait = StandardTrait(self, subitem[1]["name"], val) trait.age = subitem[1]["age"] trait.era = subitem[1]["era"] trait.custom = custom trait.customText = customText trait.identifier = subitem[0] trait.species = subitem[1]["species"] trait.cheap = subitem[1]["cheap"] #if typ == "Subpower" and trait.species == "Werewolf": #Debug.debug(subitem[1]["name"], subitem[1]["only"]) trait.only = subitem[1]["only"] if "prerequisites" in subitem[1] and subitem[1][ "prerequisites"]: trait.hasPrerequisites = True trait.prerequisitesText = subitem[1][ "prerequisites"] # In der Eigenschaft steht der richtige Name aber im Dictionary der Name mit einem numerischen Suffix, damit die Eigenschaft häufiger auftauchen kann. dictKey = subitem[0] if custom: dictKey = "{}{}".format(subitem[0], i) self.__traits[typ][item].setdefault(dictKey, trait) # Wenn sich eine Eigenschaft ändert, gilt der Charakter als modifiziert. trait.traitChanged.connect(self.setModified) #if typ == "Subpower": #Debug.debug(self.__traits[typ][item]) self.bonusChanged.connect(self.__changeBonusTrait) # Sobald irgendein Aspekt des Charakters verändert wird, muß festgelegt werden, daß sich der Charkater seit dem letzten Speichern verändert hat. # Es ist Aufgabe der Speicher-Funktion, dafür zu sorgen, daß beim Speichern diese Inforamtion wieder zurückgesetzt wird. self.identity.identityChanged.connect(self.setModified) self.eraChanged.connect(self.setModified) self.dateBirthChanged.connect(self.setModified) self.dateBecomingChanged.connect(self.setModified) self.dateGameChanged.connect(self.setModified) # Unerwünschte Wirkung #self.speciesChanged.connect(self.clearUnusableTraits) self.speciesChanged.connect(self.setModified) self.virtueChanged.connect(self.setModified) self.viceChanged.connect(self.setModified) self.breedChanged.connect(self.setModified) self.kithChanged.connect(self.setModified) self.bonusChanged.connect(self.setModified) self.factionChanged.connect(self.setModified) self.partyChanged.connect(self.setModified) self.descriptionChanged.connect(self.setModified) self.powerstatChanged.connect(self.setModified) self.moralityChanged.connect(self.setModified) self.derangementChanged.connect(self.setModified) self.pictureChanged.connect(self.setModified) self.weaponsChanged.connect(self.setModified) self.armorChanged.connect(self.setModified) self.equipmentChanged.connect(self.setModified) self.automobilesChanged.connect(self.setModified) self.extraordinaryItemsChanged.connect(self.setModified) self.magicalToolChanged.connect(self.setModified) self.nimbusChanged.connect(self.setModified) self.paradoxMarksChanged.connect(self.setModified) self.companionPowerChanged.connect(self.setModified) self.companionFinesseChanged.connect(self.setModified) self.companionResistanceChanged.connect(self.setModified) self.companionSizeChanged.connect(self.setModified) self.companionSpeedFactorChanged.connect(self.setModified) self.companionFuelChanged.connect(self.setModified) self.companionNuminaChanged.connect(self.setModified) self.companionBanChanged.connect(self.setModified) self.ageChanged.connect(self.deselctTraitsWithWrongAge) self.speciesChanged.connect(self.__emitTraitVisibleReasonChanged) self.ageChanged.connect(self.__emitTraitVisibleReasonChanged) self.eraChanged.connect(self.__emitTraitVisibleReasonChanged) self.breedChanged.connect(self.__emitTraitVisibleReasonChanged) self.factionChanged.connect(self.__emitTraitVisibleReasonChanged)
class StorageCharacter(QObject): """ @brief In dieser Klasse werden sämtliche Daten des gerade geöffneten Charakters gespeichert. Wird ein Wert durch das Programm geändert, muß der Wert tatsächlich in dieser Klasse verändert werden. Denn der Inhalt dieser Klasse wird beim Speichern in eine Datei geschrieben und beim Laden wird diese Klasse aufgefüllt. Die Anzeige nimmt all ihre Daten aus dieser Klasse. Außerdem bietet diese Klasse angenehme Zugriffsfunktionen aus den Informationen, welche zum Programmstart aus den Template-Dateien geladen werden. """ eraChanged = Signal(str) dateBirthChanged = Signal(object) dateBecomingChanged = Signal(object) dateGameChanged = Signal(object) speciesChanged = Signal(str) virtueChanged = Signal(str) viceChanged = Signal(str) breedChanged = Signal(str) bonusChanged = Signal(object) kithChanged = Signal(str) factionChanged = Signal(str) organisationChanged = Signal(str) partyChanged = Signal(str) descriptionChanged = Signal(str) powerstatChanged = Signal(int) moralityChanged = Signal(int) derangementChanged = Signal(int, str) #traitChanged = Signal(object) #traitsChanged = Signal(object) #ageChanged = Signal(int) ageChanged = Signal((int,), (str,)) ageBecomingChanged = Signal(int) #ageCategoryChanged = Signal(str, int, int) # (<Child|Adult>, <neues Alter>, <altes Alter>) heightChanged = Signal(float) weightChanged = Signal(float) eyesChanged = Signal(str) hairChanged = Signal(str) nationalityChanged = Signal(str) pictureChanged = Signal(QPixmap) weaponAdded = Signal(str, str) weaponRemoved = Signal(str, str) weaponsChanged = Signal() armorChanged = Signal(str, bool) equipmentAdded = Signal(str) equipmentRemoved = Signal(str) equipmentChanged = Signal() automobileAdded = Signal(str, str) automobileRemoved = Signal(str, str) automobilesChanged = Signal() extraordinaryItemAdded = Signal(str, str) extraordinaryItemRemoved = Signal(str, str) extraordinaryItemsChanged = Signal() magicalToolChanged = Signal(str) nimbusChanged = Signal(str) paradoxMarksChanged = Signal(str) companionNameChanged = Signal(str) companionPowerChanged = Signal(int) companionFinesseChanged = Signal(int) companionResistanceChanged = Signal(int) companionSizeChanged = Signal(int) companionSpeedFactorChanged = Signal(int) companionFuelChanged = Signal(int) companionNuminaChanged = Signal(object) companionBanChanged = Signal(str) ## Dieses Signal enthält alle möglichen Gründe, um eine Eigenschaft zu verstecken, oder sie zu zeigen. species, age, era, breed, faction traitVisibleReasonChanged = Signal(str, str, str, str, str) # Eine Liste sämtlicher verfügbaren Eigenschaften. # # { # Typ1: { # Kategorie1: { # Name1: { "bla": blub, ... } # Name2: { "bla": blub, ... } # Name3: { "bla": blub, ... } # ... # }, # Kategorie2: { # Name1: { "bla": blub, ... } # ... # }, # ... # }, # ... # } __traits = {} # Eine Liste der Waffen. # # { # "melee": [ weapon1, weapon2 ... ], # "thrown": [ weapon1, weapon2 ... ], # "ranged": [ weapon1, weapon2 ... ], # } __weapons = {} # Eine Liste der Fahrzeuge. # # { # Typ1: [ item1, item2 ... ], # Typ2: [ item1, item2 ... ], # ... # } __automobiles = {} # Eine Liste der magischen Gegenstände. # # { # Typ1: [ item1, item2 ... ], # Typ2: [ item1, item2 ... ], # ... # } __extraordinaryItems = {} def __init__(self, template, parent=None): """ \todo Eigentlich benötigt Subpower keinen eigenen Datentyp. Da die ganzen Zusatzinformationen ja nur im Template zu stehen haben und nicht auch für den Charakter bekannt sein müssen. Der Wert "level" ist aber interessant und gilt für andere Klassen nicht. """ super(StorageCharacter, self).__init__(parent) self.__storage = template self.isLoading = False self.__modified = False self.__dateBirth = QDate(1, 1, 1) self.__dateBecoming = QDate(1, 1, 1) self.__dateGame = QDate(1, 1, 1) self.__age = 0 self.__ageBecoming = 0 self.__species = "" self.__virtue = "" self.__vice = "" self.__breed = "" self.__bonus = {} self.__kith = "" self.__faction = "" self.__organisation = "" self.__party = "" self.__height = 0.0 self.__weight = 0.0 self.__eyes = "" self.__hair = "" self.__nationality = "" self.__description = "" self.__powerstat = 0 self.__morality = 0 self.__era = "" self.__picture = None self.__armor = { "name": "", "dedicated": False, } self.__equipment = [] self.__magicalTool = "" self.identity = Identity() self.__derangements = {} self.__nimbus = "" self.__paradoxMarks = "" self.__vinculi = [] for i in range(Config.VINCULI_COUNT_MAX): vinculum = AbstractTrait() self.__vinculi.append(vinculum) vinculum.traitChanged.connect(self.setModified) self.__companionName = "" self.__companionPower = 0 self.__companionFinesse = 0 self.__companionResistance = 0 self.__companionSize = 0 self.__companionSpeedFactor = 0 self.__companionFuel = 0 self.__companionInfluences = [] for i in range(Config.COMPANION_INFLUENCES_MAX): companionInfluence = AbstractTrait() self.__companionInfluences.append(companionInfluence) companionInfluence.traitChanged.connect(self.setModified) self.__companionNumina = [] self.__companionBan = "" self.dateBirthChanged.connect(self.__calcAge) self.dateGameChanged.connect(self.__calcAge) self.dateBirthChanged.connect(self.__calcAgeBecoming) self.dateBecomingChanged.connect(self.__calcAgeBecoming) self.weaponAdded.connect(self.weaponsChanged) self.weaponRemoved.connect(self.weaponsChanged) self.equipmentAdded.connect(self.automobilesChanged) self.equipmentRemoved.connect(self.equipmentChanged) self.automobileAdded.connect(self.automobilesChanged) self.automobileRemoved.connect(self.automobilesChanged) self.extraordinaryItemAdded.connect(self.extraordinaryItemsChanged) self.extraordinaryItemRemoved.connect(self.extraordinaryItemsChanged) # Die Eigenschaften in den Charakter laden. self.__traits = {} # Eigenschaften setzen. for typ in self.__storage.traits.keys(): self.__traits.setdefault(typ, {}) for item in template.traits[typ]: self.__traits[typ].setdefault(item, {}) for subitem in template.traits[typ][item].items(): #Debug.debug(subitem) val = 2 # Dies mache ich, damit beim initialen Charakter-Reset, auch alle Voraussetzungen überprüft werden. # Eigenschaften, die Zusaztext erhalten können (bspw. Language), werden mehrfach in das Dictionary eingefügt. Aber da ein Dictonary immer nur einen Eintrag desselben Namens haben kann, muß selbiger um ein numerisches Suffix erweitert werden. loop = 1 custom = False customText = None if typ != "Subpower" and subitem[1]["custom"]: loop = Config.MULTIPLE_TRAITS_MAX custom = True for i in range(loop): trait = None if typ == "Subpower": trait = SubPowerTrait(self, subitem[1]["name"], val) trait.level = subitem[1]["level"] trait.powers = subitem[1]["powers"] else: if typ == "Attribute" or typ == "Skill": trait = BonusTrait(self, subitem[1]["name"], val) else: trait = StandardTrait(self, subitem[1]["name"], val) trait.age = subitem[1]["age"] trait.era = subitem[1]["era"] trait.custom = custom trait.customText = customText trait.identifier = subitem[0] trait.species = subitem[1]["species"] trait.cheap = subitem[1]["cheap"] #if typ == "Subpower" and trait.species == "Werewolf": #Debug.debug(subitem[1]["name"], subitem[1]["only"]) trait.only = subitem[1]["only"] if "prerequisites" in subitem[1] and subitem[1]["prerequisites"]: trait.hasPrerequisites = True trait.prerequisitesText = subitem[1]["prerequisites"] # In der Eigenschaft steht der richtige Name aber im Dictionary der Name mit einem numerischen Suffix, damit die Eigenschaft häufiger auftauchen kann. dictKey = subitem[0] if custom: dictKey = "{}{}".format(subitem[0], i) self.__traits[typ][item].setdefault(dictKey, trait) # Wenn sich eine Eigenschaft ändert, gilt der Charakter als modifiziert. trait.traitChanged.connect(self.setModified) #if typ == "Subpower": #Debug.debug(self.__traits[typ][item]) self.bonusChanged.connect(self.__changeBonusTrait) # Sobald irgendein Aspekt des Charakters verändert wird, muß festgelegt werden, daß sich der Charkater seit dem letzten Speichern verändert hat. # Es ist Aufgabe der Speicher-Funktion, dafür zu sorgen, daß beim Speichern diese Inforamtion wieder zurückgesetzt wird. self.identity.identityChanged.connect(self.setModified) self.eraChanged.connect(self.setModified) self.dateBirthChanged.connect(self.setModified) self.dateBecomingChanged.connect(self.setModified) self.dateGameChanged.connect(self.setModified) # Unerwünschte Wirkung #self.speciesChanged.connect(self.clearUnusableTraits) self.speciesChanged.connect(self.setModified) self.virtueChanged.connect(self.setModified) self.viceChanged.connect(self.setModified) self.breedChanged.connect(self.setModified) self.kithChanged.connect(self.setModified) self.bonusChanged.connect(self.setModified) self.factionChanged.connect(self.setModified) self.partyChanged.connect(self.setModified) self.descriptionChanged.connect(self.setModified) self.powerstatChanged.connect(self.setModified) self.moralityChanged.connect(self.setModified) self.derangementChanged.connect(self.setModified) self.pictureChanged.connect(self.setModified) self.weaponsChanged.connect(self.setModified) self.armorChanged.connect(self.setModified) self.equipmentChanged.connect(self.setModified) self.automobilesChanged.connect(self.setModified) self.extraordinaryItemsChanged.connect(self.setModified) self.magicalToolChanged.connect(self.setModified) self.nimbusChanged.connect(self.setModified) self.paradoxMarksChanged.connect(self.setModified) self.companionPowerChanged.connect(self.setModified) self.companionFinesseChanged.connect(self.setModified) self.companionResistanceChanged.connect(self.setModified) self.companionSizeChanged.connect(self.setModified) self.companionSpeedFactorChanged.connect(self.setModified) self.companionFuelChanged.connect(self.setModified) self.companionNuminaChanged.connect(self.setModified) self.companionBanChanged.connect(self.setModified) self.ageChanged.connect(self.deselctTraitsWithWrongAge) self.speciesChanged.connect(self.__emitTraitVisibleReasonChanged) self.ageChanged.connect(self.__emitTraitVisibleReasonChanged) self.eraChanged.connect(self.__emitTraitVisibleReasonChanged) self.breedChanged.connect(self.__emitTraitVisibleReasonChanged) self.factionChanged.connect(self.__emitTraitVisibleReasonChanged) #connect (self, SIGNAL(realIdentityChanged(cv_Identity)), self, SLOT(emitNameChanged(cv_Identity))); def __emitTraitVisibleReasonChanged(self): ageText = Config.getAge(self.age) self.traitVisibleReasonChanged.emit(self.species, ageText, self.era, self.breed, self.faction) def __getEra(self): """ Gibt die Ära aus, in welcher der Charakter zuhause ist. """ return self.__era def setEra( self, era ): """ Legt die Ära fest, in welcher der Charakter zuhause ist. """ if ( self.__era != era ): self.__era = era #Debug.debug("Ära verändert zu {}".format(era) ) self.eraChanged.emit( era ) era = property(__getEra, setEra) def __getDateBirth(self): """ Geburtsdatum des Charakters. """ #Debug.debug(self.__dateBirth) return self.__dateBirth def setDateBirth( self, date ): if ( self.__dateBirth != date ): self.__dateBirth = date self.dateBirthChanged.emit( date ) dateBirth = property(__getDateBirth, setDateBirth) def __getDateBecoming(self): """ Das Datum, an welchem sich der Charakters zu einem übernatürlichen Wesen veränderte. """ return self.__dateBecoming def setDateBecoming( self, date ): if ( self.__dateBecoming != date ): self.__dateBecoming = date self.dateBecomingChanged.emit( date ) dateBecoming = property(__getDateBecoming, setDateBecoming) def __getDateGame(self): """ Das aktuelle Datum im Spiel. """ return self.__dateGame def setDateGame( self, date ): if ( self.__dateGame != date ): self.__dateGame = date self.dateGameChanged.emit( date ) dateGame = property(__getDateGame, setDateGame) @property def age(self): """ Alter des Charakters. """ return self.__age @property def ageBecoming(self): """ Alter des Charakters bei der Veränderung. """ return self.__ageBecoming def __getSpecies(self): """ Gibt die Spezies des Charakters aus. """ return self.__species def setSpecies( self, species ): """ Legt die Spezies des Charakters fest. """ if ( self.__species != species ): self.__species = species #Debug.debug("Spezies in Speicher verändert zu {}!".format(species)) self.speciesChanged.emit( species ) species = property(__getSpecies, setSpecies) @property def derangements(self): """ Eine Liste aller Identitäten des Charkaters. Die Identität an Indexposition 0 ist die echte Identität. """ return self.__derangements @derangements.setter def derangements(self, derangements): """ Eine Liste aller Identitäten des Charkaters. Die Identität an Indexposition 0 ist die echte Identität. """ #Debug.debug(derangements) if derangements and self.__derangements != derangements: self.__derangements = derangements ## Jetzt müssen in der richtigen Reihenfolge (hoch nach tief) die Signale gesandt werden. keys = self.__derangements.keys() #Debug.debug(keys, range(min(keys), max(keys)+1)[::-1]) for i in range(min(keys), max(keys)+1)[::-1]: if i in keys: self.derangementChanged.emit(i, self.__derangements[i]) def setDerangement(self, moralityValue, derangement): """ Legt die Geistesstörung für den zugehörigen Moralwert fest. """ #Debug.debug(moralityValue, type(moralityValue)) if moralityValue not in self.__derangements: if derangement: self.__derangements[moralityValue] = derangement #Debug.debug(derangement, moralityValue) self.derangementChanged.emit(moralityValue, derangement) elif self.__derangements[moralityValue] != derangement: # Wird als Geistesstörung ein leerer String übergeben, wird dieser Eintrag aus der Liste gelöscht. Dennoch wird das Signal einer Änderung mit dem leeren String gesandt. if derangement: self.__derangements[moralityValue] = derangement #Debug.debug(derangement, moralityValue) else: del self.__derangements[moralityValue] self.derangementChanged.emit(moralityValue, derangement) @property def picture(self): """ Charakterbild. """ return self.__picture @picture.setter def picture(self, image): if self.__picture != image: self.__picture = image self.pictureChanged.emit(image) @property def weapons(self): """ Die Liste aller Waffen des Charakters. """ return self.__weapons def addWeapon(self, weapon, category): """ Fügt der Waffenliste eine Waffe hinzu. """ if category not in self.__weapons: self.__weapons.setdefault(category, []) if weapon not in self.__weapons[category]: self.__weapons[category].append(weapon) self.weaponAdded.emit(weapon, category) def deleteWeapon(self, weapon, category): """ Entfernt besagte Waffe aus der Waffenliste. """ if category in self.__weapons: self.__weapons[category].remove(weapon) self.weaponRemoved.emit(weapon, category) @property def armor(self): """ Die Rüstung (Name) des Charakters """ return self.__armor def setArmor(self, name, dedicated=False): if self.__armor["name"] != name or self.__armor["dedicated"] != dedicated: self.__armor["name"] = name self.__armor["dedicated"] = dedicated self.armorChanged.emit(name, dedicated) @property def equipment(self): """ Gegenstände im Besitz des Charakters. """ return self.__equipment def addEquipment(self, item): #Debug.debug(item) if item not in self.__equipment: self.__equipment.append(item) self.equipmentAdded.emit(item) def deleteEquipment(self, item): if item in self.__equipment: self.__equipment.remove(item) self.equipmentRemoved.emit(item) @property def automobiles(self): """ Die Liste aller Fahrzeuge des Charakters. """ return self.__automobiles def addAutomobile(self, automobile, category): """ Fügt der Liste ein Fahrzeug hinzu. """ if category not in self.__automobiles: self.__automobiles.setdefault(category, []) if automobile not in self.__automobiles[category]: self.__automobiles[category].append(automobile) self.automobileAdded.emit(automobile, category) def deleteAutomobile(self, automobile, category): """ Entfernt besagtes Fahrzeug aus der Liste. """ if category in self.__automobiles: self.__automobiles[category].remove(automobile) self.automobileRemoved.emit(automobile, category) @property def extraordinaryItems(self): """ Die Liste aller magischen Gegenstände des Charakters. """ return self.__extraordinaryItems def addExtraordinaryItem(self, extraordinaryItem, typ): """ Fügt der Liste der magischen Gegenstände einen hinzu. """ if typ not in self.__extraordinaryItems: self.__extraordinaryItems.setdefault(typ, []) if extraordinaryItem not in self.__extraordinaryItems[typ]: self.__extraordinaryItems[typ].append(extraordinaryItem) self.extraordinaryItemAdded.emit(extraordinaryItem, typ) def deleteExtraordinaryItem(self, extraordinaryItem, typ): """ Entfernt besagten magischen Gegenstand aus der Liste. """ if typ in self.__extraordinaryItems: self.__extraordinaryItems[typ].remove(extraordinaryItem) self.extraordinaryItemRemoved.emit(extraordinaryItem, typ) def __getMagicalTool(self): """ Magisches Werkzeug. """ return self.__magicalTool def setMagicalTool(self, tool): if self.__magicalTool != tool: self.__magicalTool = tool self.magicalToolChanged.emit(tool) magicalTool = property(__getMagicalTool, setMagicalTool) def __getNimbus(self): """ Der Nimbus eines Magiers. """ return self.__nimbus def setNimbus(self, nimbus): if self.__nimbus != nimbus: self.__nimbus = nimbus self.nimbusChanged.emit(nimbus) nimbus = property(__getNimbus, setNimbus) def __getParadoxMarks(self): """ Die Paradoxzeichen eines Magiers. """ return self.__paradoxMarks def setParadoxMarks(self, paradoxMarks): if self.__paradoxMarks != paradoxMarks: self.__paradoxMarks = paradoxMarks self.paradoxMarksChanged.emit(paradoxMarks) paradoxMarks = property(__getParadoxMarks, setParadoxMarks) @property def vinculi(self): """ Die Vinculi eines Vampirs """ return self.__vinculi def __getCompanionName(self): return self.__companionName def setCompanionName(self, name): if self.__companionName != name: self.__companionName = name self.companionNameChanged.emit(name) companionName = property(__getCompanionName, setCompanionName) def __getCompanionPower(self): return self.__companionPower def setCompanionPower(self, power): if self.__companionPower != power: self.__companionPower = power self.companionPowerChanged.emit(power) companionPower = property(__getCompanionPower, setCompanionPower) def __getCompanionFinesse(self): return self.__companionFinesse def setCompanionFinesse(self, finesse): if self.__companionFinesse != finesse: self.__companionFinesse = finesse self.companionFinesseChanged.emit(finesse) companionFinesse = property(__getCompanionFinesse, setCompanionFinesse) def __getCompanionResistance(self): return self.__companionResistance def setCompanionResistance(self, resistance): if self.__companionResistance != resistance: self.__companionResistance = resistance self.companionResistanceChanged.emit(resistance) companionResistance = property(__getCompanionResistance, setCompanionResistance) def __getCompanionSize(self): return self.__companionSize def setCompanionSize(self, size): if self.__companionSize != size: self.__companionSize = size self.companionSizeChanged.emit(size) companionSize = property(__getCompanionSize, setCompanionSize) def __getCompanionSpeedFactor(self): return self.__companionSpeedFactor def setCompanionSpeedFactor(self, speedFactor): if self.__companionSpeedFactor != speedFactor: self.__companionSpeedFactor = speedFactor self.companionSpeedFactorChanged.emit(speedFactor) companionSpeedFactor = property(__getCompanionSpeedFactor, setCompanionSpeedFactor) def __getCompanionFuel(self): return self.__companionFuel def setCompanionFuel(self, fuel): if self.__companionFuel != fuel: self.__companionFuel = fuel self.companionFuelChanged.emit(fuel) companionFuel = property(__getCompanionFuel, setCompanionFuel) @property def companionInfluences(self): """ Die Einflüsse eines Vertrauten-Geistes. """ return self.__companionInfluences @property def companionNumina(self): return self.__companionNumina @companionNumina.setter def companionNumina(self, numina): if self.__companionNumina != numina: self.__companionNumina = numina self.companionNuminaChanged.emit(numina) def appendCompanionNumen(self, numen): self.__companionNumina.append(numen) def removeCompanionNumen(self, numen): self.__companionNumina.remove(numen) def __getCompanionBan(self): return self.__companionBan def setCompanionBan(self, ban): if self.__companionBan != ban: self.__companionBan = ban self.companionBanChanged.emit(ban) companionBan = property(__getCompanionBan, setCompanionBan) @property def traits(self): return self.__traits #def __setTraits(self, traits): #if self.__traits != traits: #self.__traits = traits #self.traitsChanged.emit(traits) @property def subPowers(self): return self.__subPowers def __calcAge(self): """ Zur Berechnung des Alters werden Geburtstag und Datum im Spiel herangezogen. """ age = Calc.years(self.dateBirth, self.dateGame) if self.__age != age: ageCtagoryChanged = False if Config.getAge(self.__age) != Config.getAge(age): ageCtagoryChanged = True self.__age = age self.ageChanged.emit(age) if ageCtagoryChanged: self.ageChanged[str].emit(Config.getAge(age)) def __calcAgeBecoming(self): """ Zur Berechnung des Alters zum Zeitpunkt der Veränderung (Erwachen, Kuß, erste Verwandlung etc.) werden Geburtsdatum und Datum der Veränderung genutzt. """ age = Calc.years(self.dateBirth, self.dateBecoming) if self.__ageBecoming != age: self.__ageBecoming = age self.ageBecomingChanged.emit(age) def __getVirtue(self): """ Tugend des Charakters """ return self.__virtue def setVirtue( self, virtue ): """ Verändert die Tugend. Bei einer Veränderung wird das Signal virtueChanged() ausgesandt. """ if ( self.__virtue != virtue ): self.__virtue = virtue self.virtueChanged.emit( virtue ) virtue = property(__getVirtue, setVirtue) def __getVice(self): """ Laster des Charakters """ return self.__vice def setVice( self, vice ): """ Verändert das Laster. Bei einer Veränderung wird das Signal viceChanged() ausgesandt. """ if ( self.__vice != vice ): self.__vice = vice self.viceChanged.emit( vice ) vice = property(__getVice, setVice) def __getBreed(self ): """ Brut (Seeming, Path, Clan, Auspice) des Charakters. """ return self.__breed def setBreed( self, breed ): """ Verändert die Brut. Bei einer Veränderung wird das Signal breedChanged() ausgesandt. """ if self.__breed != breed: self.__breed = breed self.breedChanged.emit(breed) breed = property(__getBreed, setBreed) def __getBonus(self ): """ Bonuseigenschaft """ return self.__bonus def setBonus( self, bonus ): """ Verändert die Bonuseigenschaft. Die Bonuseigenschaft wird folgendermaßen gespeichert. Der Eintrag für die Spezialisierung ist optional. { "type": Typ, "name": Name, "specialty": Gewählte Spezialisierung, } """ #Debug.debug(bonus) if ( self.__bonus != bonus ): #Debug.debug(bonus) self.__bonus = bonus self.bonusChanged.emit( bonus ) bonus = property(__getBonus, setBonus) def __changeBonusTrait(self, bonus): """ Ändert die Bonuseigenschaft. \todo Wenn die Erschaffungsphase vorüber ist, sollte die Bonuseigenschaft nichtmehr verändert werden können und die davon betroffene Eigenscahft wie eine normale Eigenschaft mit erhöhtem Wert, zusätzlicher Spezialisierung betrachtet werden. """ ## Alle bisherigen Bonuseigenschaften löschen, denn es kann immer nur eine solche geben. for typ in self.traits: for category in self.traits[typ]: for identifier in self.traits[typ][category]: if type(self.traits[typ][category][identifier]) == BonusTrait: self.traits[typ][category][identifier].clearBonus() if bonus: for category in self.traits[bonus["type"]]: if bonus["name"] in self.traits[bonus["type"]][category].keys(): if type(self.traits[bonus["type"]][category][bonus["name"]]) == BonusTrait: if bonus["type"] == "Attribute": self.traits[bonus["type"]][category][bonus["name"]].bonusValue = 1 #Debug.debug("Bonuseigenschaft {} verändert!".format(self.traits[bonus["type"]][category][bonus["name"]].name)) elif bonus["type"] == "Skill" and "specialty" in bonus: self.traits[bonus["type"]][category][bonus["name"]].bonusSpecialties = [ bonus["specialty"] ] #Debug.debug("Bonuseigenschaft {} verändert!".format(self.traits[bonus["type"]][category][bonus["name"]].name)) break def __getKith(self ): """ Kith der Wechselbälger """ return self.__kith def setKith( self, kith ): """ Verändert das Kith. """ if ( self.__kith != kith ): self.__kith = kith self.kithChanged.emit( kith ) kith = property(__getKith, setKith) def __getFaction(self): """ Fraktion (Court, Order, Covenant, Tribe) des Charakters. """ return self.__faction def setFaction( self, faction ): """ Verändert die Fraktion. Bei einer Veränderung wird das Signal factionChanged() ausgesandt. """ if ( self.__faction != faction ): self.__faction = faction self.factionChanged.emit( faction ) faction = property(__getFaction, setFaction) def __getOrganisation(self): """ Organisation (Entitlement, Legacy, Bloodline, Lodge) des Charakters. """ return self.__organisation def setOrganisation( self, organisation ): """ Verändert die Organisation. Bei einer Veränderung wird das Signal organisationChanged() ausgesandt. """ if ( self.__organisation != organisation ): self.__organisation = organisation self.organisationChanged.emit( organisation ) organisation = property(__getOrganisation, setOrganisation) def __getParty(self): """ Name der Freundesgruppe des Charakters. """ return self.__party def setParty( self, party ): if ( self.__party != party ): self.__party = party self.partyChanged.emit( party ) party = property(__getParty, setParty) def __getHeight(self): """ Größe des Charakters in m. """ return self.__height def setHeight( self, height ): if ( self.__height != height ): self.__height = height self.heightChanged.emit( height ) height = property(__getHeight, setHeight) def __getWeight(self): """ Gewicht des Charakters in kg. """ return self.__weight def setWeight( self, weight ): if ( self.__weight != weight ): self.__weight = weight self.weightChanged.emit( weight ) weight = property(__getWeight, setWeight) def __getEyes(self): """ Beschreibung der Augen des Charakters. """ return self.__eyes def setEyes( self, eyes ): if ( self.__eyes != eyes ): self.__eyes = eyes self.eyesChanged.emit( eyes ) eyes = property(__getEyes, setEyes) def __getHair(self): """ Beschreibung der Haare des Charakters. """ return self.__hair def setHair( self, hair ): if ( self.__hair != hair ): self.__hair = hair self.hairChanged.emit( hair ) hair = property(__getHair, setHair) def __getNationality(self): """ Die Nationalität des Charakters. """ return self.__nationality def setNationality( self, nationality ): if ( self.__nationality != nationality ): self.__nationality = nationality self.nationalityChanged.emit( nationality ) nationality = property(__getNationality, setNationality) @property def description(self): """ Name der Freundesgruppe des Charakters. """ return self.__description @description.setter def description( self, text ): if ( self.__description != text ): self.__description = text self.descriptionChanged.emit( text ) def __getPowerstat(self): """ Gibt den Wert des Super-Attributs aus. """ return self.__powerstat def setPowerstat( self, value ): """ Verändert den Wert des Super-Attributs. Bei einer Veränderung wird das Signal powerstatChanged() ausgesandt. """ if ( self.__powerstat != value ): self.__powerstat = value self.powerstatChanged.emit( value ) powerstat = property(__getPowerstat, setPowerstat) def __getMorality(self): """ Gibt den Wert der Moral aus. """ return self.__morality def setMorality( self, value ): """ Verändert den Wert der Moral. Bei einer Veränderung wird das Signal moralityChanged() ausgesandt. """ if ( self.__morality != value ): self.__morality = value #Debug.debug("Moral verändert auf {}".format(value)) self.moralityChanged.emit( value ) morality = property(__getMorality, setMorality) def resetCharacter(self): ## Der Charkater wird umorganisiert, ohne daß wir haufenweise Warnhinweise haben wollen. self.isLoading = True # Standardspezies ist der Mensch. self.species = Config.SPECIES_INITIAL # Zeitalter festlegen. self.era = Config.ERA_INITIAL ## Anfangsdatum setzen. self.dateGame = QDate.currentDate() self.dateBirth = QDate(self.dateGame.year() - Config.AGE_INITIAL, self.dateGame.month(), self.dateGame.day()) self.dateBecoming = QDate(self.dateGame.year() - Config.AGE_ADULT, self.dateGame.month(), self.dateGame.day()) # Löschen aller Identitäten. self.identity.reset() #Debug.debug(self.__storage.virtues[0]) #Debug.debug(self.__storage.virtues[0]["name"]) self.virtue = self.__storage.virtues[0]["name"] self.vice = self.__storage.vices[0]["name"] self.breed = "" self.bonus= "" self.kith = "" self.faction = "" self.height = 1.60 self.weight = 60 self.eyes = "" self.hair = "" self.nationality = "" # Nicht notwendig, da ja schon die Spezies gewechselt wird, was automatisch diese Felder zurücksetzt. #self.breed = self.__storage.breeds(Config.SPECIES_INITIAL)[0] self.__derangements = {} self.party = "" self.description = "" # Menschen haben eine Leere liste, also kann ich auch die Indizes nicht ändern. #// setBreed(storage.breedNames(species()).at(0)); #// setFaction(storage.breedNames(species()).at(0)); # Attribute und andere Eigenschaften auf Anfangswerte setzen. for item in self.__traits: val = 0 if item == "Attribute": val = 1 for subitem in self.__traits[item]: for subsubitem in self.__traits[item][subitem].values(): subsubitem.value = val subsubitem.customText = "" subsubitem.specialties = [] self.morality = Config.TRAIT_MORALITY_VALUE_DEFAULT # Übernatürliche Eigenschaft festlegen. self.powerstat = Config.TRAIT_POWERSTAT_VALUE_DEFAULT # Beim Löschen ist darauf zu achten, daß ich nicht aus der Liste löschen kann, über die ich iteriere. Sonst wird nicht alles gelöscht. for category in self.__weapons: ## Kopie erstellen weaponList = self.__weapons[category][:] for weapon in weaponList: self.deleteWeapon(category, weapon) self.setArmor(name="") ## Kopie erstellen eqipmentList = self.__equipment[:] for item in eqipmentList: self.deleteEquipment(item) for category in self.__automobiles: ## Kopie erstellen automobileList = self.__automobiles[category][:] for automobile in automobileList: self.deleteAutomobile(category, automobile) for typ in self.__extraordinaryItems: ## Kopie erstellen extraordinaryItemList = self.__extraordinaryItems[typ][:] for item in extraordinaryItemList: self.deleteExtraordinaryItem(typ, item) self.magicalTool = "" self.nimbus = "" self.paradoxMarks = "" for vinculum in self.__vinculi: vinculum.name = "" vinculum.value = 0 self.companionName = "" self.companionPower = 0 self.companionFinesse = 0 self.companionResistance = 0 self.companionSize = 0 self.companionSpeedFactor = 0 self.companionFuel = 0 for companionInfluence in self.__companionInfluences: companionInfluence.name = "" companionInfluence.value = 0 self.companionNumina = [] self.companionBan = "" self.picture = QPixmap() ## Fertig mit dem Laden der enuen Werte. self.isLoading = False def isModifed(self): return self.__modified def setModified( self, sw=True ): if ( self.__modified != sw ): self.__modified = sw # Unerwünschte Funktion. #def clearUnusableTraits(self, species): #""" #Beim Wechsel der Spezies werden zahlreiche Eigenschaften für den Charakter unnutzbar. Diese werden auf den Wert 0 gesetzt. #\todo Möglicherweise will ich das garnicht. Dann kan ich beim Zurücksetzen der Spezies wieder die zuvor gewählten Powers darstellen. Es muß natürlich darauf geachtet werden, daß beim Speichern nur eigenschaft der richtigen Spezies gespeichert werden und auf dem Charakterbogen auch nur die verwendbaren Werte auftauchen. #""" ### Es müssen nur bei ein paar Typen die Eigenschaft durchsucht werden. #typesToClear = ( "Merit", "Flaw", "Power", ) #for typ in typesToClear: #for item in self.__traits[typ]: #for subitem in self.__traits[typ][item].values(): #if subitem.species and subitem.species != species and subitem.value != 0: ##Debug.debug("Setze {} auf 0.".format(subitem.name)) #subitem.value = 0 def checkPrerequisites(self, trait): """ Diese Funktion überprüft, ob die Voraussetzungen der Eigenschaft "trait" erfüllt sind oder nicht. \todo Den SyntaxError sollte ich nicht verstecken! """ ConnectPrerequisites.checkPrerequisites(trait, self.__storage, self) def deselctTraitsWithWrongAge(self, age): """ \todo Man sollte nicht bei jedem Alterswechsel über alle Eigenschaften laufen, sondern zu Beginn des Programms alle Eigenschaften mit "Kid" bzw. "Adult" mit ageChanged verknüpfen. """ for typ in self.__traits: for category in self.__traits[typ]: for trait in self.__traits[typ][category].values(): if type(trait) == StandardTrait and trait.age and trait.age != Config.getAge(self.age) and trait.value > 0: trait.value = 0
def __init__(self, template, parent=None): """ \todo Eigentlich benötigt Subpower keinen eigenen Datentyp. Da die ganzen Zusatzinformationen ja nur im Template zu stehen haben und nicht auch für den Charakter bekannt sein müssen. Der Wert "level" ist aber interessant und gilt für andere Klassen nicht. """ super(StorageCharacter, self).__init__(parent) self.__storage = template self.isLoading = False self.__modified = False self.__dateBirth = QDate(1, 1, 1) self.__dateBecoming = QDate(1, 1, 1) self.__dateGame = QDate(1, 1, 1) self.__age = 0 self.__ageBecoming = 0 self.__species = "" self.__virtue = "" self.__vice = "" self.__breed = "" self.__bonus = {} self.__kith = "" self.__faction = "" self.__organisation = "" self.__party = "" self.__height = 0.0 self.__weight = 0.0 self.__eyes = "" self.__hair = "" self.__nationality = "" self.__description = "" self.__powerstat = 0 self.__morality = 0 self.__era = "" self.__picture = None self.__armor = { "name": "", "dedicated": False, } self.__equipment = [] self.__magicalTool = "" self.identity = Identity() self.__derangements = {} self.__nimbus = "" self.__paradoxMarks = "" self.__vinculi = [] for i in range(Config.VINCULI_COUNT_MAX): vinculum = AbstractTrait() self.__vinculi.append(vinculum) vinculum.traitChanged.connect(self.setModified) self.__companionName = "" self.__companionPower = 0 self.__companionFinesse = 0 self.__companionResistance = 0 self.__companionSize = 0 self.__companionSpeedFactor = 0 self.__companionFuel = 0 self.__companionInfluences = [] for i in range(Config.COMPANION_INFLUENCES_MAX): companionInfluence = AbstractTrait() self.__companionInfluences.append(companionInfluence) companionInfluence.traitChanged.connect(self.setModified) self.__companionNumina = [] self.__companionBan = "" self.dateBirthChanged.connect(self.__calcAge) self.dateGameChanged.connect(self.__calcAge) self.dateBirthChanged.connect(self.__calcAgeBecoming) self.dateBecomingChanged.connect(self.__calcAgeBecoming) self.weaponAdded.connect(self.weaponsChanged) self.weaponRemoved.connect(self.weaponsChanged) self.equipmentAdded.connect(self.automobilesChanged) self.equipmentRemoved.connect(self.equipmentChanged) self.automobileAdded.connect(self.automobilesChanged) self.automobileRemoved.connect(self.automobilesChanged) self.extraordinaryItemAdded.connect(self.extraordinaryItemsChanged) self.extraordinaryItemRemoved.connect(self.extraordinaryItemsChanged) # Die Eigenschaften in den Charakter laden. self.__traits = {} # Eigenschaften setzen. for typ in self.__storage.traits.keys(): self.__traits.setdefault(typ, {}) for item in template.traits[typ]: self.__traits[typ].setdefault(item, {}) for subitem in template.traits[typ][item].items(): #Debug.debug(subitem) val = 2 # Dies mache ich, damit beim initialen Charakter-Reset, auch alle Voraussetzungen überprüft werden. # Eigenschaften, die Zusaztext erhalten können (bspw. Language), werden mehrfach in das Dictionary eingefügt. Aber da ein Dictonary immer nur einen Eintrag desselben Namens haben kann, muß selbiger um ein numerisches Suffix erweitert werden. loop = 1 custom = False customText = None if typ != "Subpower" and subitem[1]["custom"]: loop = Config.MULTIPLE_TRAITS_MAX custom = True for i in range(loop): trait = None if typ == "Subpower": trait = SubPowerTrait(self, subitem[1]["name"], val) trait.level = subitem[1]["level"] trait.powers = subitem[1]["powers"] else: if typ == "Attribute" or typ == "Skill": trait = BonusTrait(self, subitem[1]["name"], val) else: trait = StandardTrait(self, subitem[1]["name"], val) trait.age = subitem[1]["age"] trait.era = subitem[1]["era"] trait.custom = custom trait.customText = customText trait.identifier = subitem[0] trait.species = subitem[1]["species"] trait.cheap = subitem[1]["cheap"] #if typ == "Subpower" and trait.species == "Werewolf": #Debug.debug(subitem[1]["name"], subitem[1]["only"]) trait.only = subitem[1]["only"] if "prerequisites" in subitem[1] and subitem[1]["prerequisites"]: trait.hasPrerequisites = True trait.prerequisitesText = subitem[1]["prerequisites"] # In der Eigenschaft steht der richtige Name aber im Dictionary der Name mit einem numerischen Suffix, damit die Eigenschaft häufiger auftauchen kann. dictKey = subitem[0] if custom: dictKey = "{}{}".format(subitem[0], i) self.__traits[typ][item].setdefault(dictKey, trait) # Wenn sich eine Eigenschaft ändert, gilt der Charakter als modifiziert. trait.traitChanged.connect(self.setModified) #if typ == "Subpower": #Debug.debug(self.__traits[typ][item]) self.bonusChanged.connect(self.__changeBonusTrait) # Sobald irgendein Aspekt des Charakters verändert wird, muß festgelegt werden, daß sich der Charkater seit dem letzten Speichern verändert hat. # Es ist Aufgabe der Speicher-Funktion, dafür zu sorgen, daß beim Speichern diese Inforamtion wieder zurückgesetzt wird. self.identity.identityChanged.connect(self.setModified) self.eraChanged.connect(self.setModified) self.dateBirthChanged.connect(self.setModified) self.dateBecomingChanged.connect(self.setModified) self.dateGameChanged.connect(self.setModified) # Unerwünschte Wirkung #self.speciesChanged.connect(self.clearUnusableTraits) self.speciesChanged.connect(self.setModified) self.virtueChanged.connect(self.setModified) self.viceChanged.connect(self.setModified) self.breedChanged.connect(self.setModified) self.kithChanged.connect(self.setModified) self.bonusChanged.connect(self.setModified) self.factionChanged.connect(self.setModified) self.partyChanged.connect(self.setModified) self.descriptionChanged.connect(self.setModified) self.powerstatChanged.connect(self.setModified) self.moralityChanged.connect(self.setModified) self.derangementChanged.connect(self.setModified) self.pictureChanged.connect(self.setModified) self.weaponsChanged.connect(self.setModified) self.armorChanged.connect(self.setModified) self.equipmentChanged.connect(self.setModified) self.automobilesChanged.connect(self.setModified) self.extraordinaryItemsChanged.connect(self.setModified) self.magicalToolChanged.connect(self.setModified) self.nimbusChanged.connect(self.setModified) self.paradoxMarksChanged.connect(self.setModified) self.companionPowerChanged.connect(self.setModified) self.companionFinesseChanged.connect(self.setModified) self.companionResistanceChanged.connect(self.setModified) self.companionSizeChanged.connect(self.setModified) self.companionSpeedFactorChanged.connect(self.setModified) self.companionFuelChanged.connect(self.setModified) self.companionNuminaChanged.connect(self.setModified) self.companionBanChanged.connect(self.setModified) self.ageChanged.connect(self.deselctTraitsWithWrongAge) self.speciesChanged.connect(self.__emitTraitVisibleReasonChanged) self.ageChanged.connect(self.__emitTraitVisibleReasonChanged) self.eraChanged.connect(self.__emitTraitVisibleReasonChanged) self.breedChanged.connect(self.__emitTraitVisibleReasonChanged) self.factionChanged.connect(self.__emitTraitVisibleReasonChanged)