def __init__(self, parent=None):
"""
Konstruktor
"""
self.translator_app = QTranslator()
self.translator_qt = QTranslator()
QApplication.installTranslator( self.translator_app )
QApplication.installTranslator( self.translator_qt )
QWidget.__init__(self, parent)
QCoreApplication.setOrganizationName("Caern")
QCoreApplication.setOrganizationDomain("www.caern.de")
QCoreApplication.setApplicationName("DiceRoller WoD")
QCoreApplication.setApplicationVersion(QString.number(PROGRAM_VERSION_MAJOR) +
"." +
QString.number(PROGRAM_VERSION_MINOR) +
"." +
QString.number(PROGRAM_VERSION_CHANGE)
)
QApplication.setWindowIcon(QIcon(":/icons/logo/WoD.png"))
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.createInfo()
#self.createLanguageMenu()
self.instantRoll = InstantRoll()
self.extendedRoll = ExtendedRoll()
# Dieser Zähler bestimmt, wie der rollende Würfel angezeigt wird.
self.timerDice = QTimer()
# Verzögert die tatsächliche Ausführung des Würfelwurfs.
self.timerRoll = QTimer()
self.populateUi()
self.createConnections()
self.initializing()
self.setWindowTitle(QCoreApplication.applicationName())
class Nexus(QMainWindow):
"""
Die Hauptklasse des Programms.
In dieser Klasse wird die GUI gesteuert und die Würfelwürfe aufgerufen.
"""
dicePoolChanged = pyqtSignal(int)
xAgainChanged = pyqtSignal(int)
cursed = pyqtSignal(bool)
def __init__(self, parent=None):
"""
Konstruktor
"""
self.translator_app = QTranslator()
self.translator_qt = QTranslator()
QApplication.installTranslator( self.translator_app )
QApplication.installTranslator( self.translator_qt )
QWidget.__init__(self, parent)
QCoreApplication.setOrganizationName("Caern")
QCoreApplication.setOrganizationDomain("www.caern.de")
QCoreApplication.setApplicationName("DiceRoller WoD")
QCoreApplication.setApplicationVersion(QString.number(PROGRAM_VERSION_MAJOR) +
"." +
QString.number(PROGRAM_VERSION_MINOR) +
"." +
QString.number(PROGRAM_VERSION_CHANGE)
)
QApplication.setWindowIcon(QIcon(":/icons/logo/WoD.png"))
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.createInfo()
#self.createLanguageMenu()
self.instantRoll = InstantRoll()
self.extendedRoll = ExtendedRoll()
# Dieser Zähler bestimmt, wie der rollende Würfel angezeigt wird.
self.timerDice = QTimer()
# Verzögert die tatsächliche Ausführung des Würfelwurfs.
self.timerRoll = QTimer()
self.populateUi()
self.createConnections()
self.initializing()
self.setWindowTitle(QCoreApplication.applicationName())
#self.retranslateUi()
## Die von der letzten Benutzung gespeicherte Größe und Position auf dem Bildschirm laden.
#self.readSettings()
#def closeEvent(self, event):
#"""
#Diese Funktion wird aufgerufen, wann immer das Programm geschlossen wird.
#Die Idee dahinter ist, vor dem Beenden, Größe und Position des Fensters zu speichern.
#"""
#self.writeSettings()
#event.accept()
def createInfo(self):
"""
Erzeugt Tooltips und Hilfe für die einzelnen Teile des Programms.
"""
self.ui.action_houserules.setStatusTip(self.ui.action_houserules.toolTip())
#def createLanguageMenu(self):
#"""
#Erzeugt das Menü zum Umschalten zwischen den möglichen Sprachen.
#"""
#self.menu_language = QMenu( self.tr("&Language") )
#self.actionGroup_language = QActionGroup(self)
#self.langPath = getPath() + "/" + PROGRAM_LANGUAGE_PATH
#self.dir_qm = QDir( self.langPath );
#self.fileNames = self.dir_qm.entryList( QStringList( "DiceRoller-WoD_*.qm" ));
## Englisch hat keine qm-Datei, also muß es von Hand hinzugefügt werden.
#self.action = QAction( "&1 English", self.actionGroup_language )
#self.action.setCheckable( True )
#self.action.setData( "en" )
#self.action.setChecked( True )
#self.menu_language.addAction( self.action )
#self.actionGroup_language.addAction( self.action )
#iter = 0
#for i in self.fileNames:
#self.trFilename = unicode(i)
#self.locale = unicode(i)
#self.locale = self.locale[(self.locale.find( "_" )+1):(self.locale.find( "." ))]
#self.translator = QTranslator()
#self.translator.load( self.trFilename, self.dir_qm.absolutePath() )
#self.language = self.translator.translate( "MainWindow", "English" )
#self.action = QAction( "&" + QString.number(iter + 2) + " " + self.language, self.actionGroup_language )
#self.action.setCheckable( True )
#self.action.setData( self.locale )
#self.menu_language.addAction ( self.action )
#self.actionGroup_language.addAction ( self.action )
#iter += 1
#self.actionGroup_language.triggered.connect(self.switchLanguage)
#self.ui.menuBar.insertMenu(self.ui.menuHelp.menuAction(), self.menu_language)
#def switchLanguage( self, action ):
#"""
#Schaltet zwischen den einzelnen Sprachen um.
#"""
#self.locale = action.data().toString();
#self.qmPath = getPath() + "/" + PROGRAM_LANGUAGE_PATH
##if self.translator_app.load( "DiceRoller-WoD_" + self.locale, self.qmPath ):
##qDebug("Hat DiceRoller-WoD_" + self.locale + " geladen.")
##if self.translator_qt.load( "qt_" + self.locale, QLibraryInfo.location ( QLibraryInfo.TranslationsPath ) ):
##qDebug("Hat qt_" + self.locale + " geladen.")
## Alle Texte neu setzen
#self.retranslateUi()
## Seltsamerweise ist retranslate in Ui_MainWindow leer. Ich weiß nicht, wieso das der Fall ist.
#self.ui.retranslateUi(self.ui)
#def retranslateUi(self):
#"""
#Diese Funktion übersetzt alle Texte, welche nicht in der .ui-Datei festgelegt sind, sondern im Quellcode (hier) geschrieben wurden.
#"""
#self.menu_language.setTitle( self.tr( "&Language" ) )
#self.reset()
def populateUi(self):
self.svgRenderer = QSvgRenderer(":/icons/W10.svg")
self.scene = QGraphicsScene()
self.view = QGraphicsView()
self.view.setFrameShape(QFrame.NoFrame)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.view.setStyleSheet("background-color: transparent;");
self.view.setScene(self.scene)
self.ui.horizontalLayout_dice.insertWidget(1, self.view)
def createConnections(self):
"""
Erstelle die Verbindungen zwischen den verschiedenen Klassen und Elementen des Programms.
"""
self.ui.action_about.triggered.connect(self.aboutApp)
self.ui.action_aboutQt.triggered.connect(QApplication.aboutQt)
self.ui.action_houserules.toggled.connect(self.setHouserules)
self.ui.pushButton_roll.clicked.connect(self.roll)
self.ui.spinBox_pool.valueChanged.connect(self.calcDicePool)
self.ui.spinBox_pool.valueChanged.connect(self.reset)
self.ui.spinBox_modifier.valueChanged.connect(self.calcDicePoolMod)
self.ui.spinBox_modifier.valueChanged.connect(self.reset)
self.ui.checkBox_rote.toggled.connect(self.instantRoll.setRote)
self.ui.checkBox_rote.toggled.connect(self.extendedRoll.setRote)
self.ui.checkBox_rote.toggled.connect(self.reset)
self.ui.comboBox_xAgain.activated.connect(self.setXAgainThreshold)
self.ui.comboBox_xAgain.activated.connect(self.reset)
self.ui.groupBox_extended.toggled.connect(self.changeText)
self.ui.radioButton_target.toggled.connect(self.changeText)
self.ui.radioButton_maxRolls.toggled.connect(self.changeText)
self.ui.groupBox_extended.toggled.connect(self.reset)
self.ui.radioButton_target.toggled.connect(self.setExtendedMode)
self.ui.spinBox_target.valueChanged.connect(self.extendedRoll.setTarget)
self.ui.spinBox_target.valueChanged.connect(self.reset)
self.ui.spinBox_maxRolls.valueChanged.connect(self.extendedRoll.setMaxRolls)
self.ui.spinBox_maxRolls.valueChanged.connect(self.reset)
self.ui.checkBox_rollsLimited.toggled.connect(self.extendedRoll.setLimited)
self.ui.checkBox_rollsLimited.toggled.connect(self.reset)
self.xAgainChanged.connect(self.instantRoll.setThreshold)
self.xAgainChanged.connect(self.extendedRoll.setThreshold)
self.cursed.connect(self.instantRoll.setCurse)
self.cursed.connect(self.extendedRoll.setCurse)
self.instantRoll.rolled.connect(self.setResultSuccesses)
self.extendedRoll.rolled.connect(self.setResultSuccesses)
self.extendedRoll.rollsNeeded.connect(self.setResultRolls)
self.instantRoll.rollFinished.connect(self.setResult)
self.extendedRoll.rollFinished.connect(self.setResult)
self.dicePoolChanged.connect(self.changeDiceDisplay)
self.timerDice.timeout.connect(self.displayDice)
self.timerRoll.timeout.connect(self._executeRoll)
def initializing(self):
"""
Initialisiert das Programm mit den Startwerten.
"""
self.ui.action_quit.setIcon(QIcon(":/icons/actions/exit.png"))
self.ui.action_about.setIcon(QIcon(":/icons/logo/WoD.png"))
self.ui.pushButton_quit.setIcon(self.ui.action_quit.icon())
self.ui.pushButton_roll.setIcon(QIcon(":icons/W10_0.svg"))
self.ui.action_quit.setMenuRole(QAction.QuitRole)
self.ui.action_about.setText(self.tr("About %1...").arg(QApplication.applicationName()))
self.ui.action_about.setMenuRole(QAction.AboutRole)
self.ui.spinBox_pool.setValue(2)
self.ui.checkBox_rote.setChecked(False)
self.ui.comboBox_xAgain.setCurrentIndex(0)
self.ui.spinBox_target.setValue(1)
self.changeText()
self.ui.radioButton_target.setChecked(True)
self.ui.groupBox_extended.setChecked(False)
self.ui.checkBox_rollsLimited.setChecked(True)
self.dice = []
for i in xrange(10):
self.W10_x = QGraphicsSvgItem()
self.W10_x.setSharedRenderer(self.svgRenderer)
self.W10_x.setElementId("layer" + str(i))
#self.W10_x.setVisible(False)
# Ich lege diese Liste an, da ich auf die Liste in self.scene irgendwie nicht zugreifen kann.
self.dice.append(self.W10_x)
#self.scene.addItem(self.W10_x)
def displayDice(self, value=None):
"""
@todo Der Würfel kann mehrmals in Folge das selbe Ergebnis anzeigen, was dazu führt, daß der Bildablauf zu stocken scheint.
"""
if (value == None):
dieValue = Random.random(10)-1
else:
dieValue = value
for item in self.scene.items():
self.scene.removeItem(item)
self.scene.addItem(self.dice[dieValue])
self.view.setSceneRect(self.scene.itemsBoundingRect())
self.view.fitInView(self.dice[dieValue])
def changeDiceDisplay(self, number):
"""
Diese Funktion bestimmt, wieviele Würfel angezeigt werden.
"""
pass
#if (self.ui.horizontalLayout_dice.count > 2):
#pass
#randomValue = Random.random(10)-1
#for die in xrange(number):
#self.__W10_scene = QGraphicsScene()
#self.__W10_scene.addItem(self.dice[randomValue])
#self.__W10_view = QGraphicsView()
#self.__W10_view.setScene(self.__W10_scene)
#self.__W10_view.setSceneRect(self.scene.itemsBoundingRect())
#self.__W10_view.fitInView(self.dice[randomValue])
#self.ui.horizontalLayout_dice.insertWidget(1, self.__W10_view)
def aboutApp(self):
"""
Zeigt die Info-Nachricht an.
"""
self.appText = self.tr("""
<h1>%1</h1>
<h2>Version: %2</h2>
<p>Copyright (C) 2011 by Victor von Rhein<br>
EMail: [email protected]</p>
""").arg(QCoreApplication.applicationName()).arg(QCoreApplication.applicationVersion())
self.gnuText = self.tr("""
<h2>GNU General Public License</h2>
<p>This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</p>
<p>This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.</p>
<p>You should have received a copy of the GNU General Public License along with this program. If not, see <a>http://www.gnu.org/licenses/</a>.</p>
""")
self.wodText = self.tr("""
<h2>%1</h2>
<p>%1, %2, the %3 and all referring terms and symbols are copyrighted by %4</p>
""").arg("World of Darkness").arg("White Wolf").arg("White Wolf-Logo").arg("White Wolf Inc.")
self.aboutText = self.appText + self.gnuText + self.wodText
QMessageBox.about(self, "About " + QCoreApplication.applicationName(), self.aboutText )
def roll(self):
"""
Der Wurf wird durchgeführt. Der tatsächliche Wurf wird aber von den Timern angestoßen.
"""
# Es wird ein rollender Würfel angezeigt.
self.timerDice.start(DICEROLL_TIMER_INTERVAL)
self.timerRoll.start(DICEROLL_TIMER_DELAY)
def _executeRoll(self):
"""
Entscheidet vor dem eigentlichen Würfelwurf, ob ein normaler oder ein erweiterter Wurf notwendig ist und führt diesen aus.
"""
if self.ui.groupBox_extended.isChecked():
#qDebug("Checked")
self.extendedRoll.roll()
else:
#qDebug("Not Checked")
self.instantRoll.roll()
# Die Anzeige des rollenden Würfels wird angehalten
self.timerDice.stop()
self.timerRoll.stop()
def calcDicePool(self, value):
"""
Berechnet die Größe des zur Verfügung stehenden Würfelpools, welcher von den Würfeln und den Modifikatoren abhängt.
"""
self.instantRoll.poolSize = value + self.ui.spinBox_modifier.value()
self.extendedRoll.poolSize = self.instantRoll.poolSize
self.extendedRoll.limit = value
self.dicePoolChanged.emit(self.instantRoll.poolSize)
def calcDicePoolMod(self, value):
"""
Berechnet wie schon calcDicePool() die Größe des Würfelvorrats, allerdings werden dieser Funktion andere Argumente übergeben.
"""
self.instantRoll.poolSize = value + self.ui.spinBox_pool.value()
self.extendedRoll.poolSize = value + self.ui.spinBox_pool.value()
def setHouserules(self, value):
#qDebug("Test" + str(value))
self.extendedRoll.isHouserules = value
def setXAgainThreshold(self, value):
"""
Legt fest, bei welchem Ergebnis weitergewürfelt werden kann und wann dies überhaupt nicht der Fall sein sollte oder gar Erfolge abgezogen werden können.
"""
self.__threshold = 0
if (value < 3):
self.__threshold = 10 - value # Index 0 entspricht 10 again, 1 entspricht 9 again etc.
else:
self.__threshold = 11 # Index 3 entspricht "no reroll"
self.xAgainChanged.emit(self.__threshold)
if (value > 3):
self.cursed.emit(True) # Kein reroll und 1er werden Abgezogen.
else:
self.cursed.emit(False) # 1er werden nicht abgezogen.
def setExtendedMode(self, sw):
"""
Legt den Modus fest, mit welchem der erweiterte Wurf durchgeführt wird. Entweder wird auf ein Ergebnishingewürfelt, oder nach einer bestimmten Anzahl würde die Anzahl der Erfolge gezählt.
"""
if (sw):
self.extendedRoll.isResultInRolls = False
else:
self.extendedRoll.isResultInRolls = True
def setResult(self, value):
"""
Schreibt das Ergebnis des Wurfs in die GUI. Dabei wird auch je nach Erfolgsqualität bei dem dargestellten Würfel eine andere Augenzahl gezeigt.
"""
self.ui.statusBar.showMessage(self.tr("Result of diceroll is displayed."))
if (value == DieResult.dramaticFailure):
self.ui.label_resultText.setText(self.tr("Dramatic Failure"));
self.ui.label_result.setPixmap(QPixmap(":/icons/actions/cnrdelete-all1.png"));
self.displayDice(1)
elif (value == DieResult.failure):
self.ui.label_resultText.setText(self.tr("Failure"));
self.ui.label_result.setPixmap(QPixmap(":/icons/actions/fileclose.png"));
self.displayDice(Random.random(2, 7))
elif (value == DieResult.success):
self.ui.label_resultText.setText(self.tr("Success"));
self.ui.label_result.setPixmap(QPixmap(":/icons/actions/ok.png"));
self.displayDice(Random.random(8, 9))
else:
self.ui.label_resultText.setText(self.tr("Exceptional Success"));
self.ui.label_result.setPixmap(QPixmap(":/icons/actions/bookmark.png"));
self.displayDice(0)
def setResultRolls(self, value):
"""
Zeigt in der GUI an, wieviele Würfe nötig waren.
"""
if (self.ui.groupBox_extended.isChecked() and self.ui.radioButton_target.isChecked()):
self.ui.lcdNumber_successes.display(value)
def setResultSuccesses(self, value):
"""
Zeigt in der GUI an, wieviele Erfolge erzielt wurden.
"""
if (not self.ui.groupBox_extended.isChecked() or not self.ui.radioButton_target.isChecked()):
self.ui.lcdNumber_successes.display(value)
def changeText(self):
"""
Verändert den Text in der Statuszeile.
"""
if (self.ui.groupBox_extended.isChecked() and self.ui.radioButton_target.isChecked()):
self.ui.label_successes.setText(self.tr("Number of rolls needed:"))
else:
self.ui.label_successes.setText(self.tr("Number of successes:"))
def reset(self):
"""
Setzt das Programm auf einen definierten Startwert zurück.
"""
self.ui.label_result.setPixmap(QPixmap(":/icons/actions/fileclose.png"))
self.ui.label_resultText.setText(self.tr("No result yet!"))
self.ui.lcdNumber_successes.display(0)
self.ui.statusBar.showMessage(self.tr("Press the Button to roll the dice!"))
