def setBtn(self):
setBtn_ = QPushButton(self)
setBtn_.resize(60, 15)
setBtn_.setText("设置")
setBtn_.setStyleSheet("background-color: pink")
setBtn_.setObjectName("settingBtn")
return setBtn_
def initUI(self):
self.resize(400, 180)
self.setWindowTitle("Ticket Analysis")
self.setWindowIcon(QIcon('Keyword_Analysis'))
CsvUploadBtn = QPushButton("CSV Upload", self)
CsvUploadBtn.resize(CsvUploadBtn.sizeHint())
CsvUploadBtn.clicked.connect(self.Browse)
CsvUploadBtn.move(10, 10)
self.FilePathLbl = QLabel(self)
self.FilePathLbl.move(100, 15)
AnalyseBtn = QPushButton("Analyse", self)
AnalyseBtn.move(10, 40)
AnalyseBtn.clicked.connect(self.Analyse)
self.ProgressBar = QProgressBar(self)
self.ProgressBar.move(100, 41)
self.ProgressBar.hide()
self.ProgressBar.setProperty("value", 1)
self.ProgressBar.setMinimumWidth(300)
ConfirmationLbl = QLabel("Ticket analysis done", self)
ConfirmationLbl.move(10, 110)
ConfirmationLbl2 = QLabel("Please check the folder in the directory",
self)
ConfirmationLbl2.move(10, 130)
OpenDirectory = QPushButton("Open Directory", self)
OpenDirectory.move(285, 125)
OpenDirectory.clicked.connect(self.OpenDir)
self.show()
def npkBtn(self):
npkBtn_ = QPushButton(self)
npkBtn_.resize(60, 25)
npkBtn_.move(0, self.height() - self.btnHeight * 1)
npkBtn_.setObjectName("_npkFuncBtn_")
npkBtn_.setText("功能")
npkBtn_.setEnabled(False)
return npkBtn_
def initUi(self):
self.setGeometry(600, 300, 400, 200)
self.setWindowTitle('Absolute Positioning')
#QPushButton
btn = QPushButton('Button', self)
btn.resize(btn.sizeHint())
btn.move(150, 100)
def addNewFrame(self, frame):
button = QPushButton("", self)
button.resize(FrameList.BUTTON_WIDTH, FrameList.BUTTON_HEIGHT)
button.clicked.connect(self.onMousePressed)
button.show()
self.buttons[button] = frame
if len(self.buttons) > FrameList.MAX_LENGTH:
self.start_index = len(self.buttons) - FrameList.MAX_LENGTH
self.rearrangeButtons()
def checkBox(self):
#
confirmBtn = QPushButton("确认", self)
confirmBtn.resize(self.width() // 2, 25)
confirmBtn.move(0, self.height() - 25)
confirmBtn.clicked.connect(self.hide)
#
cancelBtn = QPushButton("取消", self)
cancelBtn.resize(self.width() // 2, 25)
cancelBtn.move(self.width() // 2, self.height() - 25)
cancelBtn.clicked.connect(self.close)
class Interface(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(150, 150, 529, 498)
self.setWindowTitle('Рисование КРУГА')
self.pushButton = QPushButton("Нарисовать круг", self)
self.pushButton.resize(511, 31)
self.pushButton.move(10, 20)
def newNpkDictBtn(self):
newNpkBtn_ = QPushButton(self)
newNpkBtn_.resize(60, 25)
newNpkBtn_.move(0, self.height() - self.btnHeight * 2)
newNpkBtn_.setText("新建")
def newBtnFunc():
result = newDictBtnFunc(self)
newNpkBtn_.clicked.connect(newBtnFunc)
return newNpkBtn_
def saveDirSelectBtn(self):
btn = QPushButton("保存文件夹", self)
btn.setObjectName("saveDirSelectBtn")
btn.resize(self.width() / 2, self.height_)
btn.move(0, self.height_ * 2)
# btn.setStyleSheet("background-color: pink")
def btnFunc():
saveDirFunc(self)
btn.clicked.connect(btnFunc)
def testPortBtn(self):
portBtn = QPushButton("默认端口测试", self)
portBtn.setObjectName("testPortBtn")
portBtn.resize((self.width() - 30) / 2, self.height_)
portBtn.move(0, self.height_ * 3)
# portBtn.setEnabled(False)
def portBtnFunc():
testPortFunc(self)
portBtn.clicked.connect(portBtnFunc)
return portBtn
def readNpkDictBtn(self):
readNpkBtn_ = QPushButton(self)
readNpkBtn_.resize(60, 25)
readNpkBtn_.move(0, self.height() - self.btnHeight * 3)
readNpkBtn_.setText("读取")
def readDict():
result = readDictFile(self)
if result:
self.mainWin.findChild(QPushButton,
"_npkFuncBtn_").setEnabled(True)
readNpkBtn_.clicked.connect(readDict)
return readNpkBtn_
def img2DirBtn(self):
btn = QPushButton("ImagePacks2文件夹", self)
btn.setObjectName("saveDirSelectBtn")
btn.resize(self.width() / 2, self.height_)
btn.move(self.width() / 2, self.height_ * 2)
# btn.setStyleSheet("background-color: pink")
def btnFunc():
if img2DirFunc(self) is False:
QMessageBox.warning(self, "img2文件夹选择错误", "文件夹下无NPK文件，请重新选择",
QMessageBox.Yes, QMessageBox.Yes)
btn.clicked.connect(btnFunc)
def copyFrame(self):
if not self.buttons.active == None:
button = QPushButton("", self)
button.resize(FrameList.BUTTON_WIDTH, FrameList.BUTTON_HEIGHT)
button.clicked.connect(self.onMousePressed)
button.show()
index = self.buttons.index(self.buttons.active)
copy_frame = getWorld().getFrame()
copy_frame.time = self.buttons[self.buttons.active].time
self.buttons.insertAt(index+1, button, copy_frame)
if len(self.buttons) > FrameList.MAX_LENGTH:
self.start_index = self.start_index + 1
self.rearrangeButtons()
def iniUi(self):
self.roi = QLabel(self)
self.roi.resize(400, 400)
self.roi.move(25, 25)
startButton = QPushButton('Correct Roi', self)
startButton.resize(100, 50)
startButton.move(450, 25)
#self.setPlayersNum.activated[str].connect(self.Activation)
cancelButton = QPushButton('Done', self)
cancelButton.resize(100, 50)
cancelButton.move(450, 100)
self.setGeometry(300, 300, 550, 500)
self.setWindowTitle('Roi Correction')
self.show()
def initUi(self):
self.setGeometry(50, 50, 1024, 600)
self.setObjectName('MainWindow')
self.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
exitButton = QPushButton('Exit', self)
exitButton.setObjectName("ExitButton")
exitButton.resize(EXIT_BUTTON_WIDTH, EXIT_BUTTON_HEIGHT)
exitButton.move(EXIT_BUTTON_X, EXIT_BUTTON_Y)
exitButton.clicked.connect(QCoreApplication.instance().quit)
self.createMainControls()
self.createStatusBar()
self.createMiscControls()
self.show()
def positional_widget_layout(self):
label_1 = QLabel('Our first label', self)
print(self.menuBar().size()) # default size: PyQt5.QtCore.QSize(100, 30)
mbar_height = self.menuBar().height()
print(mbar_height)
label_1.move(10, mbar_height) # position label below menubar
label_2 = QLabel('Another label', self) # create another label
label_2.move(10, mbar_height * 2) # align and position below label_1
button_1 = QPushButton('click 1', self)
button_2 = QPushButton('click 2', self)
button_1.move(label_1.width(), label_1.height())
button_2.move(label_1.width(), label_1.height() * 2)
button_1.resize(100, 20) # no longer aligned
def onStickmanListener(self, name, operation):
if operation == World.ADD_EVENT:
button = QPushButton(name, self)
button.resize(StickmanList.BUTTON_WIDTH, StickmanList.BUTTON_HEIGHT)
button.clicked.connect(self.onMousePressed)
button.show()
self.buttons.insert(0, button)
self.start_index = 0
self.rearrangeButtons()
elif operation == World.REMOVE_EVENT:
for button in self.buttons:
if button.text() == name:
self.buttons.remove(button)
button.setParent(None)
if self.start_index > 0:
self.start_index = self.start_index - 1
self.rearrangeButtons()
elif operation == World.ACTIVE_EVENT:
self.rearrangeButtons()
def createMainControls(self):
radioButton = QPushButton('FM Radio', self)
radioButton.resize(MAIN_CONTROLS_WIDTH, MAIN_CONTROLS_HEIGHT)
radioButton.move(MAIN_CONTROLS_X_START, MAIN_CONTROLS_Y)
radioButton.clicked.connect(lambda: MainController.getInstance().
changeState(MainController.STATE_FM))
auxButton = QPushButton('AUX', self)
auxButton.resize(MAIN_CONTROLS_WIDTH, MAIN_CONTROLS_HEIGHT)
auxButton.move(
MAIN_CONTROLS_X_START + MAIN_CONTROLS_WIDTH +
MAIN_CONTROLS_DISTANCE, MAIN_CONTROLS_Y)
auxButton.clicked.connect(lambda: MainController.getInstance().
changeState(MainController.STATE_AUX))
mediaButton = QPushButton('Media', self)
mediaButton.resize(MAIN_CONTROLS_WIDTH, MAIN_CONTROLS_HEIGHT)
mediaButton.move(
MAIN_CONTROLS_X_START + 2 *
(MAIN_CONTROLS_WIDTH + MAIN_CONTROLS_DISTANCE), MAIN_CONTROLS_Y)
mediaButton.clicked.connect(lambda: MainController.getInstance().
changeState(MainController.STATE_MEDIA))
def initUI(self):
self.resize(454, 34)
self.setFrameStyle(QFrame.StyledPanel)
self.setLineWidth(1)
button_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
"""
""" all the control button switches are created from here """
world_tools_button = QPushButton('World Tools', self)
world_tools_button.setCheckable(True)
world_tools_button.resize(150, 30)
world_tools_button.move(2, 2)
world_tools_button.setStyleSheet(button_stylesheet)
world_tools_button.clicked.connect(self.pressControlPanelButton)
stickman_tools_button = QPushButton('Stickman Tools', self)
stickman_tools_button.setCheckable(True)
stickman_tools_button.resize(150, 30)
stickman_tools_button.move(152, 2)
stickman_tools_button.setStyleSheet(button_stylesheet)
stickman_tools_button.clicked.connect(self.pressControlPanelButton)
animation_tools_button = QPushButton('Animation Tools', self)
animation_tools_button.setCheckable(True)
animation_tools_button.resize(150, 30)
animation_tools_button.move(302, 2)
animation_tools_button.setStyleSheet(button_stylesheet)
animation_tools_button.clicked.connect(self.pressControlPanelButton)
world_tools_button.click()
class EditMap(QWidget): # класс для создания карты
def __init__(self):
self._sp_map = []
self._elem_map = []
self._activ_pic = 0
self._mouse_x = 0
self._mouse_y = 0
self._flag_1 = False
self._flag_2 = True
self._col = 14
self._row = 14
super().__init__()
self.initUI()
def initUI(self):
self.setWindowFlags(Qt.Window | Qt.WindowTitleHint
| Qt.CustomizeWindowHint) #
self.setMouseTracking(True) # отслеживаем положение мыши
self.resize(200,
100) # задаем размер окна с параметрами размеров карты
self.center() # отцентровываем окно относительно экрана
self.setWindowTitle('Редактор карты')
self.input_col = QLineEdit(str(self._col),
self) # создаем строку для ввода x
self.input_col.resize(50, 25) # задаем размер строки для ввода x
self.input_col.move(
30, 0
) # задаем положение строки для ввода x в окне с параметрами размеров карты
self.input_row = QLineEdit(str(self._row),
self) # создаем строку для ввода y
self.input_row.resize(50, 25) # задаем размер строки для ввода y
self.input_row.move(
120, 0
) # задаем положение строки для ввода y в окне с параметрами размеров карты
self.button_new_map = QPushButton(
"СОЗДАТЬ КАРТУ", self) # создаем кнопку "СОЗДАТЬ КАРТУ"
self.button_new_map.resize(140,
50) # задаем размер кнопки "СОЗДАТЬ КАРТУ"
self.button_new_map.move(
30, 50
) # задаем положение кнопки "СОЗДАТЬ КАРТУ" в окне с параметрами размеров карты
self.button_new_map.clicked.connect(
self.new_map) # ждем событие от кнопки "СОЗДАТЬ КАРТУ"
self.button_create = QPushButton("СОЗДАТЬ",
self) # создаем кнопку "СОЗДАТЬ"
self.button_create.resize(70, 30) # задаем размер кнопки "СОЗДАТЬ"
self.button_create.setVisible(False) # прячем кнопку "СОЗДАТЬ"
self.button_create.clicked.connect(
self.create_map) # ждем событие от кнопки "СОЗДАТЬ"
self.button_open = QPushButton("ОТКРЫТЬ",
self) # создаем кнопку "ОТКРЫТЬ"
self.button_open.resize(70, 30) # задаем размер кнопки "ОТКРЫТЬ"
self.button_open.setVisible(False) # прячем кнопку "ОТКРЫТЬ"
self.button_open.clicked.connect(
self.open_map) # ждем событие от кнопки "ОТКРЫТЬ"
self.button_save = QPushButton('СОХРАНИТЬ',
self) # создаем кнопку "СОХРАНИТЬ"
self.button_save.resize(70, 30) # задаем размер кнопки "СОХРАНИТЬ"
self.button_save.setVisible(False) # прячем кнопку "СОХРАНИТЬ"
self.button_save.clicked.connect(
self.save_map) # ждем событие от кнопки "СОХРАНИТЬ"
self.button_back = QPushButton("НАЗАД", self) # создаем кнопку "НАЗАД"
self.button_back.resize(70, 30) # задаем размер кнопки "НАЗАД"
self.button_back.setVisible(False) # прячем кнопку "НАЗАД"
self.button_back.clicked.connect(
self.close) # ждем событие от кнопки "НАЗАД"
self.timer_edit_map = QTimer()
self.timer_edit_map.timeout.connect(self.updateValues)
self.timer_edit_map.start(200)
def new_map(self): # метод класса Edit_Map, новая карта
if (not self.input_col.text().isdigit() or not self.input_row.text().isdigit()) or \
(int(self.input_col.text()) < 14 or int(self.input_row.text()) < 14):
# проверяем значения x, y. Если не числа, то выводим окно ошибки
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Error") # текст окна msg
msg.setWindowTitle("Error") # название окна msg
msg.exec_()
return
self._col = int(self.input_col.text()) # запоминаем новое значение x
self._row = int(self.input_row.text()) # запоминаем новое значение y
self._sp_map = [[0 for i in range(self._col)] for j in range(self._row)
] # создаем список 0 по размерам x, y
self.input_col.setVisible(False) # прячем строку для ввода x
self.input_row.setVisible(False) # прячем строку для ввода y
self.button_new_map.setVisible(False) # прячем кнопку "СОЗДАТЬ КАРТУ"
edit_map.move_button(
) # Расширяем окно и меняем положение кнопок "ОТКРЫТЬ", "НАЗАД", "СОЗДАТЬ", "СОХРАНИТЬ"
self.button_back.setVisible(True) # показываем кнопку "НАЗАД"
self.button_save.setVisible(True) # показываем кнопку "СОХРАНИТЬ"
self.button_open.setVisible(True) # показываем кнопку "ОТКРЫТЬ"
self.button_create.setVisible(True) # показываем кнопку "СОЗДАТЬ"
self.center() # отцентровываем окно относительно экрана
for i in range(
PIC
): # записываем в elem_map изображения из которых будет состоять карта
self._elem_map.append(QPixmap())
self._elem_map[i].load(resource_path("PIC/" + str(i) + "_0.png"))
self._flag_1 = True
def center(self): # функция отцентровывает окно относительно окна
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def paintEvent(self, event):
if self._flag_1:
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor(255, 237,
0)) # задаем желтый цвет для рамки выбора
qp.drawRect(self._col * 40 + 15, self._activ_pic * 50, 50,
50) # задаем положение и размер рамки выбора
for i in range(self._col):
for j in range(self._row):
qp.setBrush(QColor(50, 50, 50))
qp.drawRect(i * 40, j * 40, 40, 40)
qp.drawPixmap(i * 40, j * 40, self._elem_map[
self._sp_map[j][i]]) # рисуем картинками из elem_map
for i in range(PIC):
qp.drawPixmap(self._col * 40 + 20, i * 50 + 5,
self._elem_map[i])
if self._mouse_x < self._col * 40 and self._mouse_y < self._row * 40:
qp.drawPixmap(self._mouse_x - 30, self._mouse_y - 30,
self._elem_map[self._activ_pic])
qp.end()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
if self._mouse_x < self._col * 40 and self._mouse_y < self._row * 40:
self._sp_map[self._mouse_y // 40][self._mouse_x //
40] = self._activ_pic
for i in range(PIC):
if self._col * 40 + 20 < self._mouse_x < self._col * 40 + 80 and \
i * 50 + 5 < self._mouse_y < i * 50 + 65:
self._activ_pic = i
break
def mouseMoveEvent(self, event):
self._mouse_x = event.x()
self._mouse_y = event.y()
def create_map(self):
self.button_create.setVisible(False)
self.button_open.setVisible(False)
self.button_save.setVisible(False)
self.button_back.setVisible(False)
self._flag_1 = False
self.input_col.setVisible(True)
self.input_row.setVisible(True)
self.button_new_map.setVisible(True)
self.resize(200, 100)
self.center()
def save_map(self):
stroka = ''
for j in range(self._row):
for i in range(self._col):
stroka += str(self._sp_map[j][i])
stroka += '\n'
file_save_map = QFileDialog.getSaveFileName(self, filter='*.map')[0]
if file_save_map != '':
f = open(file_save_map, 'w', encoding="utf8")
with f:
f.write(stroka[:-1])
self._flag_2 = False
f.close()
def open_map(self):
file_save_map = QFileDialog.getOpenFileName(self, filter='*.map')[0]
f = open(file_save_map, encoding="utf8")
with f:
old_map = f.readlines()
f.close()
self._row = len(old_map)
self._col = len(old_map[0]) - 1
self._sp_map = []
for j in range(self._row):
self._sp_map.append([])
for i in range(self._col):
self._sp_map[j].append(int(old_map[j][i]))
edit_map.move_button()
self.center()
def close(self):
if self._flag_2:
result = QMessageBox.question(self, "ПРЕДУПРЕЖДЕНИЕ!",
"Сохранить карту?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if result == QMessageBox.Yes:
edit_map.save_map()
self.setVisible(False)
game.setVisible(True)
def updateValues(self):
self.update()
def move_button(self):
self.resize(self._col * 40 + 100, self._row * 40)
# расширяем окно по параметрам x, y, добавляем 100 по х для elem_map
self.button_back.move(self._col * 40 + 15, self._row * 40 -
30) # задаем положение кнопки "НАЗАД"
self.button_save.move(self._col * 40 + 15, self._row * 40 -
60) # задаем положение кнопки "СОХРАНИТЬ"
self.button_open.move(self._col * 40 + 15, self._row * 40 -
90) # задаем положение кнопки "ОТКРЫТЬ"
self.button_create.move(self._col * 40 + 15, self._row * 40 -
120) # задаем положение кнопки "СОЗДАТЬ"
class InputLine(QWidget):
HEIGHT = 30
LABEL_WIDTH = 170
INPUT_TEXT_WIDTH = 200
BUTTON_WIDTH = 100
BUTTON_BLOCK_X = 380
ELEMENT_GAP = 5
ERROR_WIDTH = 250
ERROR_X = 595
def __init__(self, parent):
super().__init__(parent)
self.initUI()
def initUI(self):
component_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
.QPushButton:pressed {
background-color:#CCCCCC;
}
.QLabel {
padding-top: 7px;
font-weight: bold;
font-size: 14px;
}
.QLineEdit {
font-weight: bold;
font-size: 14px;
}
.QLabel#error {
color: red;
font-size: 12px;
font-style: italic;
padding-top: 0px;
padding-left: 6px;
}
"""
self.label = QLabel("", self)
self.label.setStyleSheet(component_stylesheet)
self.label.setAlignment(Qt.AlignRight)
self.label.resize(InputLine.LABEL_WIDTH, InputLine.HEIGHT)
self.label.move(0, 0)
self.text = QLineEdit(self)
self.text.setStyleSheet(component_stylesheet)
self.text.resize(InputLine.INPUT_TEXT_WIDTH, InputLine.HEIGHT)
self.text.move(InputLine.LABEL_WIDTH + InputLine.ELEMENT_GAP, 0)
self.ok = QPushButton("OK", self)
self.ok.setStyleSheet(component_stylesheet)
self.ok.resize(InputLine.BUTTON_WIDTH, InputLine.HEIGHT)
self.ok.move(InputLine.BUTTON_BLOCK_X, 0)
self.cancel = QPushButton("Cancel", self)
self.cancel.setStyleSheet(component_stylesheet)
self.cancel.resize(InputLine.BUTTON_WIDTH, InputLine.HEIGHT)
self.cancel.move(InputLine.BUTTON_BLOCK_X + InputLine.BUTTON_WIDTH + InputLine.ELEMENT_GAP, 0)
self.error = QLabel("", self)
self.error.setObjectName("error")
self.error.setStyleSheet(component_stylesheet)
self.error.resize(InputLine.ERROR_WIDTH, InputLine.HEIGHT)
self.error.move(InputLine.ERROR_X, 0)
""" listeners which control what happens on ok an cancel button presses """
def addOkListener(self, onOkEvent):
self.ok.clicked.connect(onOkEvent)
def addCancelListener(self, onCancelEvent):
self.cancel.clicked.connect(onCancelEvent)
""" utility methods of the widget """
def getText(self):
return self.text.text()
def setText(self, text):
self.text.setText(text)
def setLabelText(self, text):
self.label.setText(text)
def setErrorText(self, text):
self.error.setText(text)
class TimeInputLine(QFrame):
WIDTH = 396
HEIGHT = 43
FRAME_WIDTH = 1
FRAME_MARGIN = 2
ICON_SIZE = 35
ICON_BUTTON_WIDTH = 60
LABEL_SIZE_X = 174
INPUT_SIZE_X = 100
BUTTON_BLOCK_X = 278
STEP = 0.5
MIN_VALUE = 0.1
MAX_VALUE = 10
DECIMAL_COUNT = 1
def __init__(self, parent):
super().__init__(parent)
self.initUI()
def initUI(self):
self.resize(TimeInputLine.WIDTH + TimeInputLine.FRAME_MARGIN*2, TimeInputLine.HEIGHT + TimeInputLine.FRAME_MARGIN*2)
self.setFrameStyle(QFrame.StyledPanel)
self.setLineWidth(TimeInputLine.FRAME_WIDTH)
component_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
.QPushButton:pressed {
background-color:#CCCCCC;
}
.QDoubleSpinBox {
font-weight: bold;
font-size: 23px;
}
.QLabel {
font-weight: bold;
font-size: 23px;
}
"""
self.label = QLabel("", self)
self.label.resize(TimeInputLine.LABEL_SIZE_X, TimeInputLine.HEIGHT)
self.label.move(TimeInputLine.FRAME_MARGIN, TimeInputLine.FRAME_MARGIN)
self.label.setStyleSheet(component_stylesheet)
self.label.setAlignment(Qt.AlignCenter)
self.label.show()
self.spinbox = QDoubleSpinBox(self)
self.spinbox.setRange(TimeInputLine.MIN_VALUE, TimeInputLine.MAX_VALUE)
self.spinbox.setValue(TimeInputLine.STEP)
self.spinbox.setSingleStep(TimeInputLine.STEP)
self.spinbox.setDecimals(TimeInputLine.DECIMAL_COUNT)
self.spinbox.resize(TimeInputLine.INPUT_SIZE_X, TimeInputLine.HEIGHT)
self.spinbox.move(TimeInputLine.LABEL_SIZE_X + TimeInputLine.FRAME_MARGIN, TimeInputLine.FRAME_MARGIN)
self.spinbox.setStyleSheet(component_stylesheet)
self.spinbox.show()
self.enter = QPushButton("", self)
self.enter.setIcon(assets.enter)
self.enter.setIconSize(QSize(TimeInputLine.ICON_SIZE, TimeInputLine.ICON_SIZE))
self.enter.resize(TimeInputLine.ICON_BUTTON_WIDTH, TimeInputLine.HEIGHT)
self.enter.move(TimeInputLine.BUTTON_BLOCK_X, TimeInputLine.FRAME_MARGIN)
self.enter.setStyleSheet(component_stylesheet)
self.enter.show()
self.cancel = QPushButton("", self)
self.cancel.setIcon(assets.exit)
self.cancel.setIconSize(QSize(TimeInputLine.ICON_SIZE, TimeInputLine.ICON_SIZE))
self.cancel.resize(TimeInputLine.ICON_BUTTON_WIDTH, TimeInputLine.HEIGHT)
self.cancel.move(TimeInputLine.BUTTON_BLOCK_X + TimeInputLine.ICON_BUTTON_WIDTH, TimeInputLine.FRAME_MARGIN)
self.cancel.setStyleSheet(component_stylesheet)
self.cancel.show()
""" listeners which control what happens on accept and on cancel button presses """
def addAcceptListener(self, onAcceptListener):
self.enter.clicked.connect(onAcceptListener)
def addCancelListener(self, onCancelListener):
self.cancel.clicked.connect(onCancelListener)
class SingleRank(QWidget):
single_rk_comeback_sg = pyqtSignal()
detail_sg = pyqtSignal(str)
def __init__(self, parent=None):
super(SingleRank, self).__init__(parent)
self.desktop = QApplication.desktop()
self.screenRect = self.desktop.screenGeometry()
self.h = self.screenRect.height()
self.w = self.screenRect.width()
self.xr = self.w / 930
self.yr = self.h / 640
self.zr = min(self.xr, self.yr)
self.inlist = {}
self.back2_wi = QWidget(self)
self.rankexit_but = QPushButton(self)
self.header1 = QLabel(self.back2_wi)
self.comeback_but = QPushButton(self.back2_wi)
self.next_but = QPushButton(self.back2_wi)
self.table = QWidget(self.back2_wi)
self.tablein = QGridLayout()
self.headers = ['对局id', '分数', '时间', '详情']
self.set_ui()
with open('rank.qss', 'r') as f:
self.setStyleSheet(f.read())
def set_ui(self):
self.setWindowTitle('SingleRank')
self.setObjectName('singlerank')
self.resize(self.w, self.h)
effect = QGraphicsDropShadowEffect()
effect.setOffset(10, 10)
effect.setColor(QColor(0, 0, 0, 80))
effect.setBlurRadius(20)
effect1 = QGraphicsDropShadowEffect()
effect1.setOffset(10, 10)
effect1.setColor(QColor(0, 0, 0, 80))
effect1.setBlurRadius(20)
self.back2_wi.setObjectName('back')
self.back2_wi.resize(self.xr * 793, self.yr * 534)
self.back2_wi.move(self.xr * 69, self.yr * 53)
self.back2_wi.setGraphicsEffect(effect)
self.header1.setObjectName('header')
self.header1.resize(self.xr * 172, self.yr * 36)
self.header1.move(self.xr * 24, self.yr * 10)
self.header1.setText('过往战绩')
self.header1.setAlignment(Qt.AlignCenter)
self.comeback_but.setObjectName('comeback')
self.comeback_but.resize(self.xr * 80, self.yr * 36)
self.comeback_but.move(self.xr * 67, self.yr * 467)
self.comeback_but.setText('返回')
self.comeback_but.clicked.connect(self.come_back)
self.comeback_but.setGraphicsEffect(effect1)
self.next_but.setObjectName('next')
self.next_but.resize(self.zr * 38, self.zr * 38)
self.next_but.move(self.xr * 725, self.yr * 468)
self.next_but.setStyleSheet('border-radius:{}px;'.format(self.zr * 18))
self.next_but.clicked.connect(self.next)
self.table.setObjectName('table')
self.table.resize(self.xr * 746, self.yr * 382)
self.table.move(self.xr * 24, self.yr * 61)
self.tablein.setSpacing(0)
self.tablein.setContentsMargins(0, 0, 0, 0)
self.table.setLayout(self.tablein)
li = ['#f5f0e3', '#cccccc']
for i in range(0, 5):
for j in range(0, 4):
if j == 3 and i != 0:
exec('self.tableheader{}_{} = QPushButton()'.format(i, j))
exec(
'self.tableheader{}_{}.setMinimumHeight(self.yr *382/5)'
.format(i, j))
exec('self.tableheader{}_{}.setText("详情")'.format(i, j))
exec(
'self.tableheader{}_{}.clicked.connect(self.details{})'
.format(i, j, i))
else:
exec('self.tableheader{}_{} = QLabel()'.format(i, j))
exec('self.tableheader{}_{}.setAlignment(Qt.AlignCenter)'.
format(i, j))
if i == 0:
exec('self.tableheader{}_{}.setObjectName("table_head")'.
format(i, j))
exec('self.tableheader{}_{}.setText("{}")'.format(
i, j, self.headers[j]))
else:
exec('self.tableheader{}_{}.setObjectName("table_unit")'.
format(i, j))
exec(
'self.tableheader{}_{}.setStyleSheet("background-color:{};")'
.format(i, j, li[(i + j) % 2]))
exec('self.tablein.addWidget(self.tableheader{}_{}, {}, {})'.
format(i, j, i, j))
self.back2_wi.setStyleSheet('#back{border-radius:' +
str(self.zr * 20) +
'px;}#header{border-radius:' +
str(self.zr * 15) + 'px;font-size:' +
str(int(self.zr * 18)) +
'px;}#comeback{border-radius:' +
str(self.zr * 15) + 'px;font-size:' +
str(int(self.zr * 16)) +
'px;}#table_unit{font-size:' +
str(int(self.zr * 18)) +
'px;}#table_head{font-size:' +
str(int(self.zr * 20)) +
'px;font-weight:bold}')
def come_back(self):
self.single_rk_comeback_sg.emit()
def get_list(self, info):
if len(info) >= 4:
li = info[:4]
self.inlist = info[4:]
else:
li = info
self.inlist = info
self.set_table(li)
def set_table(self, mp):
lens = len(mp)
for i in range(1, lens + 1):
self.next_but.setEnabled(True)
exec('self.tableheader{}_0.setText("{}")'.format(
i, mp[i - 1]['id']))
exec('self.tableheader{}_1.setText("{}")'.format(
i, mp[i - 1]['score']))
exec('self.tableheader{}_2.setText("{}")'.format(
i, mp[i - 1]['time']))
if lens < 4:
for i in range(lens + 1, 5):
self.next_but.setEnabled(False)
exec('self.tableheader{}_0.clear()'.format(i))
exec('self.tableheader{}_1.clear()'.format(i))
exec('self.tableheader{}_2.clear()'.format(i))
def next(self):
if len(self.inlist) >= 4:
li = self.inlist[:4]
self.inlist = self.inlist[4:]
else:
li = self.inlist
self.set_table(li)
def details1(self):
if self.tableheader1_0.text() != '':
self.detail_sg.emit(self.tableheader1_0.text())
def details2(self):
if self.tableheader2_0.text() != '':
self.detail_sg.emit(self.tableheader2_0.text())
def details3(self):
if self.tableheader3_0.text() != '':
self.detail_sg.emit(self.tableheader3_0.text())
def details4(self):
if self.tableheader4_0.text() != '':
self.detail_sg.emit(self.tableheader4_0.text())
class ResultSingle(QWidget):
result_exit_sg = pyqtSignal()
def __init__(self, parent=None):
super(ResultSingle, self).__init__(parent)
self.desktop = QApplication.desktop()
self.screenRect = self.desktop.screenGeometry()
self.h = self.screenRect.height()
self.w = self.screenRect.width()
self.xr = self.w / 930
self.yr = self.h / 640
self.zr = min(self.xr, self.yr)
self.back1_wi = QWidget(self)
self.resexit_but = QPushButton(self)
self.id_head = QLabel(self.back1_wi)
self.role1 = QWidget(self.back1_wi)
self.role1_detail = QWidget(self.role1)
self.role4 = QWidget(self.back1_wi)
self.role4_detail = QWidget(self.role4)
self.role4_special = QLabel(self.role4)
self.set_ui()
with open('result.qss', 'r') as f:
self.setStyleSheet(f.read())
def set_ui(self):
self.setWindowTitle('Result')
self.setObjectName('result')
self.resize(self.w, self.h)
effect = QGraphicsDropShadowEffect()
effect.setOffset(10, 10)
effect.setColor(QColor(0, 0, 0, 80))
effect.setBlurRadius(20)
self.back1_wi.setObjectName('back')
self.back1_wi.resize(self.xr * 793, self.yr * 534)
self.back1_wi.move(self.xr * 69, self.yr * 53)
self.back1_wi.setGraphicsEffect(effect)
back_x = 69
back_y = 53
effect1 = QGraphicsDropShadowEffect()
effect1.setOffset(10, 10)
effect1.setColor(QColor(0, 0, 0, 80))
effect1.setBlurRadius(20)
effect4 = QGraphicsDropShadowEffect()
effect4.setOffset(10, 10)
effect4.setColor(QColor(0, 0, 0, 80))
effect4.setBlurRadius(20)
self.resexit_but.setObjectName('resexit')
self.resexit_but.resize(self.zr * 38, self.zr * 38)
self.resexit_but.move(self.xr * 834, self.yr * 36)
self.resexit_but.clicked.connect(self.result_exit)
self.resexit_but.setStyleSheet('border-radius:{}px;'.format(self.zr * 18))
self.id_head.setObjectName('id_head')
self.id_head.resize(self.xr * 350, self.yr * 140)
self.id_head.move(self.xr * 225, self.yr * 195)
# self.id_head.setText('战局ID:4396')
self.id_head.setAlignment(Qt.AlignCenter)
self.id_head.setStyleSheet('font-size:{}px;'.format(int(self.zr * 50)))
self.role1.setObjectName('role')
self.role1.resize(self.xr * 716, self.yr * 87)
self.role1.move(self.xr * (108 - back_x), self.yr * (77 - back_y))
self.role1.setGraphicsEffect(effect1)
# self.role1_head.setText('test')
self.role1_detail.setObjectName('role_detail')
self.role1_detail.resize(self.xr * 606, self.yr * 87)
self.role1_detail.move(self.xr * 110, self.yr * 0)
self.role4.setObjectName('role')
self.role4.resize(self.xr * 716, self.yr * 87)
self.role4.move(self.xr * (108 - back_x), self.yr * (467 - back_y))
self.role4.setGraphicsEffect(effect4)
self.role4_detail.setObjectName('role_detail')
self.role4_detail.resize(self.xr * 606, self.yr * 87)
self.role4_detail.move(self.xr * 110, self.yr * 0)
self.role4_special.setObjectName('role_special')
self.role4_special.resize(self.xr * 88, self.yr * 36)
self.role4_special.move(self.xr * 70, self.yr * 26)
self.role4_special.setAlignment(Qt.AlignCenter)
for i in range(1, 14):
if i >= 9:
xp = 416
t = 9
elif i >= 4:
xp = 239
t = 4
else:
xp = 108
t = 1
if i == 3 or i == 8 or i == 13:
exec('self.role4_lv{}=QLabel(self.role4_detail)'.format(i))
exec('self.role4_lv{}.resize(self.xr*46,self.yr*67)'.format(i))
exec('self.role4_lv{}.move(self.xr*(xp+({}-t)*20)+90,self.yr*10)'.format(i, i))
exec('self.role4_lv{}.setStyleSheet("font-size:{}px;")'.format(i, int(self.zr * 17)))
# exec('self.role4_lv{}.setText(change_vertical(" 葫芦"))'.format(i))
exec('self.role4_lv{}.setAlignment(Qt.AlignCenter)'.format(i))
exec('self.role1_card{}=QLabel(self.role1_detail)'.format(i))
exec('self.role1_card{}.setObjectName("card")'.format(i))
exec('self.role1_card{}.resize(self.xr*46,self.yr*67)'.format(i))
exec('self.role1_card{}.move(self.xr*i*33,self.yr*10)'.format(i))
exec('self.role1_card{}.setScaledContents(True)'.format(i))
exec('self.role4_card{}=QLabel(self.role4_detail)'.format(i))
exec('self.role4_card{}.setObjectName("card")'.format(i))
exec('self.role4_card{}.resize(self.xr*46,self.yr*67)'.format(i))
exec('self.role4_card{}.move(self.xr*(xp+({}-t)*20),self.yr*10)'.format(i, i))
exec('self.role4_card{}.setScaledContents(True)'.format(i))
self.back1_wi.setStyleSheet(
'#back{border-radius:' + str(self.zr * 25) + 'px;}#role{border-radius:' + str(
self.zr * 18) + 'px;}#role_head{border-radius:' + str(self.zr * 15) + 'px;font-size:' + str(
int(self.zr * 16)) + 'px;}#role_special{font-size:' + str(int(self.zr * 18)) + 'px;}')
def result_exit(self):
self.result_exit_sg.emit()
def set_role(self, info):
self.id_head.setText('战局ID:{}'.format(info['id']))
self.role4_special.setText('{}'.format('散牌'))
i = 1
for card in info['origin_cards']:
exec('self.role1_card{}.setPixmap(QPixmap("./resource/image/{}.jpg"))'.format(i, card))
i += 1
t = 3
j = 1
for de in info['cards']:
exec('self.role4_lv{}.setText("{}")'.format(t, de['lv']))
for card in de["card"]:
exec('self.role4_card{}.setPixmap(QPixmap("./resource/image/{}.jpg"))'.format(j, card))
j += 1
t += 5
import sys
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import QCoreApplication
from PyQt5.Qt import QPushButton
app = QApplication(sys.argv)
w = QWidget()
w.setWindowTitle("나는윈도우야.")
w.setWindowIcon(QIcon('web.png'))
w.setGeometry(1000, 300, 300, 300)
btn = QPushButton('Quit', w)
btn.move(50, 50)
btn.resize(btn.sizeHint())
btn.clicked.connect(QCoreApplication.instance().quit)
w.show()
app.exec()
class GUI(QtWidgets.QMainWindow):
def __init__(self):
'''Asetetaan muuttujille alkuarvoja ohjelman suorittamiseksi'''
super().__init__()
self.title = "Lujuusanalysaattori"
self.left = 200
self.top = 200
self.width = 1300
self.height = 700
self.palkin_default_pituus = 5
self.square_size = 10
self.ikkuna()
self.button_height = 75
self.button_width = 150
self.button_separation = 25
self.x = 0
self.y = 0
self.palkin_leveys = 700
self.palkin_korkeus = 75
self.palkin_keskipiste = 650
self.palkin_paatypiste = 1000
self.yksikko_arvo = 0
self.voima = 20
self.maks_jannitys = "-"
self.asteikko_teksti = QGraphicsSimpleTextItem()
'''Lisää QGraphicsScenen ruudukon piirtämistä varten'''
self.scene = QtWidgets.QGraphicsScene()
self.scene.setSceneRect(0, -20, self.width - 200, self.height - 100)
'''Suoritetaan lukuisia metodeja, jolla ohjelma "alustetaan"'''
self.aloita_simulaatio()
self.simulaatioikkuna()
self.simulaatio_nappi()
self.materiaali_valikko()
self.uusi_palkki_nappi()
self.lisaa_tuki_nappi()
self.lisaa_ulkoinen_voima_nappi()
self.poista_ulkoinen_voima_nappi()
self.vaihda_tuki_nappi()
Ominaisuudet.alkuarvot(self)
self.lisaa_palkki()
self.palkin_pituus_valikko()
self.yksikko_pituus()
self.asteikko()
self.lisaa_asteikko_arvo()
self.asteikko_teksti.hide()
self.tulos_teksti()
self.lisaa_seina_tuki()
self.lisaa_tuki_alhaalta()
self.ulkoinen_voima_valikko()
self.ulkoinen_voima_nuoli_alatuki()
self.ulkoinen_voima_nuoli_seinatuki()
Ominaisuudet.alkuarvot(self)
'''Asetetaan tietyille napeille tietty näkyvyys'''
self.lisaa_tuki.setEnabled(False)
self.simuloi.setEnabled(False)
self.show()
def ikkuna(self):
'''Tekee ohjelman pääikkunan'''
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowTitle('Lujuusanalysaattori')
self.horizontal = QtWidgets.QHBoxLayout()
'''Luo menubarin'''
self.uusiAction = QAction("Uusi simulaatio", self)
self.uusiAction.setStatusTip("Luo uusi rakenne")
self.uusiAction.triggered.connect(self.uusi_rakenne)
self.uusiAction.setEnabled(True)
self.uusiAction.setShortcut("Ctrl+N")
self.tallennaAction = QAction("Tallenna simulaatio", self)
self.tallennaAction.setStatusTip("Tallenna simulaatio")
self.tallennaAction.triggered.connect(self.tallenna_rakenne)
self.tallennaAction.setEnabled(False)
self.tallennaAction.setShortcut("Ctrl+S")
self.avaaAction = QAction("Lataa simulaatio", self)
self.avaaAction.setStatusTip("Lataa simulaatio tiedostosta")
self.avaaAction.triggered.connect(self.lataa_tallennettu_rakenne)
self.avaaAction.setShortcut("Ctrl+O")
self.exitAction = QAction("Exit", self)
self.exitAction.setToolTip("Lopeta ohjelma")
self.exitAction.triggered.connect(self.close_application)
self.exitAction.setShortcut("Ctrl+E")
self.statusBar()
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu('&File')
aboutMenu = mainMenu.addMenu('&About')
fileMenu.addAction(self.uusiAction)
fileMenu.addAction(self.avaaAction)
fileMenu.addAction(self.tallennaAction)
fileMenu.addAction(self.exitAction)
def tallenna_rakenne(self):
'''Hoitaa rakenteen tallentamisen'''
tallennus = Tallennin.tallenin(self)
if tallennus == True:
'''Kerrotaan käyttäjälle, että tallennus onnistui'''
msgBox = QMessageBox()
msgBox.setText("Tallennus onnistui!")
msgBox.setWindowTitle("Onnistunut Tallennus")
msgBox.setMinimumWidth(50)
msgBox.addButton(QPushButton('OK'), QMessageBox.NoRole)
msgBox.exec_()
def lataa_tallennettu_rakenne(self):
'''Metodi avaa QFileDialog ikkunan, josta käyttäjä valitsee tiedoston, jossa aiemmin tallennettu rakenne sijaitsee. Vain .txt -tiedostot
ovat ladattavissa '''
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
tiedosto, _ = QFileDialog.getOpenFileName(self,
"Valitse tiedosto",
"",
"txt Files (*.txt)",
options=options)
lataus = Lataaja.lataaja(self, tiedosto)
if lataus == False:
return
if lataus == True:
self.uusi_rakenne()
Lataaja.lataaja(self, tiedosto)
tuen_tyyppi = Ominaisuudet.palauta_tuen_tyyppi(self)
'''Jos tuki on seinästä, piirretään sitä vastaava grafiikka'''
if tuen_tyyppi == 0:
self.nayta_seina_tuki()
self.gradient_seina_tuki()
'''Jos tuki on alhaalta, piirretään sitä vastaava grafiikka'''
if tuen_tyyppi == 1:
self.nayta_tuki_alhaalta()
self.gradient_alatuki()
if tuen_tyyppi != 2:
self.vaihda_tuki.show()
self.lisaa_tuki.hide()
'''Jos ulkoinen voima on asetettu, piirretään se'''
ulkoinen_voima = int(
Ominaisuudet.onko_ulkoinen_voima_asetettu(self))
if ulkoinen_voima == 1:
self.nayta_ulkoinen_voima()
self.nayta_palkki()
Laskin.laskin(self)
self.paivita_tulos_teksti()
self.tulos.show()
self.sp.setValue(float(Ominaisuudet.palauta_palkin_pituus(self)))
self.uusiAction.setEnabled(True)
self.simuloi.setEnabled(True)
'''Kerrotaan käyttäjälle, että kaikki onnistui'''
msgBox = QMessageBox()
msgBox.setText("Lataus onnistui!")
msgBox.setWindowTitle("Onnistunut lataus")
msgBox.addButton(QPushButton('OK'), QMessageBox.NoRole)
msgBox.exec_()
def aloita_simulaatio(self):
'''Aloittaa simulaation'''
self.setCentralWidget(QtWidgets.QWidget())
self.horizontal = QtWidgets.QHBoxLayout()
self.centralWidget().setLayout(self.horizontal)
def simulaatioikkuna(self):
'''lisää view näyttämistä varten'''
self.view = QtWidgets.QGraphicsView(self.scene, self)
self.view.adjustSize()
self.view.show()
self.horizontal.addWidget(self.view)
def uusi_palkki_nappi(self):
'''Luo Uusi palkki -napin'''
self.uusi_palkki = QPushButton('Uusi palkki')
self.uusi_palkki.setToolTip("Lisää uusi palkki")
self.uusi_palkki.move(0, 0)
self.uusi_palkki.resize(self.button_width, self.button_height)
self.uusi_palkki.font = QtGui.QFont()
self.uusi_palkki.font.setPointSize(12)
self.uusi_palkki.setFont(self.uusi_palkki.font)
self.uusi_palkki.setEnabled(True)
self.scene.addWidget(self.uusi_palkki)
self.uusi_palkki.clicked.connect(self.nayta_palkki)
def nayta_palkki(self):
'''Näyttää kaikki palkkiin liittyvät komponentit sekä asettaa uusi palkki -napin toimimattomaksi'''
self.rect.show()
self.palkin_pituus.show()
self.sp.show()
self.yksikko.show()
self.asteikko_teksti.show()
self.line.show()
self.nuoli_1.show()
self.nuoli_2.show()
self.uusi_palkki.setEnabled(False)
self.lisaa_tuki.setEnabled(True)
self.materiaali_valinta.setEnabled(True)
def lisaa_palkki(self):
'''lisää palkin'''
self.rect = QGraphicsRectItem(300, 200, self.palkin_leveys,
self.palkin_korkeus)
self.rect.setBrush(QBrush(4))
self.scene.addItem(self.rect)
self.rect.hide()
self.lisaa_tuki.setEnabled(True)
'''Aina kun on uusi palkki luotu, voidaan aloittaa simulaatio alusta'''
self.uusiAction.setEnabled(True)
def lisaa_tuki_nappi(self):
'''Luo Lisää tuki -napin'''
self.lisaa_tuki = QPushButton("Lisää tuki")
self.lisaa_tuki.setToolTip("Lisää tuki")
self.lisaa_tuki.move(0, self.button_height + self.button_separation)
self.lisaa_tuki.resize(self.button_width, self.button_height)
self.lisaa_tuki.font = QtGui.QFont()
self.lisaa_tuki.font.setPointSize(12)
self.lisaa_tuki.setFont(self.lisaa_tuki.font)
self.lisaa_tuki.setEnabled(False)
self.lisaa_tuki.clicked.connect(self.valitse_tuki)
self.scene.addWidget(self.lisaa_tuki)
def vaihda_tuki_nappi(self):
'''Luo vaihda tuki -napin'''
self.vaihda_tuki = QPushButton("Vaihda tuki")
self.vaihda_tuki.setToolTip("Vaihda tuki")
self.vaihda_tuki.move(0, self.button_height + self.button_separation)
self.vaihda_tuki.resize(self.button_width, self.button_height)
self.vaihda_tuki.setFont(self.lisaa_tuki.font)
self.vaihda_tuki.clicked.connect(self.valitse_tuki)
self.scene.addWidget(self.vaihda_tuki)
self.vaihda_tuki.hide()
def valitse_tuki(self):
'''Tuen valinta.
Jos tuki on seinästä (tyyppi = 0), kysytään halutaanko vaihtaa.
Jos haluaa muutetaan tuen grafiikka ja arvo'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 0:
msgBox = QMessageBox()
msgBox.setText("Haluatko vaihtaa tuen tyyppiä?")
msgBox.addButton(QPushButton('En'), QMessageBox.NoRole)
msgBox.addButton(QPushButton('Kyllä'), QMessageBox.YesRole)
vastaus = msgBox.exec_()
self.rect.setBrush(QBrush(4))
if vastaus == 1:
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
self.nayta_tuki_alhaalta()
if int(Ominaisuudet.onko_ulkoinen_voima_asetettu(self)) == 1:
self.viiva.hide()
self.nuoli_3.hide()
self.viiva_5.show()
self.nuoli_6.show()
Ominaisuudet.tuki(self, 1)
return
'''Jos tuki on alhaalta (tyyppi = 1), kysytään halutaanko vaihtaa.
Jos haluaa muutetaan tuen grafiikka ja arvo'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 1:
msgBox = QMessageBox()
msgBox.setText("Haluatko vaihtaa tuen tyyppiä?")
msgBox.addButton(QPushButton('Kyllä'), QMessageBox.YesRole)
msgBox.addButton(QPushButton('En'), QMessageBox.NoRole)
vastaus = msgBox.exec_()
self.rect.setBrush(QBrush(4))
if vastaus == 0:
Ominaisuudet.tuki(self, 0)
self.nuoli_4.hide()
self.nuoli_5.hide()
self.nayta_seina_tuki()
if int(Ominaisuudet.onko_ulkoinen_voima_asetettu(self)) == 1:
self.viiva.show()
self.nuoli_3.show()
self.viiva_5.hide()
self.nuoli_6.hide()
if vastaus == 1:
pass
'''Jos tukea ei ole (tyyppi = 2). Tuen tyypin valinta'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 2:
msgBox = QMessageBox()
msgBox.setText("Valitse tuen tyyppi")
msgBox.addButton(QPushButton('Seinätuki'), QMessageBox.YesRole)
msgBox.addButton(QPushButton('Tuki alhaalta'), QMessageBox.NoRole)
vastaus = msgBox.exec_()
self.vaihda_tuki.show()
self.lisaa_tuki.hide()
if vastaus == 0:
self.nayta_seina_tuki()
Ominaisuudet.tuki(self, 0)
if vastaus == 1:
self.nayta_tuki_alhaalta()
Ominaisuudet.tuki(self, 1)
'''Joka tapauksessa asetetaan ulkoisen voiman lisääminen mahdolliseksi
sekä maalataan palkki normaaliksi'''
self.lisaa_ulkoinen_voima.setEnabled(True)
self.simuloi.setEnabled(True)
def nayta_seina_tuki(self):
'''Näytetään seinätukea kuvaavat grafiikat'''
self.viiva_1.show()
self.viiva_2.show()
self.viiva_3.show()
self.viiva_4.show()
def nayta_tuki_alhaalta(self):
'''Näytetään alatukea kuvaavat grafiikat'''
self.nuoli_4.show()
self.nuoli_5.show()
def paivita_tuen_tyyppi(self, tyyppi):
'''Päivittää tuen tyypin arvon Ominaisuudet luokassa'''
Ominaisuudet.tuki(self, tyyppi)
def lisaa_seina_tuki(self):
'''Piirtää seinätukea kuvaavat viivat sekä asettaa self.tuen_tyyppi arvoksi
Asettaa SIMULOI-napin painettavaksi'''
viiva = QtGui.QPen(QtCore.Qt.black, 2)
viiva.setStyle(QtCore.Qt.SolidLine)
self.viiva_1 = QGraphicsLineItem(QtCore.QLineF(300, 202, 275, 225))
self.viiva_2 = QGraphicsLineItem(QtCore.QLineF(300, 222, 275, 245))
self.viiva_3 = QGraphicsLineItem(QtCore.QLineF(300, 242, 275, 265))
self.viiva_4 = QGraphicsLineItem(QtCore.QLineF(300, 262, 275, 285))
self.scene.addItem(self.viiva_1)
self.scene.addItem(self.viiva_2)
self.scene.addItem(self.viiva_3)
self.scene.addItem(self.viiva_4)
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
tyyppi = 0
Ominaisuudet.tuki(self, tyyppi)
self.simuloi.setEnabled(True)
def lisaa_tuki_alhaalta(self):
'''Piirtää alhaalta tukemista kuvaavat grafiikat
sekä asettaa self.tuen_tyyppi arvoksi 1'''
leveys = 15 #nuolen leveus pikseleissä
korkeus = 30 #nuuolen korkeus pikseleissä
'''Nuolen kärkien koordinaatit'''
nuoli_piste_1 = QtCore.QPointF(305, 275)
nuoli_piste_2 = QtCore.QPointF(305 - leveys, 275 + korkeus)
nuoli_piste_3 = QtCore.QPointF(305 + leveys, 275 + korkeus)
nuoli_piste_4 = QtCore.QPointF(995, 275)
nuoli_piste_5 = QtCore.QPointF(995 - leveys, 275 + korkeus)
nuoli_piste_6 = QtCore.QPointF(995 + leveys, 275 + korkeus)
'''Luodaan nuolia kuvaavat QPolygonF oliot'''
self.nuoli_4 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_5 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_4, nuoli_piste_5, nuoli_piste_6]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
'''Lisätään nuolet sceneen'''
self.scene.addItem(self.nuoli_4)
self.scene.addItem(self.nuoli_5)
self.nuoli_4.hide()
self.nuoli_5.hide()
tyyppi = 1
Ominaisuudet.tuki(self, tyyppi)
self.simuloi.setEnabled(True)
def lisaa_ulkoinen_voima_nappi(self):
'''Luo Lisää ulkoinen voima -napin'''
self.lisaa_ulkoinen_voima = QPushButton("Lisää ulkoinen voima")
self.lisaa_ulkoinen_voima.setToolTip("Lisää ulkoinen voima")
self.lisaa_ulkoinen_voima.move(
0, 2 * self.button_height + 2 * self.button_separation)
self.lisaa_ulkoinen_voima.resize(self.button_width, self.button_height)
self.lisaa_ulkoinen_voima.font = QtGui.QFont()
self.lisaa_ulkoinen_voima.font.setPointSize(8)
self.lisaa_ulkoinen_voima.setFont(self.lisaa_ulkoinen_voima.font)
self.lisaa_ulkoinen_voima.clicked.connect(self.nayta_ulkoinen_voima)
self.lisaa_ulkoinen_voima.clicked.connect(self.nollaa_gradientti)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.scene.addWidget(self.lisaa_ulkoinen_voima)
def poista_ulkoinen_voima_nappi(self):
'''Luo poista ulkoinen voima -napin'''
self.poista_ulkoinen_voima = QPushButton("Poista ulkoinen voima")
self.poista_ulkoinen_voima.setToolTip("Poista ulkoinen voima")
self.poista_ulkoinen_voima.move(
0, 2 * self.button_height + 2 * self.button_separation)
self.poista_ulkoinen_voima.resize(self.button_width,
self.button_height)
self.poista_ulkoinen_voima.setFont(self.lisaa_ulkoinen_voima.font)
self.poista_ulkoinen_voima.clicked.connect(self.piilota_ulkoinen_voima)
self.poista_ulkoinen_voima.clicked.connect(self.nollaa_gradientti)
self.scene.addWidget(self.poista_ulkoinen_voima)
self.poista_ulkoinen_voima.hide()
def piilota_ulkoinen_voima(self):
'''Piilotaa kaiken ulkoiseen voimaan liittyvän'''
self.sp_voima.hide()
self.yksikko_voima.hide()
self.ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
self.lisaa_ulkoinen_voima.setEnabled(True)
self.viiva.hide()
self.nuoli_3.hide()
self.viiva_5.hide()
self.nuoli_6.hide()
self.poista_ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
self.tulos.hide()
Ominaisuudet.ulkoinen_voima(self, 0)
def nayta_ulkoinen_voima(self):
'''Näytetään ulkoinen voima riippuen tuen tyypistä'''
self.sp_voima.show()
self.yksikko_voima.show()
self.ulkoinen_voima.show()
self.lisaa_ulkoinen_voima.hide()
self.poista_ulkoinen_voima.show()
if int(Ominaisuudet.palauta_tuen_tyyppi(self)) == 0:
self.viiva.show()
self.nuoli_3.show()
if int(Ominaisuudet.palauta_tuen_tyyppi(self)) == 1:
self.viiva_5.show()
self.nuoli_6.show()
Ominaisuudet.ulkoinen_voima(self, 1)
def ulkoinen_voima_valikko(self):
'''Luo voiman suuruus -tekstin'''
self.ulkoinen_voima = QGraphicsSimpleTextItem("Voiman suuruus")
self.ulkoinen_voima.setPos(600, 5)
self.ulkoinen_voima.font = QtGui.QFont()
self.ulkoinen_voima.font.setPointSize(12)
self.ulkoinen_voima.setFont(self.ulkoinen_voima.font)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.scene.addItem(self.ulkoinen_voima)
self.ulkoinen_voima.hide()
'''Luo voiman arvon QSpinBoxin'''
self.sp_voima = QSpinBox()
self.sp_voima.move(750, 5)
self.sp_voima.setRange(0, 10000)
self.sp_voima.setSingleStep(1)
self.sp_voima.setMinimumHeight(30)
self.sp_voima.setValue(int(Ominaisuudet.palauta_voima(self)))
self.sp_voima.valueChanged.connect(self.paivita_voima)
self.scene.addWidget(self.sp_voima)
self.sp_voima.hide()
'''Luo yksikönvalinta QComboBOxin'''
self.yksikko_voima = QComboBox()
self.yksikko_voima.addItem("kN", 0)
self.yksikko_voima.addItem("N", 1)
self.yksikko_voima.move(820, 5)
self.yksikko_voima.setMinimumHeight(30)
self.yksikko_voima.setCurrentIndex(
int(Ominaisuudet.palauta_voiman_yksikko(self)))
self.yksikko_voima.setEditable(True)
self.yksikko_voima.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.scene.addWidget(self.yksikko_voima)
self.yksikko_voima.currentIndexChanged.connect(
self.paivita_yksikko_voima)
self.yksikko_voima.hide()
def ulkoinen_voima_nuoli_seinatuki(self):
'''Luo nuolen osoittamaan ulkoisen voiman paikkaa'''
voima_viiva = QtGui.QPen(QtCore.Qt.black, 2)
voima_viiva.setStyle(QtCore.Qt.SolidLine)
'''Nuolen kärkien koordinaatit seinätuelle'''
nuoli_piste_1 = QtCore.QPointF(self.palkin_paatypiste - 7, 185)
nuoli_piste_2 = QtCore.QPointF(self.palkin_paatypiste, 200)
nuoli_piste_3 = QtCore.QPointF(self.palkin_paatypiste + 7, 185)
viiva_x = self.palkin_paatypiste
self.viiva = QGraphicsLineItem(
QtCore.QLineF(viiva_x, 100, viiva_x, 200))
'''Luodaan nuoli QPolygonItem olio'''
self.nuoli_3 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.viiva)
self.scene.addItem(self.nuoli_3)
self.viiva.hide()
self.nuoli_3.hide()
'''Lisätään tieto, että voima on asetettu'''
Ominaisuudet.ulkoinen_voima(self, 1)
def ulkoinen_voima_nuoli_alatuki(self):
'''Nuolen kärkien koordinaatit alhaalta tuetulle palkille'''
nuoli_piste_1 = QtCore.QPointF(self.palkin_keskipiste - 7, 185)
nuoli_piste_2 = QtCore.QPointF(self.palkin_keskipiste, 200)
nuoli_piste_3 = QtCore.QPointF(self.palkin_keskipiste + 7, 185)
viiva_x = self.palkin_keskipiste
'''Luodaan nuoli QPolygonItem olio'''
self.nuoli_6 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
self.viiva_5 = QGraphicsLineItem(
QtCore.QLineF(viiva_x, 100, viiva_x, 200))
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.viiva_5)
self.scene.addItem(self.nuoli_6)
self.viiva_5.hide()
self.nuoli_6.hide()
'''Lisätään tieto, että voima on asetettu'''
Ominaisuudet.ulkoinen_voima(self, 1)
def paivita_voima(self):
'''Lukee voiman arvon
ja kutsuu Ominaisuudet luoka metodia voima'''
voima = self.sp_voima.value()
Ominaisuudet.voima(self, voima)
def paivita_yksikko_voima(self):
'''Lukee ykiskön arvon
ja kutsuu Ominaisuudet-luokan metodia yksikko_voima'''
self.yksikko_voima_arvo = self.yksikko_voima.currentData()
Ominaisuudet.yksikko_voima(self, self.yksikko_voima_arvo)
def materiaali_valikko(self):
''' Luo Materiaali-otsikon'''
self.materiaali = QGraphicsSimpleTextItem("Materiaali")
self.materiaali.setPos(
0, 3 * self.button_height + 3 * self.button_separation)
self.materiaali.font = QtGui.QFont()
self.materiaali.font.setPointSize(12)
self.materiaali.setFont(self.materiaali.font)
self.scene.addItem(self.materiaali)
'''Luo drop down valikon materiaalivalinnalle'''
self.materiaali_valinta = QComboBox()
self.materiaali_valinta.addItem("Teräs", 0)
self.materiaali_valinta.addItem("Alumiini", 1)
self.materiaali_valinta.addItem("Muovi", 2)
self.materiaali_valinta.move(
0, 3 * self.button_height + 3 * self.button_separation + 25)
self.materiaali_valinta.resize(self.button_width,
self.button_height - 25)
self.materiaali_valinta.setEditable(True)
self.materiaali_valinta.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.materiaali_valinta.setCurrentIndex(0)
self.scene.addWidget(self.materiaali_valinta)
self.materiaali_valinta.setEnabled(False)
self.materiaali_valinta.currentIndexChanged.connect(
self.paivita_materiaali)
def paivita_materiaali(self):
'''Lukee materiaalin arvon
ja kutsuu Ominaisuudet-luokan metodia materiaali'''
materiaali = self.materiaali_valinta.currentData()
Ominaisuudet.materiaali(self, materiaali)
def simulaatio_nappi(self):
'''Luo SIMULOI-napin'''
self.simuloi = QPushButton('SIMULOI')
self.simuloi.setToolTip('Simuloi valittu rakenne')
self.simuloi.move(0,
4 * self.button_height + 4 * self.button_separation)
self.simuloi.setStyleSheet("background-color:rgb(122, 201, 255)")
self.simuloi.resize(self.button_width, self.button_height)
self.simuloi.font = QtGui.QFont()
self.simuloi.font.setPointSize(12)
self.simuloi.setFont(self.simuloi.font)
self.simuloi.setEnabled(False)
self.simuloi.clicked.connect(self.simulaatio)
self.scene.addWidget(self.simuloi)
def simulaatio(self):
'''Kutsuu laskentaa suorittavaa metodia ja tallentaa tuloksen.
Tämän jälkeen kutsuu lopputuloksen esittävän tekstin päivittävää metodia
sekä palkin visualisoivaa gradient-metodia'''
Laskin.laskin(self)
Ominaisuudet.palauta_tulos(self)
self.paivita_tulos_teksti()
self.tallennaAction.setEnabled(True)
if Ominaisuudet.palauta_tuen_tyyppi(self) == 0:
if Ominaisuudet.onko_ulkoinen_voima_asetettu(self) == 1:
self.gradient_seina_tuki()
if Ominaisuudet.onko_ulkoinen_voima_asetettu(self) == 0:
self.gradient_seina_tuki_ei_voimaa()
if Ominaisuudet.palauta_tuen_tyyppi(self) == 1:
self.gradient_alatuki()
def tulos_teksti(self):
'''Lisää tekstin, joka kertoo maksimijänintyksen arvon'''
teksti = "Maksimijännitys " + str(self.maks_jannitys) + " MPa"
self.tulos = QGraphicsSimpleTextItem(teksti)
self.tulos.setPos(550, 500)
self.tulos.font = QtGui.QFont()
self.tulos.font.setPointSize(12)
self.tulos.setFont(self.tulos.font)
self.scene.addItem(self.tulos)
self.tulos.hide()
def paivita_tulos_teksti(self):
'''Päivittää maksimijännityksen arvoa kuvaavan tekstin'''
maks_jannitys = Ominaisuudet.palauta_tulos(self)
self.tulos.setText("Maksimijännitys " + str(maks_jannitys) + " MPa")
self.tulos.show()
def palkin_pituus_valikko(self):
'''Luo palkin pituus tekstin sekä spinbox-valitsimen pituuden asettamista varten
Päivittää palkin pituuden Ominaisuudet luokan avulla'''
self.palkin_pituus = QGraphicsSimpleTextItem("Palkin pituus")
self.palkin_pituus.setPos(300, 5)
self.palkin_pituus.font = QtGui.QFont()
self.palkin_pituus.font.setPointSize(12)
self.palkin_pituus.setFont(self.palkin_pituus.font)
self.scene.addItem(self.palkin_pituus)
self.palkin_pituus.hide()
self.sp = QSpinBox()
self.scene.addWidget(self.sp)
self.sp.hide()
self.sp.move(450, 5)
self.sp.setRange(0, 100)
self.sp.setSingleStep(1)
self.sp.setMinimumHeight(30)
self.sp.setValue(int(Ominaisuudet.palauta_palkin_pituus(self)))
self.paivita_pituus()
self.sp.valueChanged.connect(self.paivita_pituus)
def paivita_pituus(self):
'''Lukee palkin pituuden ja aktivoi Ominaisuudet luokan meodin palkin pituus'''
self.palkin_pituus_arvo = self.sp.value()
Ominaisuudet.palkin_pituus(self, self.palkin_pituus_arvo)
self.paivita_asteikon_arvot()
def yksikko_pituus(self):
'''Luo yksikönvalinta dropdown-menun
ja arvon muuttuessa päivittää yksikön Ominaisuudet-luokassa'''
self.yksikko = QComboBox()
self.yksikko.addItem("m", 0)
self.yksikko.addItem("cm", 1)
self.yksikko.addItem("mm", 2)
self.yksikko.move(500, 5)
self.yksikko.setMinimumHeight(30)
self.yksikko.setEditable(True)
self.yksikko.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.yksikko.setCurrentIndex(
Ominaisuudet.palauta_pituuden_yksikko(self))
self.scene.addWidget(self.yksikko)
self.yksikko.hide()
self.yksikko_arvo = self.yksikko.currentData()
self.yksikko.currentIndexChanged.connect(self.paivita_yksikko)
def paivita_yksikko(self):
'''Lukee yksikön arvon
ja kutsuu Ominaisuudet-luokan metodia yksikko'''
self.yksikko_arvo = self.yksikko.currentData()
Ominaisuudet.yksikko(self, self.yksikko_arvo)
self.paivita_asteikon_arvot()
def asteikko(self):
''''Luodaan viivaa kuvaava olio'''
viiva = QtGui.QPen(QtCore.Qt.black, 2)
viiva.setStyle(QtCore.Qt.SolidLine)
'''Oikean puoleisen nuolen kärkien koordinaatit'''
nuoli_1_piste_1 = QtCore.QPointF(990, 390)
nuoli_1_piste_2 = QtCore.QPointF(1000, 400)
nuoli_1_piste_3 = QtCore.QPointF(990, 410)
'''Vasemman puoleisen nuolen kärkien koordinaatit'''
nuoli_2_piste_1 = QtCore.QPointF(310, 390)
nuoli_2_piste_2 = QtCore.QPointF(300, 400)
nuoli_2_piste_3 = QtCore.QPointF(310, 410)
'''Luodaan nuoli QPolygonF oliot'''
self.nuoli_1 = QGraphicsPolygonItem(
QtGui.QPolygonF(
[nuoli_1_piste_1, nuoli_1_piste_2, nuoli_1_piste_3]))
self.nuoli_2 = QGraphicsPolygonItem(
QtGui.QPolygonF(
[nuoli_2_piste_1, nuoli_2_piste_2, nuoli_2_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
self.line = QGraphicsLineItem(QtCore.QLineF(300, 400, 1000, 400))
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.line)
self.scene.addItem(self.nuoli_1)
self.scene.addItem(self.nuoli_2)
self.line.hide()
self.nuoli_1.hide()
self.nuoli_2.hide()
def lisaa_asteikko_arvo(self):
'''Lisää tekstikentän pituuden arvolle sekä yksikölle'''
teksti = (str(Ominaisuudet.palauta_palkin_pituus(self)) + " " + "m")
self.asteikko_teksti = QGraphicsSimpleTextItem()
self.asteikko_teksti.setText(teksti)
self.asteikko_teksti.setPos(650, 425)
self.asteikko_teksti.font = QtGui.QFont()
self.asteikko_teksti.font.setPointSize(12)
self.asteikko_teksti.setFont(self.asteikko_teksti.font)
self.scene.addItem(self.asteikko_teksti)
self.asteikko_teksti.hide()
def paivita_asteikon_arvot(self):
'''Päivittää palkin pituutta kuvaavan asteikon'''
yksikko = Ominaisuudet.palauta_pituuden_yksikko(self)
if yksikko == 0:
self.yksikko_merkki = "m"
if yksikko == 1:
self.yksikko_merkki = "cm"
if yksikko == 2:
self.yksikko_merkki = "mm"
pituus = float(Ominaisuudet.palauta_palkin_pituus(self))
teksti = str(str(pituus) + " " + self.yksikko_merkki)
self.asteikko_teksti.setText(teksti)
self.asteikko_teksti.show()
def gradient_seina_tuki(self):
'''Luo seinästä tuetun palkin rasitusta kuvaavan gradientin'''
gradient = QLinearGradient(300, 200, 300 + self.palkin_leveys, 200)
gradient.setColorAt(0, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def gradient_seina_tuki_ei_voimaa(self):
'''Luo ilman ulkoista voimaa olevan gradientin'''
gradient = QLinearGradient(300, 200, 300 + (self.palkin_leveys / 2),
200)
gradient.setColorAt(0, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def gradient_alatuki(self):
'''Luo kahdella alatuella olevan palkin rasitusta kuvaavan gradientin'''
gradient = QLinearGradient(300, 200, 300 + self.palkin_leveys, 200)
gradient.setColorAt(0, QColor(65, 244, 83))
gradient.setColorAt(0.5, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def nollaa_gradientti(self):
'''Asettaa palkin "normaaliksi"'''
self.rect.setBrush(QBrush(4))
def uusi_rakenne(self):
'''Muokkaa ikkunaa uuden simulaation luomista varten'''
self.rect.hide()
self.ulkoinen_voima.hide()
self.sp_voima.hide()
self.yksikko_voima.hide()
self.nuoli_1.hide()
self.nuoli_2.hide()
self.nuoli_3.hide()
self.nuoli_4.hide()
self.nuoli_5.hide()
self.nuoli_6.hide()
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
self.viiva_5.hide()
self.viiva.hide()
self.palkin_pituus.hide()
self.sp.hide()
self.yksikko.hide()
self.line.hide()
self.asteikko_teksti.hide()
self.tulos.hide()
self.nollaa_gradientti()
self.lisaa_tuki.show()
self.vaihda_tuki.hide()
self.poista_ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
Ominaisuudet.alkuarvot(self)
'''Asettaa napit'''
self.uusi_palkki.setEnabled(True)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.lisaa_tuki.setEnabled(False)
self.simuloi.setEnabled(False)
self.tallennaAction.setEnabled(False)
'''Päivittää tuen tyypiksi arvon, joka vastaa, ettei tukea ole'''
self.tuen_tyyppi = 2
def close_application(self):
'''sulkee ohjelman'''
sys.exit()
class MainIndex(QWidget):
auto_pressed_sg = pyqtSignal(dict)
home_pressed_sg = pyqtSignal()
search_pressed_sg = pyqtSignal()
def __init__(self, parent=None):
super(MainIndex, self).__init__(parent)
self.desktop = QApplication.desktop()
self.screenRect = self.desktop.screenGeometry()
self.h = self.screenRect.height()
self.w = self.screenRect.width()
self.xr = self.w / 930
self.yr = self.h / 640
self.zr = min(self.xr, self.yr)
self.token = ''
self.top_wi = QWidget(self)
self.logo_la = QLabel(self.top_wi)
self.manual_but = QPushButton(self)
# self.manual_tex = QLabel(self)
self.auto_but = QPushButton(self)
# self.auto_tex = QLabel(self)
self.home_but = QPushButton(self)
# self.home_tex = QLabel(self)
self.loading = QLabel(self)
self.gif = QMovie('./resource/image/load.gif')
self.set_ui()
with open('mainindex.qss', 'r') as f:
self.setStyleSheet(f.read())
def set_ui(self):
self.setWindowTitle('Hall')
self.setObjectName('hall')
self.resize(self.w, self.h)
effect1 = QGraphicsDropShadowEffect()
effect1.setOffset(10, 10)
effect1.setColor(QColor(0, 0, 0, 80))
effect1.setBlurRadius(20)
effect2 = QGraphicsDropShadowEffect()
effect2.setOffset(10, 10)
effect2.setColor(QColor(0, 0, 0, 80))
effect2.setBlurRadius(20)
effect3 = QGraphicsDropShadowEffect()
effect3.setOffset(10, 10)
effect3.setColor(QColor(0, 0, 0, 80))
effect3.setBlurRadius(20)
self.top_wi.setObjectName('top')
self.top_wi.resize(self.xr * 930, self.yr * 95)
self.logo_la.setObjectName('logo')
self.logo_la.resize(self.xr * 65, self.zr * 65)
self.logo_la.move(self.xr * 29, self.yr * 16)
self.manual_but.setObjectName('box')
self.manual_but.resize(self.xr * 180, self.yr * 320)
self.manual_but.move(self.xr * 112, self.yr * 194)
self.manual_but.setText(change_vertical('战局搜索'))
self.manual_but.setStyleSheet(
'border-radius:{}px;font-size:{}px;'.format(
self.zr * 20, int(self.zr * 30)))
self.manual_but.setGraphicsEffect(effect1)
self.manual_but.clicked.connect(self.search_press)
# self.manual_tex.setObjectName('manual_tex')
# self.manual_tex.resize(self.xr * 34, self.yr * 413)
# self.manual_tex.move(self.xr * 68, self.yr * 152)
# self.manual_tex.setText(change_vertical('是当一辈子的懦夫，还是三十秒的勇士？'))
# self.manual_tex.setStyleSheet('font-size:{}px;'.format(int(self.zr * 17)))
self.auto_but.setObjectName('box')
self.auto_but.resize(self.xr * 180, self.yr * 320)
self.auto_but.move(self.xr * 381, self.yr * 194)
self.auto_but.setText(change_vertical('自动场'))
self.auto_but.setStyleSheet(
'border-radius:{}px;font-size:{}px;'.format(
self.zr * 20, int(self.zr * 30)))
self.auto_but.setGraphicsEffect(effect2)
self.auto_but.clicked.connect(self.auto_press)
# self.auto_tex.setObjectName('auto_tex')
# self.auto_tex.resize(self.xr * 34, self.yr * 413)
# self.auto_tex.move(self.xr * 340, self.yr * 152)
# self.auto_tex.setText(change_vertical('机器就要由机器来终结'))
# self.auto_tex.setStyleSheet('font-size:{}px;'.format(int(self.zr * 17)))
self.home_but.setObjectName('box')
self.home_but.resize(self.xr * 180, self.yr * 320)
self.home_but.move(self.xr * 660, self.yr * 194)
self.home_but.setText(change_vertical('沙之家'))
self.home_but.setStyleSheet(
'border-radius:{}px;font-size:{}px;'.format(
self.zr * 20, int(self.zr * 30)))
self.home_but.setGraphicsEffect(effect3)
self.home_but.clicked.connect(self.home_press)
# self.home_tex.setObjectName('home_tex')
# self.home_tex.resize(self.xr * 34, self.yr * 413)
# self.home_tex.move(self.xr * 610, self.yr * 152)
# self.home_tex.setText(change_vertical('常回家看看！'))
# self.home_tex.setStyleSheet('font-size:{}px;'.format(int(self.zr * 17)))
self.loading.setObjectName('load')
self.loading.resize(self.xr * 150, self.yr * 150)
self.loading.move(self.xr * 760, self.yr * 500)
self.loading.setScaledContents(True)
self.loading.setMovie(self.gif)
self.gif.start()
def auto_press(self):
res = play(self.token)
if res["status"] == 0:
self.auto_pressed_sg.emit(res)
def home_press(self):
self.home_pressed_sg.emit()
def search_press(self):
self.search_pressed_sg.emit()
def get_token(self, t):
self.token = t
class Register(QWidget):
register_ok_sg = pyqtSignal()
def __init__(self, parent=None):
super(Register, self).__init__(parent)
self.desktop = QApplication.desktop()
self.screenRect = self.desktop.screenGeometry()
self.h = self.screenRect.height()
self.w = self.screenRect.width()
self.xr = self.w / 930
self.yr = self.h / 640
self.zr = min(self.xr, self.yr)
self.top_wi = QWidget(self)
self.logo_la = QLabel(self.top_wi)
self.ind_wi = QWidget(self)
self.register_but = QPushButton(self.ind_wi)
self.imp_la = QLabel(self.ind_wi)
self.account_le = QLineEdit(self.ind_wi)
self.psw_le = QLineEdit(self.ind_wi)
self.name_le = QLineEdit(self.ind_wi)
self.set_ui()
with open('index.qss', 'r') as f:
self.setStyleSheet(f.read())
def set_ui(self):
self.setWindowTitle('Register')
self.setObjectName('register')
self.resize(self.w, self.h)
self.top_wi.setObjectName('top')
self.top_wi.resize(930 * self.xr, 95 * self.yr)
self.logo_la.setObjectName('logo')
self.logo_la.resize(65 * self.xr, 65 * self.zr)
self.logo_la.move(29 * self.xr, 16 * self.yr)
effect = QGraphicsDropShadowEffect()
effect.setOffset(10, 10)
effect.setColor(QColor(0, 0, 0, 80))
effect.setBlurRadius(20)
self.ind_wi.setObjectName('login')
self.ind_wi.resize(327 * self.xr, 388 * self.yr)
self.ind_wi.move(300 * self.xr, 150 * self.yr)
self.ind_wi.setGraphicsEffect(effect)
self.register_but.setObjectName('button')
self.register_but.move(64 * self.xr, 315 * self.yr)
self.register_but.resize(202 * self.xr, 45 * self.yr)
self.register_but.setText('注册新用户')
self.register_but.clicked.connect(self.register)
self.imp_la.setObjectName('imp_label')
self.imp_la.resize(100 * self.zr, 100 * self.zr)
self.imp_la.move(115 * self.xr + 100 * (self.xr - self.zr) / 2,
15 * self.yr)
self.imp_la.setStyleSheet('border-radius:{}px;'.format(self.zr * 49))
self.account_le.setObjectName('input')
self.account_le.setTextMargins(20, 0, 0, 0)
self.account_le.resize(213 * self.xr, 45 * self.yr)
self.account_le.move(59 * self.xr, 126 * self.yr)
self.account_le.setPlaceholderText('账号')
self.psw_le.setObjectName('input')
self.psw_le.setTextMargins(20, 0, 0, 0)
self.psw_le.resize(213 * self.xr, 45 * self.yr)
self.psw_le.move(59 * self.xr, 181 * self.yr)
self.psw_le.setPlaceholderText('密码')
self.psw_le.setEchoMode(QLineEdit.Password)
self.name_le.setObjectName('input')
self.name_le.setTextMargins(20, 0, 0, 0)
self.name_le.resize(213 * self.xr, 45 * self.yr)
self.name_le.move(59 * self.xr, 236 * self.yr)
self.name_le.setPlaceholderText('昵称')
self.ind_wi.setStyleSheet('#input{border-radius:' + str(self.zr * 20) +
'px;}' + '#button{border-radius:' +
str(self.zr * 20) + 'px;' + 'font-size:' +
str(int(self.zr * 18)) + 'px;}')
def register(self):
account_p = self.account_le.text()
psw_p = self.psw_le.text()
# name_p = self.name_le.text()
dic = register(account_p, psw_p)
if dic['status'] == 1001:
self.account_le.clear()
self.psw_le.clear()
self.account_le.setStyleSheet('border:4px solid;border-color:red;')
self.account_le.setPlaceholderText('账号已存在')
elif dic['status'] == 0:
self.register_ok_sg.emit()
else:
self.account_le.clear()
self.psw_le.clear()
self.account_le.setStyleSheet('border:4px solid;border-color:red;')
self.account_le.setPlaceholderText('未知错误')
class MainGame(QWidget):
"'it` a game class"''
def __init__(self,debug,playersNum):
super().__init__()
self.debug = debug
self.camera = cv2.VideoCapture(id)
try:
while True:
done = self.connect2Robot()
if type(done)!='None':
break
except TimeoutException:
pass
if self.debug:
self.debug = debug
print('this is debug mode')
else:
print('all fine')
#self.robot = FakeRobot('ip',1)
dialog = fenInit.InitScreen(self.robot)
dialog.exec()
dialog = InitScreen.InitScreen(0,self.robot)
dialog.exec()
#print('tratatata',dialog.playersNum)
self.playersNum = dialog.playersNum
self.restartStatus = [True,True,True]
self.difficulties =dialog.plDifficult
self.aiDifficulties=dialog.aiDifficult
self.players = dialog.isPlayer
self.initDone = False
self.curPlayer = [0,1]
self.loopDone = [True,True,True]
self.RobotMoveDone = [True,True,True]
self.GenerateMoveDone = [True,True,True,True]
self.playerPhotoStatus=[True,True,True]
self.InitUI(False)
self.CheckPermission = [False,False,False]
self.InitDraw()
def connect2Robot(self):
self.robot = urx.Robot("192.168.0.20", use_rt=True)
print(self.robot)
for i in range(7):
self.robot.set_digital_out(i, False)
return(self.robot)
# def ButtonLed(self, GenerateMoveDone, robot):
# if GenerateMoveDone[0]==True:
# self.robot.set_digital_out(dataStructers.led_flash, True)
#
# if self.robot.get_digital_in(0) == True:
#
# else:
# self.robot.set_digital_out(dataStructers.led_flash, False)
def InitUI(self,old):
if old==False:
self.buttonsPause=[]
self.buttonsPhoto=[]
self.buttonsReset=[]
self.buttonsStop=[]
self.playerNamesLabels = []
self.aiNamesLabels = []
self.chessboardDisplays = []
self.turn = ['w','w','w']
self.curTurn = []
self.logs = []
for i in range(self.playersNum):
self.playerNamesLabels.append(QLabel(self))
if self.players[i]==True:
self.playerNamesLabels[i].setText("Player \nPlayer "+str(i+1))
else:
self.playerNamesLabels[i].setText("Player \n Ai:"+str(self.aiDifficulties[i]))
self.playerNamesLabels[i].resize(80,40)
self.playerNamesLabels[i].move(4+500*i,0)
self.aiNamesLabels.append(QLabel(self))
self.aiNamesLabels[i].setText("Robot\n AI:"+ str(self.difficulties[i]))
self.aiNamesLabels[i].resize(80,40)
self.aiNamesLabels[i].move(4+500*i,55)
self.curTurn.append(QLabel('123',self))
if self.turn[i]=='w':
self.curTurn[i].setText('Current\n Turn:\n White')
else:
self.curTurn[i].setText('Current\n Turn:\n Black')
self.curTurn[i].resize(80,80)
self.curTurn[i].move(4+500*i,110)
self.buttonsPause.append(QPushButton('Pause',self))
self.buttonsReset.append(QPushButton('Restart',self))
self.buttonsPhoto.append(QPushButton('ReMake',self))
#self.buttonsStop.append(QPushButton('Stop',self))
#self.buttonsStop[i].clicked.connect(self.StopGame)
#self.buttonsStop[i].clicked.connect(self.StopGame)
self.buttonsPause[i].resize(150,40)
self.buttonsPause[i].move(80+500*i,540)
self.buttonsReset[i].resize(150,40)
self.buttonsReset[i].move(250+500*i,540)
self.buttonsPhoto[i].resize(40,40)
self.buttonsPhoto[i].move(420+500*i,540)
#self.buttonsStop[i].resize(150,40)
#self.buttonsStop[i].move(250+500*i,590)
self.logs.append(QTextEdit(self))
self.logs[i].setReadOnly(True)
self.logs[i].resize(400,100)
self.logs[i].move(55+500*i,420)
self.chessboardDisplays.append(QLabel(self))
self.chessboardDisplays[i].setPixmap(QPixmap("images/BoardBase.png"))
self.chessboardDisplays[i].resize(400,400)
self.chessboardDisplays[i].move(55+500*i,0)
self.buttonsChange = QPushButton('',self)
self.buttonsChange.setIcon(QIcon('images\settings.png'))
self.buttonsChange.resize(48,48)
self.buttonsChange.move(4,192)
self.buttonsChange.clicked.connect(self.ChangeSetting)
self.buttonsChange.show()
#button function
if self.playersNum == 1:
self.buttonsReset[0].clicked.connect(self.RestartOne)
self.buttonsPhoto[0].clicked.connect(self.CorrectBaseOne)
self.buttonsPause[0].clicked.connect(self.PauseOne)
if self.playersNum == 2:
self.buttonsReset[0].clicked.connect(self.RestartOne)
self.buttonsReset[1].clicked.connect(self.RestartTwo)
self.buttonsPhoto[0].clicked.connect(self.CorrectBaseOne)
self.buttonsPhoto[1].clicked.connect(self.CorrectBaseTwo)
self.buttonsPause[0].clicked.connect(self.PauseOne)
self.buttonsPause[1].clicked.connect(self.PauseTwo)
if self.playersNum == 3:
self.buttonsReset[0].clicked.connect(self.RestartOne)
self.buttonsReset[1].clicked.connect(self.RestartTwo)
self.buttonsReset[2].clicked.connect(self.RestartThree)
self.buttonsPhoto[0].clicked.connect(self.CorrectBaseOne)
self.buttonsPhoto[1].clicked.connect(self.CorrectBaseTwo)
self.buttonsPhoto[2].clicked.connect(self.CorrectBaseThree)
self.buttonsPause[0].clicked.connect(self.PauseOne)
self.buttonsPause[1].clicked.connect(self.PauseTwo)
self.buttonsPause[2].clicked.connect(self.PauseThree)
self.setWindowTitle('ChessGamer')
self.setGeometry(100, 100, 520*self.playersNum, 590)
self.setFixedSize(520*self.playersNum, 590)
self.show()
else:
sendButton = QPushButton("Send",self)
cancelButton = QPushButton('Exit',self)
cancelButton.clicked.connect(qApp.quit)
self.textBox = QTextEdit()
self.textBox.setReadOnly(True)
self.textEdit = QTextEdit()
self.pic = QLabel()
self.pic.setPixmap(QPixmap("images/BoardBase.png"))
self.pic.resize(350,350)
self.pic.show()
self.debugBoard =chess.Board()
if self.debug:
print('this is board in init: ',self.debugBoard)
sendButton.clicked.connect(self.DrawBoard)
vbox = QVBoxLayout()
hbox = QHBoxLayout()
hbox.addStretch(1)
vbox.addStretch(1)
hbox.addWidget(sendButton)
hbox.addWidget(cancelButton)
vbox.addWidget(self.pic)
vbox.addWidget(self.textBox)
vbox.addLayout(hbox)
self.setGeometry(500, 300, 300, 200)
self.setWindowTitle('ChessGamer')
self.setLayout(vbox)
self.show()
def ChangeSetting(self):
self.close()
self.__init__(False, 1)
self.GameLoop()
def InitDraw(self):
#gameboard picture
fontWhite = cv2.imread("images/white_square.png")
fontBlack = cv2.imread("images/brown_square.png")
boardPic = np.zeros((400,400,3),dtype=np.uint8)
tick =0
for x in range(8):
for y in range(8):
if x%2 == 0:
if tick %2==0:
boardPic[50*x:50+50*x,50*y:50+50*y] = fontWhite
else:
boardPic[50*x:50+50*x,50*y:50+50*y] = fontBlack
else:
if tick %2==0:
boardPic[50*x:50+50*x,50*y:50+50*y] = fontBlack
else:
boardPic[50*x:50+50*x,50*y:50+50*y] = fontWhite
tick += 1
if self.debug:
cv2.imshow("BoardPic",boardPic)
else:
cv2.imwrite("images/BoardBase.png",boardPic)
def DrawBoard(self,board,player):
if self.debug:
print("im in drawBoardCall")
try:
board = self.debugBoard
except AttributeError:
pass
stringBoard=Board2String(board)
boardPic = DrawBoardPic(stringBoard, self.debug)
tmpImagename = "images/tmp"+str(player)+".png"
cv2.imwrite(tmpImagename,boardPic)
self.chessboardDisplays[player-1].setPixmap(QPixmap(tmpImagename))
self.chessboardDisplays[player-1].show()
def DrawGui(self):
if self.playersNum ==1:
self.chessboardDisplays[0].setPixmap(QPixmap('images/tmp0.png'))
self.chessboardDisplays[0].show()
if self.playersNum ==2:
self.chessboardDisplays[0].setPixmap(QPixmap('images/tmp0.png'))
self.chessboardDisplays[0].show()
self.chessboardDisplays[1].setPixmap(QPixmap('images/tmp1.png'))
self.chessboardDisplays[1].show()
if self.playersNum ==3:
self.chessboardDisplays[0].setPixmap(QPixmap('images/tmp0.png'))
self.chessboardDisplays[0].show()
self.chessboardDisplays[1].setPixmap(QPixmap('images/tmp1.png'))
self.chessboardDisplays[1].show()
self.chessboardDisplays[2].setPixmap(QPixmap('images/tmp2.png'))
self.chessboardDisplays[2].show()
def Draw(self,board,player):
if player ==0:
self.garbage = 0
self.drawThread = DrawThread(board,player)
self.drawThread.finished.connect(self.DrawGui)
self.drawThread.start()
if player ==1:
self.garbage = 1
self.drawThread1 = DrawThread(board,player)
self.drawThread1.finished.connect(self.DrawGui)
self.drawThread1.start()
if player ==2:
self.garbage = 2
self.drawThread2 = DrawThread(board,player)
self.drawThread2.finished.connect(self.DrawGui)
self.drawThread2.start()
def GainDataFromThread(self,strData):
self.gainedData=strData
#print('this is data in main loop',strData)
def MoveDone(self,player):
self.RobotMoveDone[player]=True
self.GenerateMoveDone[player] = True
if self.playersNum>1:
if self.curPlayer[0]==0 and self.playersNum==2:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.playersNum==2:
self.curPlayer[0]=0
if self.playersNum==3:
if self.curPlayer[0]==0 and self.curPlayer[1]==1:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==1:
self.curPlayer[0]=2
self.curPlayer[1]=0
elif self.curPlayer[0]==2 and self.curPlayer[1]==0:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==0:
self.curPlayer[0]=0
self.curPlayer[1]=1
def RestartDone(self,player):
#print('Restart Done')
self.playerStatus[player][0] = chess.Board()
#print('2',self.playerStatus[player][0].fen())
self.RobotMoveDone[player] = True
self.GenerateMoveDone[player] = True
self.restartStatus[player]=False
self.playerStatus[player][4] = False
def PlayerCheckDone(self,data):
player = int(data[1])
if data[0]=='0':
'''
if first data symbol 0 then no turn done
'''
if self.curPlayer[0]==0:
self.robot.set_digital_out(dataStructers.OutButtonOne,True)
elif self.curPlayer[0]==1:
self.robot.set_digital_out(dataStructers.OutButtonTwo,True)
elif self.curPlayer[0]==2:
self.robot.set_digital_out(dataStructers.OutButtonThree,True)
if self.playersNum>1:
if self.curPlayer[0]==0 and self.playersNum==2:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.playersNum==2:
self.curPlayer[0]=0
if self.playersNum==3:
if self.curPlayer[0]==0 and self.curPlayer[1]==1:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==1:
self.curPlayer[0]=2
self.curPlayer[1]=0
elif self.curPlayer[0]==2 and self.curPlayer[1]==0:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==0:
self.curPlayer[0]=0
self.curPlayer[1]=1
self.GenerateMoveDone[player] = True
elif data[0]=='1':
'''
Player has made a move, need to push board
'''
self.robot.set_digital_out(dataStructers.led_red,False)
self.robot.set_digital_out(dataStructers.led_blue,False)
filename = 'player'+str(player)+'.txt'
file = open(filename,'w')
a = data[2:data.find('-')]
b = data[data.find('-')+1:len(data)]
uci = square2Uci(int(a)) +square2Uci(int(b))
move= chess.Move.from_uci(uci)
self.playerStatus[player][0].push(move)
file.write(self.playerStatus[player][0].fen())
file.close()
self.GenerateMoveDone[player] = True
elif data[0]=='2':
'''
something gone wrong and need to be corrected
'''
print('Something went wrong')
if self.curPlayer[0]==0:
self.robot.set_digital_out(dataStructers.OutButtonOne,True)
elif self.curPlayer[0]==1:
self.robot.set_digital_out(dataStructers.OutButtonTwo,True)
elif self.curPlayer[0]==2:
self.robot.set_digital_out(dataStructers.OutButtonThree,True)
if self.playersNum>1:
if self.curPlayer[0]==0 and self.playersNum==2:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.playersNum==2:
self.curPlayer[0]=0
if self.playersNum==3:
if self.curPlayer[0]==0 and self.curPlayer[1]==1:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==1:
self.curPlayer[0]=2
self.curPlayer[1]=0
elif self.curPlayer[0]==2 and self.curPlayer[1]==0:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==0:
self.curPlayer[0]=0
self.curPlayer[1]=1
self.GenerateMoveDone[player] = True
def LoopThreadDone(self):
currentPlayer = self.curPlayer[0]
self.robot.set_digital_out(dataStructers.led_red,False)
self.robot.set_digital_out(dataStructers.led_blue,False)
#self.CheckPermission[currentPlayer]=False
if self.RobotMoveDone[currentPlayer]:
prevBoard=self.playerStatus[currentPlayer][0].copy()
a = int(self.gainedData[0:self.gainedData.find("-")])
if self.gainedData.count("+")==1:
#c = self.gainedData[-1]
c = FindPosiblePromotion(self.playerStatus[self.curPlayer[0]][0],self.gainedData[-1])
b = int(self.gainedData[self.gainedData.find("-")+1:self.gainedData.find("+")])
uci = square2Uci(a)+square2Uci(b)+c
else:
c = ''
b = int(self.gainedData[self.gainedData.find("-")+1:len(self.gainedData)])
uci = square2Uci(a)+square2Uci(b)
move=chess.Move.from_uci(uci)
if prevBoard.is_castling(move):
castling = 1
else:
castling = 0
filename = 'player'+str(currentPlayer)+'.txt'
file = open(filename,'w')
self.playerStatus[self.curPlayer[0]][0].push(move)
file.write(self.playerStatus[self.curPlayer[0]][0].fen())
file.close()
boardWithMove = self.playerStatus[self.curPlayer[0]][0]
#
#print(boardWithMove.fen())
#
if self.playerStatus[currentPlayer][1]:
if self.playerStatus[currentPlayer][0].is_check():
self.robot.set_digital_out(dataStructers.led_red,True)
self.robot.set_digital_out(dataStructers.led_blue,True)
self.RobotMoveDone[currentPlayer]=False
if self.playerStatus[currentPlayer][1]==True:
robotMoveThread=RoboWorker(currentPlayer,[a,b,c],[prevBoard,boardWithMove],self.robot,castling,self.camera)
elif self.playerStatus[currentPlayer][1]==False:
castling+=3
robotMoveThread=RoboWorker(currentPlayer,[a,b,c],[prevBoard,boardWithMove],self.robot,castling,self.camera)
robotMoveThread.doneSignal.connect(self.MoveDone)
robotMoveThread.start()
if BoardTurn(prevBoard) =='w':
message = 'Player move: '+uci
self.logs[self.curPlayer[0]].setAlignment(QtCore.Qt.AlignLeft)
self.logs[self.curPlayer[0]].append(message)
else:
message = 'Robot move: '+uci
self.logs[self.curPlayer[0]].setAlignment(QtCore.Qt.AlignRight)
self.logs[self.curPlayer[0]].append(message)
self.Draw(self.playerStatus[currentPlayer][0],currentPlayer)
#self.GenerateMoveDone[player]= True
def Loop(self):
currentPlayer = self.curPlayer[0]
#self.Draw(self.playerStatus[currentPlayer][0],currentPlayer)
#print('Run gameloop')
#print('Current turn',BoardTurn(self.playerStatus[self.curPlayer[0]][0]))
if self.GenerateMoveDone[currentPlayer]:
'''
If move Generation from player or Ai is finished, than game may be continued
'''
if self.playerStatus[currentPlayer][0].is_game_over() ==True or self.playerStatus[currentPlayer][4] == True:
#print('Game is finished')
'''
If game is finished, then it must be restarted
'''
if self.playerStatus[currentPlayer][5]!=True:
self.logs[currentPlayer].append("Game over")
print('Restart Started')
self.GenerateMoveDone[currentPlayer] = False
endBoard = self.playerStatus[currentPlayer][0].copy()
if self.playerStatus[self.curPlayer[0]][1]:
restartThread = RoboWorker(currentPlayer,[0,0,''],[endBoard,0],self.robot,6,self.camera)
else:
restartThread = RoboWorker(currentPlayer,[0,0,''],[endBoard,0],self.robot,2,self.camera)
restartThread.restarSignal[int].connect(self.RestartDone)
#restartThread.restarSignal[int].connect(self.LoopThreadDone)
restartThread.start()
elif self.playerStatus[currentPlayer][0].is_game_over() ==False and self.playerStatus[currentPlayer][5]==False:
'''
If a game is not finished and not paused, then it needs to Get move from ai or from player
'''
if self.restartStatus[currentPlayer]==False:
'''
some help to restart game board CHECK IT!!!!!!!!!!!!
'''
self.playerStatus[currentPlayer][0]=chess.Board()
self.restartStatus[currentPlayer]=True
#print('1',self.playerStatus[currentPlayer][0].fen())
if BoardTurn(self.playerStatus[self.curPlayer[0]][0]) =='w':
#print("White Move")
self.curTurn[currentPlayer].setText('Current\n Turn:\n White')
if self.playerStatus[self.curPlayer[0]][1]:
'''
main human iteraction event
'''
#print('player Move')
while True:
file = open('status.txt','r')
self.CheckPermission = file.read()
file.close()
if len(self.CheckPermission)==3:
break
if self.CheckPermission[self.curPlayer[0]]=='1':
if self.curPlayer[0] ==0:
data = '0'+self.CheckPermission[1]+self.CheckPermission[2]
elif self.curPlayer[0] ==1:
data = self.CheckPermission[0]+'0'+self.CheckPermission[2]
elif self.curPlayer[0] ==2:
data = self.CheckPermission[0]+self.CheckPermission[1] +'0'
file = open('status.txt','w')
file.write(data)
file.close()
self.robot.set_digital_out(2+currentPlayer,False)
self.GenerateMoveDone[currentPlayer] = False
#print('1111111111111111111111111111')
checkPlayer = CheckBoard(self.curPlayer[0],self.playerStatus[currentPlayer][0],self.robot,self.camera,2)
checkPlayer.result[str].connect(self.PlayerCheckDone)
checkPlayer.start()
#print('222222222222222')
#self.CheckPermission[self.curPlayer[0]] = False
else:
if self.playersNum>1:
if self.curPlayer[0]==0 and self.playersNum==2:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.playersNum==2:
self.curPlayer[0]=0
if self.playersNum==3:
if self.curPlayer[0]==0 and self.curPlayer[1]==1:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==1:
self.curPlayer[0]=2
self.curPlayer[1]=0
elif self.curPlayer[0]==2 and self.curPlayer[1]==0:
self.curPlayer[0]=1
elif self.curPlayer[0]==1 and self.curPlayer[1]==0:
self.curPlayer[0]=0
self.curPlayer[1]=1
#wait for videosource
else:
self.GenerateMoveDone[currentPlayer] = False
print('Player is Ai making movement')
gameThread = GameLoop(self.playerStatus[currentPlayer][0],self.playerStatus[currentPlayer][2],self.engine,currentPlayer)
gameThread.dataSignal[str].connect(self.GainDataFromThread)
gameThread.doneSignal[int].connect(self.LoopThreadDone)
self.robot.set_digital_out(dataStructers.led_blue,True)
if gameThread.isFinished:
gameThread.start()
if BoardTurn(self.playerStatus[self.curPlayer[0]][0]) =='b':
#print('Black Move')
self.curTurn[currentPlayer].setText('Current\n Turn:\n Black')
self.GenerateMoveDone[currentPlayer] = False
self.robot.set_digital_out(2+currentPlayer,False)
#print(' Robot Move')
gameThread1 = GameLoop(self.playerStatus[currentPlayer][0],self.playerStatus[currentPlayer][3],self.engine,currentPlayer)
gameThread1.dataSignal[str].connect(self.GainDataFromThread)
gameThread1.doneSignal[int].connect(self.LoopThreadDone)
self.robot.set_digital_out(dataStructers.led_blue,True)
if gameThread1.isFinished:
gameThread1.start()
self.robot.set_digital_out(2+currentPlayer,False)
#
# if self.playersNum==1:
# self.curPlayer[0]=0
# if self.playersNum==2:
# pass
# if self.playersNum==3:
# pass
#self.Draw(self.playerStatus[currentPlayer][0],currentPlayer)
def CorrectBaseOne(self):
restartThread = CheckBoard(0,'',self.robot,self.camera,3)
self.robot.set_digital_out(dataStructers.OutButtonOne, True)
restartThread.start()
def CorrectBaseTwo(self):
restartThread = CheckBoard(1,'',self.robot,self.camera,3)
self.robot.set_digital_out(dataStructers.OutButtonTwo, True)
restartThread.start()
def CorrectBaseThree(self):
restartThread = CheckBoard(2,'',self.robot,self.camera,3)
self.robot.set_digital_out(dataStructers.OutButtonThree, True)
restartThread.start()
def StopGame(self,number):
print(number)
def initPhotoDone(self,data):
print(data)
print('Init Photo done')
self.GenerateMoveDone[self.curInt] = True
if self.curInt+1 ==self.playersNum:
self.initDone =True
if self.playerStatus[self.curInt-1][1]:
self.robot.set_digital_out(2+self.curInt-1,True)
else:
self.robot.set_digital_out(2+self.curInt-1,False)
self.curInt+=1
def RestartOne(self):
#self.playerStatus[0][0] = chess.Board()
self.playerStatus[0][4] = True
self.isdone=False
# t =
self.logs[0].append("Restart\n")
self.Speaker("Перезапуск первого стола")
def RestartTwo(self):
#self.playerStatus[1][0] = chess.Board()
self.playerStatus[1][4] = True
self.logs[1].append("Restart\n")
self.Speaker("Перезапуск второго стола")
def RestartThree(self):
#self.playerStatus[2][0] = chess.Board()
self.playerStatus[2][4] = True
self.timer.start(0)
self.logs[2].append("Restart\n")
self.Speaker("Перезапуск третьего стола")
def PauseOne(self):
if self.playerStatus[0][5]==False:
self.playerStatus[0][5]=True
self.buttonsPause[0].setText('Unpause')
self.logs[0].append("Pause\n")
self.Speaker("Поставлена пауза на первом игроке")
elif self.playerStatus[0][5]==True:
self.playerStatus[0][5]=False
self.buttonsPause[0].setText('Pause')
self.logs[0].append("Pause\n")
self.Speaker("Игрок один Игра продолжается")
def PauseTwo(self):
if self.playerStatus[1][5]==False:
self.playerStatus[1][5]=True
self.buttonsPause[1].setText('Unpause')
self.logs[1].append("Pause\n")
self.Speaker("Поставлена пауза на втором игроке")
elif self.playerStatus[1][5]==True:
self.playerStatus[1][5]=False
self.buttonsPause[1].setText('Pause')
self.logs[1].append("Pause\n")
self.Speaker("Игрок два Игра продолжается")
def PauseThree(self):
if self.playerStatus[2][5]==False:
self.playerStatus[2][5]=True
self.buttonsPause[2].setText('Unpause')
self.logs[2].append("Pause\n")
self.Speaker("Поставлена пауза на третьем игроке")
elif self.playerStatus[2][5]==True:
self.playerStatus[2][5]=False
self.buttonsPause[2].setText('Pause')
self.logs[2].append("Pause\n")
self.Speaker("Игрок Три Игра продолжается")
def Speaker(self, text):
speaker = win32com.client.Dispatch("SAPI.SpVoice")
speaker.Speak(text)
def InitPhoto(self):
if self.initDone or self.playerStatus[self.curInt][1]==0:
self.Loop()
#print('init done')
elif self.initDone ==False and self.GenerateMoveDone[self.curInt]:
makeFirstPhotoEvent = CheckBoard(self.curInt,self.playerStatus[self.curInt][0],self.robot,self.camera,1)
makeFirstPhotoEvent.result[str].connect(self.initPhotoDone)
makeFirstPhotoEvent.start()
def ButtonPushed(self,player):
pass
#self.CheckPermission[player]=True
def checkButtons(self):
pass
# print ('lets check button in game.py')
# if self.robot.get_digital_in(dataStructers.InButtonOne) == True:
# print ('Button for player one')
# self.CheckPermission[0]=True
# elif self.robot.get_digital_in(dataStructers.InButtonTwo) == True:
# print ('button for player two')
# self.CheckPermission[1]=True
# elif self.robot.get_digital_in(dataStructers.InButtonThree) == True:
# print ('button for player three')
# self.CheckPermission[2]=True
#def EmitSignal(self,event,signal, value):
# buttonCheckEvent = event
# if value == int:
# buttonCheckEvent.doneSignal[int].connect(signal)
# elif value == str:
# buttonCheckEvent.doneSignal[str].connect(signal)
# buttonCheckEvent.start()
def GameLoop(self):
self.playerStatus =[]
self.engine = ChessEngine(False)
boards = []
#ButtonCheckEvent = ButtonCheck(self.robot)
#ButtonCheckEvent.doneSignal[int].connect(self.ButtonPushed)
#ButtonCheckEvent.start()
#EmitSignal(ButtonCheck(self.robot),ButtonPushed, int)
for i in range(3):
'''
playerStatus[i][j]
i = player from 1 to 3
j = 0-Current board
j = 1 player Type: Ai or a human (true or 1 for human)
j = 2 difficalty for robot ai
j = 3 difficluty for player AI
j = 4 gameOver status (True or false)
j = 5 pause
'''
try:
filename = 'player'+str(i)+'.txt'
file = open(filename,'r')
fen = file.read()
except FileNotFoundError:
fen='rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'
self.playerStatus.append([chess.Board(fen),self.players[i],self.difficulties[i],self.aiDifficulties[i],False,False])
boards.append(chess.Board())
self.Draw(self.playerStatus[i][0],i)
self.curInt = 0
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.InitPhoto)
self.timer.setInterval(300)
self.timer.start(1)
self.timer2 = QtCore.QTimer()
self.timer2.timeout.connect(self.checkButtons)
self.timer2.setInterval(300)
self.timer2.start(1)
class FrameList(QWidget):
BUTTON_WIDTH = 240
BUTTON_HEIGHT = 40
MARGIN_TOP = 20
BUTTON_GAP = 5
MAX_LENGTH = 10
ICON_SIZE = 25
EVENT_SHIFT_X = 845
def __init__(self, parent):
super().__init__(parent)
self.resize(FrameList.BUTTON_WIDTH, FrameList.BUTTON_HEIGHT*(FrameList.MAX_LENGTH+2) + FrameList.MARGIN_TOP)
self.initUI()
def initUI(self):
self.buttons = FrameMap()
self.button_style_passive = """
.QPushButton {
font-weight: bold;
font-size: 20px;
background-color:#D3D3D3;
border: 1px solid black;
}
"""
self.button_style_active = """
.QPushButton {
font-weight: bold;
font-size: 20px;
background-color:#B4B4B4;
border: 2px solid black;
}
"""
""" These are the buttons to control list of names scrolling. start_index is the index which points to the
first entry in the button list which is currently shown at the top of the visual list. """
scroll_button_style = """
.QPushButton {
font-weight: bold;
font-size: 20px;
background-color:#D3D3D3;
}
.QPushButton:pressed {
background-color:#B4B4B4;
}
"""
self.scroll_up_button = QPushButton("", self)
self.scroll_up_button.setIcon(assets.up)
self.scroll_up_button.setIconSize(QSize(FrameList.ICON_SIZE*2, FrameList.ICON_SIZE))
self.scroll_up_button.resize(FrameList.BUTTON_WIDTH/2, FrameList.BUTTON_HEIGHT)
self.scroll_up_button.move(0, FrameList.BUTTON_HEIGHT*(FrameList.MAX_LENGTH+1) + FrameList.MARGIN_TOP)
self.scroll_up_button.setStyleSheet(scroll_button_style)
self.scroll_up_button.clicked.connect(self.scrollListUp)
self.scroll_up_button.hide()
self.scroll_down_button = QPushButton("", self)
self.scroll_down_button.setIcon(assets.down)
self.scroll_down_button.setIconSize(QSize(FrameList.ICON_SIZE*2, FrameList.ICON_SIZE))
self.scroll_down_button.resize(FrameList.BUTTON_WIDTH/2, FrameList.BUTTON_HEIGHT)
self.scroll_down_button.move(FrameList.BUTTON_WIDTH/2, FrameList.BUTTON_HEIGHT*(FrameList.MAX_LENGTH+1) + FrameList.MARGIN_TOP)
self.scroll_down_button.setStyleSheet(scroll_button_style)
self.scroll_down_button.clicked.connect(self.scrollListDown)
self.scroll_down_button.hide()
self.start_index = 0
""" Methods for changing the frames on the FrameList """
def addNewFrame(self, frame):
button = QPushButton("", self)
button.resize(FrameList.BUTTON_WIDTH, FrameList.BUTTON_HEIGHT)
button.clicked.connect(self.onMousePressed)
button.show()
self.buttons[button] = frame
if len(self.buttons) > FrameList.MAX_LENGTH:
self.start_index = len(self.buttons) - FrameList.MAX_LENGTH
self.rearrangeButtons()
def deleteFrame(self, caller):
if not self.buttons.active == None:
response = QMessageBox.question(caller, 'Frame Remove Message', "Are you sure you want to delete this frame?", QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
if response == QMessageBox.Yes:
self.buttons.active.setParent(None)
del self.buttons[self.buttons.active]
if self.start_index > 0:
self.start_index = self.start_index-1
self.parent().canvas.hideMessage()
self.rearrangeButtons()
def removeAllFrames(self):
self.buttons.active = None
for button in self.buttons.keys().copy():
button.setParent(None)
del self.buttons[button]
self.start_index = 0
self.rearrangeButtons()
def copyFrame(self):
if not self.buttons.active == None:
button = QPushButton("", self)
button.resize(FrameList.BUTTON_WIDTH, FrameList.BUTTON_HEIGHT)
button.clicked.connect(self.onMousePressed)
button.show()
index = self.buttons.index(self.buttons.active)
copy_frame = getWorld().getFrame()
copy_frame.time = self.buttons[self.buttons.active].time
self.buttons.insertAt(index+1, button, copy_frame)
if len(self.buttons) > FrameList.MAX_LENGTH:
self.start_index = self.start_index + 1
self.rearrangeButtons()
def changeFrameTime(self, time):
if not self.buttons.active == None:
self.buttons[self.buttons.active].time = time
self.rearrangeButtons()
""" Convenience methods for frame retrieval used by the animation player and some buttons """
def getActiveFrame(self):
if not self.buttons.active == None:
return (self.buttons.active, self.buttons[self.buttons.active])
else:
return None
def getFirstFrame(self):
first_button = self.buttons.first()
if not first_button == None:
return self.buttons[first_button]
else:
return None
def getNextFrame(self, frame):
return self.buttons.nextValue(frame)
def getAllFrames(self):
return self.buttons.frames
""" fixes button positions on the stickmen list after button addition or removal.
activates/deactivates buttons depending on which stickman is active.
In case there are more than 10 buttons, shows scrolling buttons. Controls which buttons are hidden and which are shown. """
def rearrangeButtons(self):
i = 0
for button in self.buttons.keys():
if i == 0:
button.setText("Frame " + str(i+1) + " : " + "0.0s")
else:
button.setText("Frame " + str(i+1) + " : " + str("%0.1f" % (self.buttons[button].time)) + "s") #makes up for removed frames, restoring the naming order
if i < self.start_index:
button.hide()
elif i > (self.start_index + FrameList.MAX_LENGTH - 1):
button.hide()
else:
button.show()
button.move(0, (i-self.start_index)*(FrameList.BUTTON_HEIGHT + FrameList.BUTTON_GAP))
if button == self.buttons.active:
button.setStyleSheet(self.button_style_active)
else:
button.setStyleSheet(self.button_style_passive)
i = i+1
#part which whows or hides up-down scroll buttons
if len(self.buttons) > FrameList.MAX_LENGTH:
self.scroll_up_button.show()
self.scroll_down_button.show()
else:
self.scroll_up_button.hide()
self.scroll_down_button.hide()
self.parent().tools.animation_tools.showButtonBlock()
def scrollListUp(self):
if self.start_index > 0:
self.start_index = self.start_index - 1
self.rearrangeButtons()
def scrollListDown(self):
if self.start_index < len(self.buttons)-FrameList.MAX_LENGTH:
self.start_index = self.start_index + 1
self.rearrangeButtons()
""" listener method used to switch between currently present frames """
def onMousePressed(self):
#sets the world to a copy of the current contents, preserving frame from future changes
if self.sender() == self.buttons.active:
self.buttons.active = None
getWorld().copyWorld()
self.parent().canvas.hideMessage()
#sets the world to the current frame contents
else:
open_frame = self.buttons[self.sender()]
getWorld().setWorldFrom(open_frame)
self.buttons.active = self.sender()
self.parent().canvas.showMessage()
self.rearrangeButtons()
""" these listeners are required to pass mouse events to the canvas in case there are any, making this list transparent as a result """
def mousePressEvent(self, event):
getWorld().mousePressed(event.x() + FrameList.EVENT_SHIFT_X, event.y() + FrameList.MARGIN_TOP)
def mouseReleaseEvent(self, event):
getWorld().mouseReleased(event.x() + FrameList.EVENT_SHIFT_X, event.y() + FrameList.MARGIN_TOP)
def mouseMoveEvent(self, event):
getWorld().mouseMoved(event.x() + FrameList.EVENT_SHIFT_X, event.y() + FrameList.MARGIN_TOP)
class Game(QWidget):
def __init__(self):
super().__init__()
self._flag_1 = False
self.media = QtCore.QUrl.fromLocalFile("MP3/music.mp3")
content = QtMultimedia.QMediaContent(self.media)
self.player = QtMultimedia.QMediaPlayer()
self.player.setMedia(content)
self.player.setVolume(50)
self.initUI()
def initUI(self):
self.file_number = 2
self._score = 0
self.setMouseTracking(True)
self.resize(500, 500)
self.center()
self.setWindowTitle('Игра')
self.main_pic = QLabel(self)
self.main_pic.setPixmap(
QPixmap(resource_path("PIC/running_rabbit.jpg")))
self.main_pic.resize(500, 500)
self.button_start_game = QPushButton("НАЧАТЬ ИГРУ", self)
self.button_start_game.resize(140, 50)
self.button_start_game.move(70, 300)
self.button_start_game.clicked.connect(self.start_game)
self.button_edit_map = QPushButton("СОЗДАТЬ КАРТУ", self)
self.button_edit_map.resize(140, 50)
self.button_edit_map.move(70, 360)
self.button_edit_map.clicked.connect(self.edit_map_menu)
self.button_exit = QPushButton("ЗАКОНЧИТЬ СЕАНС", self)
self.button_exit.resize(140, 50)
self.button_exit.move(70, 420)
self.button_exit.clicked.connect(self.exit)
self.timer_game = QTimer()
self.timer_game.timeout.connect(self.updateValues)
self.timer_game.start(200)
self.setFocusPolicy(Qt.StrongFocus)
self.lable_score = QLabel(self)
self.lable_score.resize(200, 35)
self.lable_score.setFont(
QFont("RetroComputer[RUS by Daymarius]", 26, QFont.Bold))
self.lable_score.setVisible(False)
self.button_menu = QPushButton("НАЗАД", self)
self.button_menu.resize(120, 40)
self.button_menu.clicked.connect(self.show_menu)
self.button_menu.setVisible(False)
self.lable_name = QLabel("ВВЕДИТЕ ВАШЕ ИМЯ:", self)
self.lable_name.sizeHint()
self.lable_name.setFont(
QFont("RetroComputer[RUS by Daymarius]", 10, QFont.Bold))
self.lable_name.move(230, 300)
self.input_name = QLineEdit("Без имени", self)
self.input_name.resize(200, 20)
self.input_name.move(230, 325)
self.table_score = QTableWidget(self)
self.table_score.resize(200, 120)
self.table_score.move(230, 350)
def bd_score(self):
con = sqlite3.connect(resource_path("DB/score.db"))
# Создание курсора
cur = con.cursor()
# Выполнение запроса и получение всех результатов
result = cur.execute(
"SELECT * FROM main ORDER BY score DESC;").fetchmany(5)
cur.execute("DROP TABLE main")
cur.execute("CREATE TABLE main (name STRING, score INTEGER)")
for item in result:
cur.execute("INSERT INTO main VALUES(?, ?)", (item[0], item[1]))
con.commit()
# Вывод результатов на экран
if result != []:
self.table_score.setColumnCount(len(result[0]))
self.table_score.setRowCount(0)
for i, row in enumerate(result):
self.table_score.setRowCount(self.table_score.rowCount() + 1)
for j, elem in enumerate(row):
item = QTableWidgetItem(str(elem))
self.table_score.setItem(i, j, item)
item.setFlags(QtCore.Qt.ItemIsEnabled)
self.table_score.setHorizontalHeaderItem(
0, QTableWidgetItem("Имя игрока"))
self.table_score.setHorizontalHeaderItem(1,
QTableWidgetItem("Счет"))
self.table_score.setColumnWidth(0, 127)
self.table_score.setColumnWidth(1, 20)
con.close()
def append_bd_score_and_name(self):
con = sqlite3.connect("DB/score.db")
# Создание курсора
cur = con.cursor()
cur.execute("INSERT INTO main VALUES(?, ?)",
(self.input_name.text(), self.get_score()))
con.commit()
self.bd_score()
con.close()
def get_score(self):
return self._score
def set_score(self, score):
self._score = score
def keyPressEvent(self, event):
if event.key() == Qt.Key_Right:
self.hero.go_right()
elif event.key() == Qt.Key_Left:
self.hero.go_left()
elif event.key() == Qt.Key_Up:
self.hero.go_up()
elif event.key() == Qt.Key_Down:
self.hero.go_down()
elif event.key() == Qt.Key_Space:
self.hero.go_dig()
def keyReleaseEvent(self, QKeyEvent):
if self._flag_1 and not QKeyEvent.isAutoRepeat():
self.hero.stop()
def edit_map_menu(self):
game.setVisible(False)
edit_map.create_map()
edit_map.show()
def exit(self):
sys.exit(app.exec())
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def reload_game(self):
score = self.get_score()
lifes = self.hero.get_lifes()
self.start_game()
self.set_score(score)
self.hero.set_lifes(lifes)
def start_game(self):
self.player.play()
self.set_score(0)
self.map = Map(resource_path("MAP/" + str(self.file_number) + ".map"))
for enemy in self.enemies:
enemy.create_labirint()
self.button_menu.setVisible(True)
self.button_menu.setFocusPolicy(False)
self.lable_score.setVisible(True)
self.lable_score.move(0, 0)
self.button_menu.move(self.map.get_col() * 40 - 120, 0)
self.lable_score.setText("00000")
sp_0_1 = []
for j in range(self.map.get_row()):
for i in range(self.map.get_col()):
if type(self.map.get_elem_xy(i, j)) == Empty and (
self.map.get_row() - 1 == j
or type(self.map.get_elem_xy(
i, j + 1)) in [Stairs, Brick]):
sp_0_1.append((i, j))
zerro = Zerro()
one = One()
for i in range(int(round(len(sp_0_1) * 0.2))):
t = randrange(0, len(sp_0_1))
x, y = sp_0_1[t]
self.map.set_elem_xy(x, y, choice([zerro, one]))
del sp_0_1[t]
self.hide_menu()
def show_menu(self):
self.append_bd_score_and_name()
game.player.pause()
self.hero.timer.stop()
for enemy in self.enemies:
enemy.timer.stop()
self.timer_game.stop()
self.main_pic.show()
self.table_score.show()
self.input_name.show()
self.lable_name.show()
self.button_menu.setVisible(False)
self.lable_score.setVisible(False)
self.button_edit_map.setVisible(True)
self.button_exit.setVisible(True)
self.button_start_game.setVisible(True)
self.resize(500, 500)
self.center()
self._flag_1 = False
def hide_menu(self):
game.player.play()
self.hero.timer.start(200)
for enemy in self.enemies:
enemy.timer.start(200)
game.timer_game.start(200)
self.main_pic.hide()
self.table_score.hide()
self.input_name.hide()
self.lable_name.hide()
self.button_menu.setVisible(True)
self.lable_score.setVisible(True)
self.button_edit_map.setVisible(False)
self.button_exit.setVisible(False)
self.button_start_game.setVisible(False)
self.resize(self.map.get_col() * 40, self.map.get_row() * 40 + 40)
self.center()
self._flag_1 = True
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
if self._flag_1:
for i in range(self.map.get_col()):
for j in range(self.map.get_row()):
qp.drawPixmap(
i * 40, j * 40 + 40,
self.map.get_elem_xy(
i, j).get_pic()) # рисуем картинками из elem_map
qp.drawPixmap(self.hero.get_x() * 40,
self.hero.get_y() * 40 + 40, self.hero.get_pic())
for enemy in self.enemies:
qp.drawPixmap(enemy.get_x() * 40,
enemy.get_y() * 40 + 40, enemy.get_pic())
for i in range(game.hero.get_lifes()):
qp.drawPixmap(280 + i * 40, 0,
self.hero._pic[self.hero._STOP][0])
txt = "00000" + str(self._score)
self.lable_score.setText(txt[len(txt) - 5:len(txt)])
qp.end()
def updateValues(self):
self.update()
def you_lose(self):
self.player.pause()
self.hero.timer.stop()
for enemy in self.enemies:
enemy.timer.stop()
self.timer_game.stop()
if self.hero.get_lifes() > 1:
game.player.pause()
buttonReply = QMessageBox.question(
self, 'ВЫ ПРОИГРАЛИ', "Продолжить игру?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
if buttonReply == QMessageBox.Yes:
self.hero.set_lifes(self.hero.get_lifes() - 1)
self.reload_game()
self.timer_game.start(200)
else:
self.set_score(0)
self.show_menu()
else:
game.player.pause()
buttonReply = QMessageBox.information(self, 'ИГРА ОКОНЧЕНА',
"Вы проиграли.")
self.append_bd_score_and_name()
self.show_menu()
class Search(QWidget):
search_sg = pyqtSignal(dict)
back_sg = pyqtSignal()
def __init__(self, parent=None):
super(Search, self).__init__(parent)
self.desktop = QApplication.desktop()
self.screenRect = self.desktop.screenGeometry()
self.h = self.screenRect.height()
self.w = self.screenRect.width()
self.xr = self.w / 930
self.yr = self.h / 640
self.zr = min(self.xr, self.yr)
self.token = ''
self.head = QLabel(self)
self.search = QLineEdit(self)
self.butt = QPushButton(self)
self.but = QPushButton(self)
self.set_ui()
def set_ui(self):
self.search.setObjectName('search')
self.search.resize(self.xr * 520, self.yr * 40)
self.search.move(self.xr * 205, self.yr * 300)
self.search.setPlaceholderText('请输入战局ID')
self.search.setTextMargins(20, 0, 0, 0)
self.search.setStyleSheet('font-size:{}px;border-radius:{}px;'.format(int(self.zr * 16), self.zr * 15))
self.head.setObjectName('head')
self.head.resize(self.xr * 200, self.yr * 50)
self.head.move(self.xr * 360, self.yr * 240)
self.head.setText('搜索战局')
self.head.setAlignment(Qt.AlignCenter)
self.head.setStyleSheet('font-size:{}px;'.format(int(self.zr * 25)))
self.but.setObjectName('button')
self.but.resize(self.xr * 130, self.yr * 40)
self.but.move(self.xr * 480, self.yr * 380)
self.but.setText('返回')
self.but.clicked.connect(self.back_for)
self.butt.setObjectName('button')
self.butt.resize(self.xr * 130, self.yr * 40)
self.butt.move(self.xr * 320, self.yr * 380)
self.butt.setText('搜索')
self.butt.clicked.connect(self.search_for)
self.setStyleSheet('#button{font-size:' + str(int(self.zr * 18)) + 'px;border-radius:' + str(
self.zr * 15) + 'px;background-color:#333643;color:#ffffff;}#button:hover{background-color:#575B6E;}#button:pressed{background-color:#202129;}')
def search_for(self):
id_p = self.search.text()
self.search.clear()
dic = find_info(id_p, self.token)
# print(dic)
if dic['status'] == 0:
self.search_sg.emit(dic)
else:
self.search.setStyleSheet(
'font-size:{}px;border-radius:{}px;border:4px solid;border-color:red'.format(int(self.zr * 16),
self.zr * 15))
self.search.clear()
self.search.setPlaceholderText('ID不存在')
def back_for(self):
self.back_sg.emit()
def get_token(self, t):
self.token = t
class AnimationPlayer(QFrame):
STOPPED = 0
PLAYING = 1
PAUSED = 2
WIDTH = 260
def __init__(self, parent):
super().__init__(parent)
self.initUI()
def initUI(self):
self.resize(AnimationPlayer.WIDTH, AnimationToolsPanel.HEIGHT)
self.playing = AnimationPlayer.STOPPED
button_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
.QPushButton:pressed {
background-color:#CCCCCC;
}
"""
self.play_button = QPushButton('', self)
self.play_button.setIcon(assets.play)
self.play_button.setIconSize(QSize(AnimationToolsPanel.ICON_SIZE, AnimationToolsPanel.ICON_SIZE))
self.play_button.resize(AnimationToolsPanel.ICON_BUTTON_WIDTH, AnimationToolsPanel.HEIGHT)
self.play_button.move(0, 0)
self.play_button.setStyleSheet(button_stylesheet)
self.play_button.clicked.connect(self.onPlay)
self.play_button.show()
self.clock = Clock(self)
self.clock.move(AnimationToolsPanel.ICON_BUTTON_WIDTH, 0)
self.clock.task = self.updateAnimation
self.clock.hide()
self.stop_button = QPushButton('', self)
self.stop_button.setIcon(assets.stop)
self.stop_button.setIconSize(QSize(AnimationToolsPanel.ICON_SIZE, AnimationToolsPanel.ICON_SIZE))
self.stop_button.resize(AnimationToolsPanel.ICON_BUTTON_WIDTH, AnimationToolsPanel.HEIGHT)
self.stop_button.move(AnimationPlayer.WIDTH - AnimationToolsPanel.ICON_BUTTON_WIDTH, 0)
self.stop_button.setStyleSheet(button_stylesheet)
self.stop_button.clicked.connect(self.onStop)
self.stop_button.hide()
self.old_frame = None
self.current_frame = None
self.next_frame = None
self.steps = 0 #number of intermediate steps between two frames
self.step_counter = 0 #number of steps already taken for the interpolation
""" called when the play button is pressed """
def onPlay(self):
self.disable()
self.clock.show()
self.stop_button.show()
if self.playing == AnimationPlayer.STOPPED: #starting
self.play_button.setIcon(assets.pause)
self.playing = AnimationPlayer.PLAYING
self.play()
elif self.playing == AnimationPlayer.PAUSED:
self.play_button.setIcon(assets.pause)
self.playing = AnimationPlayer.PLAYING
self.clock.startClock()
else: #pausing
self.play_button.setIcon(assets.play)
self.playing = AnimationPlayer.PAUSED
self.clock.stopClock()
""" called when the stop button is pressed or the animation is over """
def onStop(self):
if not self.playing == AnimationPlayer.STOPPED:
self.enable()
self.play_button.setIcon(assets.play)
self.playing = AnimationPlayer.STOPPED
self.clock.stopClock()
self.clock.reset()
self.clock.hide()
self.stop_button.hide()
""" Methods which enable and disable screen controls while the animation plays """
def disable(self):
self.parent().parent().control_panel.setEnabled(False)
self.parent().parent().canvas.setEnabled(False)
self.parent().tools.framemenu.hide()
self.parent().hideAll()
def enable(self):
self.parent().parent().control_panel.setEnabled(True)
self.parent().parent().canvas.setEnabled(True)
self.parent().tools.framemenu.show()
self.parent().showAll()
""" Entry method for the animation """
def play(self):
if self.parent().tools.framemenu.getActiveFrame() == None:
self.next_frame = self.parent().tools.framemenu.getFirstFrame()
else:
self.next_frame = self.parent().tools.framemenu.getActiveFrame()[1]
if self.next_frame != None:
self.reloadFrames()
else:
self.onStop()
""" this method loads two frames between which it is required to interpolate.
It loads frames from the FrameList until there are no more pairs of frames """
def reloadFrames(self):
self.clock.stopClock()
self.old_frame = self.next_frame
self.current_frame = self.old_frame.copy()
getWorld().setWorldFrom(self.current_frame)
self.next_frame = self.parent().tools.framemenu.getNextFrame(self.old_frame)
if self.next_frame != None:
self.steps = (self.next_frame.time*1000)/Clock.TIMER_STEP
self.step_counter = 0
self.clock.startClock()
else:
self.onStop()
""" Methods used to perform the interpolation job as they are """
def updateAnimation(self):
if self.step_counter < self.steps:
self.step_counter = self.step_counter + 1
step_ratio = self.step_counter/self.steps
# interpolate all stickmen one by one
for stickman in self.old_frame.stickmen:
new_stickman = self.next_frame.getStickman(stickman.name)
# need to check the new stickman, because it can be removed in the next frame
if new_stickman != None:
self.interpolatePosition(stickman, new_stickman, step_ratio)
self.interpolateJoints(stickman, new_stickman, step_ratio)
else:
self.reloadFrames() # called when two frames have interpolated enough to swap the last approximation for the real next frame
""" Interpolates between the positions of stickman body """
def interpolatePosition(self, old_stickman, new_stickman, ratio):
x_difference = new_stickman.x - old_stickman.x
y_difference = new_stickman.y - old_stickman.y
current_x = x_difference*ratio
current_y = y_difference*ratio
modified_stickman = self.current_frame.getStickman(old_stickman.name)
modified_stickman.x = old_stickman.x + current_x
modified_stickman.y = old_stickman.y + current_y
""" Interpolates between the positions of stickman joints """
def interpolateJoints(self, old_stickman, new_stickman, ratio):
i = 0
while i < len(old_stickman.joints):
old_joint = old_stickman.joints[i]
new_joint = new_stickman.joints[i]
if (old_joint.attachment != None and new_joint.attachment != None):
# degree difference and its alternatives are used to calculate the shortes path in rotation between two points of stickman
degree_difference = new_joint.angle - old_joint.angle
degree_difference_alternative = (2*math.pi - old_joint.angle + new_joint.angle)
if abs(degree_difference) <= abs(degree_difference_alternative):
current_degree_change = degree_difference*ratio
else:
current_degree_change = degree_difference_alternative*ratio
modified_stickman = self.current_frame.getStickman(old_stickman.name)
degree_by = old_joint.angle + current_degree_change - modified_stickman.joints[i].angle
modified_stickman.joints[i].rotateBy(degree_by)
i = i + 1
class WorldToolsPanel(QFrame):
FRAME_WIDTH = 1
FRAME_MARGIN = 2
TOOLS_WIDTH = 600
TOOLS_HEIGHT = 30
INPUT_WIDTH = 585
BUTTON_WIDTH = 150
STICKMAN_X = 300
STICKMAN_Y = 100
STICKMAN_NAME_MAX_LENGTH = 15
def __init__(self, parent):
super().__init__(parent)
self.initUI()
def initUI(self):
self.setFrameStyle(QFrame.StyledPanel)
self.setLineWidth(WorldToolsPanel.FRAME_WIDTH)
self.resize(WorldToolsPanel.TOOLS_WIDTH + WorldToolsPanel.FRAME_MARGIN*2, WorldToolsPanel.TOOLS_HEIGHT + WorldToolsPanel.FRAME_MARGIN*2)
self.setFrameRect(QRect(0, 0, WorldToolsPanel.TOOLS_WIDTH + WorldToolsPanel.FRAME_MARGIN*2, WorldToolsPanel.TOOLS_HEIGHT + WorldToolsPanel.FRAME_MARGIN*2))
button_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
.QPushButton:pressed {
background-color:#CCCCCC;
}
"""
self.create_stickman = QPushButton('Create Stickman', self)
self.create_stickman.resize(WorldToolsPanel.BUTTON_WIDTH, WorldToolsPanel.TOOLS_HEIGHT)
self.create_stickman.move(WorldToolsPanel.FRAME_WIDTH*2, WorldToolsPanel.FRAME_MARGIN)
self.create_stickman.setStyleSheet(button_stylesheet)
self.create_stickman.clicked.connect(self.showCreateDialog)
self.create_stickman_input = InputLine(self)
self.create_stickman_input.setLabelText("Enter New StickName: ")
self.create_stickman_input.addOkListener(self.readCreateName)
self.create_stickman_input.addCancelListener(self.hideCreateDialog)
self.create_stickman_input.move(WorldToolsPanel.FRAME_MARGIN, WorldToolsPanel.FRAME_MARGIN)
self.create_stickman_input.hide()
self.delete_stickman = QPushButton('Delete Stickman', self)
self.delete_stickman.resize(WorldToolsPanel.BUTTON_WIDTH, WorldToolsPanel.TOOLS_HEIGHT)
self.delete_stickman.move(WorldToolsPanel.BUTTON_WIDTH + WorldToolsPanel.FRAME_MARGIN, WorldToolsPanel.FRAME_MARGIN)
self.delete_stickman.setStyleSheet(button_stylesheet)
self.delete_stickman.clicked.connect(self.showDeleteDialog)
self.delete_stickman_input = InputLine(self)
self.delete_stickman_input.setLabelText("Enter Name to Delete: ")
self.delete_stickman_input.addOkListener(self.readDeleteName)
self.delete_stickman_input.addCancelListener(self.hideDeleteDialog)
self.delete_stickman_input.move(WorldToolsPanel.FRAME_MARGIN, WorldToolsPanel.FRAME_MARGIN)
self.delete_stickman_input.hide()
self.change_background = QPushButton('Set Background', self)
self.change_background.resize(WorldToolsPanel.BUTTON_WIDTH, WorldToolsPanel.TOOLS_HEIGHT)
self.change_background.move(WorldToolsPanel.BUTTON_WIDTH*2 + WorldToolsPanel.FRAME_MARGIN, WorldToolsPanel.FRAME_MARGIN)
self.change_background.setStyleSheet(button_stylesheet)
self.change_background.clicked.connect(self.findBackground)
self.remove_background = QPushButton('Clear Background', self)
self.remove_background.resize(WorldToolsPanel.BUTTON_WIDTH, WorldToolsPanel.TOOLS_HEIGHT)
self.remove_background.move(WorldToolsPanel.BUTTON_WIDTH*3 + WorldToolsPanel.FRAME_MARGIN, WorldToolsPanel.FRAME_MARGIN)
self.remove_background.setStyleSheet(button_stylesheet)
self.remove_background.clicked.connect(self.clearBackground)
""" Methods which show and hide input lines and buttons. ALso methods for resizing the panel and its frame """
def showCreateDialog(self):
self.resizeForInput()
self.hideButtons()
self.create_stickman_input.setText("")
self.create_stickman_input.setErrorText("")
self.create_stickman_input.show()
def hideCreateDialog(self):
self.resizeForButtons()
self.create_stickman_input.hide()
self.showButtons()
def showDeleteDialog(self):
self.resizeForInput()
self.hideButtons()
self.delete_stickman_input.setText("")
self.delete_stickman_input.setErrorText("")
self.delete_stickman_input.show()
def hideDeleteDialog(self):
self.resizeForButtons()
self.delete_stickman_input.hide()
self.showButtons()
def hideButtons(self):
self.create_stickman.hide()
self.delete_stickman.hide()
self.change_background.hide()
self.remove_background.hide()
def showButtons(self):
self.create_stickman.show()
self.delete_stickman.show()
self.change_background.show()
self.remove_background.show()
def resizeForButtons(self):
self.resize(WorldToolsPanel.TOOLS_WIDTH + WorldToolsPanel.FRAME_MARGIN*2, WorldToolsPanel.TOOLS_HEIGHT + WorldToolsPanel.FRAME_MARGIN*2)
self.setFrameRect(QRect(0, 0, WorldToolsPanel.TOOLS_WIDTH + WorldToolsPanel.FRAME_MARGIN*2, WorldToolsPanel.TOOLS_HEIGHT + WorldToolsPanel.FRAME_MARGIN*2))
def resizeForInput(self):
self.resize(WorldToolsPanel.INPUT_WIDTH + WorldToolsPanel.FRAME_MARGIN*2 + InputLine.ERROR_WIDTH, WorldToolsPanel.TOOLS_HEIGHT + WorldToolsPanel.FRAME_MARGIN*2)
self.setFrameRect(QRect(0, 0, WorldToolsPanel.INPUT_WIDTH + WorldToolsPanel.FRAME_MARGIN*2, WorldToolsPanel.TOOLS_HEIGHT + WorldToolsPanel.FRAME_MARGIN*2))
""" listener for the file dialog method to open the file for the background"""
def findBackground(self):
file = QFileDialog.getOpenFileName(self, "Open Image", ".", "Image Files (*.png *.jpg)")
if file[0] != "":
getWorld().setBackground(file[0])
def clearBackground(self):
getWorld().clearBackground("#FFFFFF")
""" Listeners to take actions when ok button was pressed and input text has been read """
def readCreateName(self):
if self.create_stickman_input.getText() == "":
self.create_stickman_input.setErrorText("StickName cannot be empty!")
elif getWorld().exists(self.create_stickman_input.getText()):
self.create_stickman_input.setErrorText("This StickName is already taken!")
self.create_stickman_input.setText("")
elif len(self.create_stickman_input.getText()) > WorldToolsPanel.STICKMAN_NAME_MAX_LENGTH:
self.create_stickman_input.setErrorText("StickName is too long!")
self.create_stickman_input.setText("")
else:
getWorld().createStickman(self.create_stickman_input.getText(), WorldToolsPanel.STICKMAN_X, WorldToolsPanel.STICKMAN_Y)
self.hideCreateDialog()
def readDeleteName(self):
if self.delete_stickman_input.getText() == "":
self.delete_stickman_input.setErrorText("StickName cannot be empty!")
elif not getWorld().exists(self.delete_stickman_input.getText()):
self.delete_stickman_input.setErrorText("This StickName does not exist!")
self.delete_stickman_input.setText("")
else:
getWorld().removeStickman(self.delete_stickman_input.getText())
self.hideDeleteDialog()
class AnimationToolsPanel(QFrame):
WIDTH = 1100
HEIGHT = 45
FRAME_WIDTH = 1
FRAME_MARGIN = 2
ICON_SIZE = 35
ICON_BUTTON_WIDTH = 60
IO_BUTTON_WIDTH = 200
IO_BLOCK_START_X = 292
TIME_INPUT_X = 698
BUTTON_BLOCK_X = 918
def __init__(self, parent, tools):
super().__init__(parent)
self.tools = tools
self.initUI()
def initUI(self):
self.resize(AnimationToolsPanel.WIDTH, AnimationToolsPanel.HEIGHT + AnimationToolsPanel.FRAME_MARGIN*2)
self.setFrameStyle(QFrame.StyledPanel)
self.setLineWidth(AnimationToolsPanel.FRAME_WIDTH)
self.setFrameRect(QRect(290, 0, 404, 49))
button_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
.QPushButton:pressed {
background-color:#CCCCCC;
}
"""
self.save_animation = QPushButton('Save Animation', self)
self.save_animation.resize(AnimationToolsPanel.IO_BUTTON_WIDTH, AnimationToolsPanel.HEIGHT)
self.save_animation.move(AnimationToolsPanel.IO_BLOCK_START_X, AnimationToolsPanel.FRAME_MARGIN)
self.save_animation.setStyleSheet(button_stylesheet)
self.save_animation.clicked.connect(self.saveXML)
self.load_animation = QPushButton('Load Animation', self)
self.load_animation.resize(AnimationToolsPanel.IO_BUTTON_WIDTH, AnimationToolsPanel.HEIGHT)
self.load_animation.move(AnimationToolsPanel.IO_BLOCK_START_X + AnimationToolsPanel.IO_BUTTON_WIDTH, AnimationToolsPanel.FRAME_MARGIN)
self.load_animation.setStyleSheet(button_stylesheet)
self.load_animation.clicked.connect(self.fromXML)
self.player = AnimationPlayer(self)
self.player.move(0, AnimationToolsPanel.FRAME_MARGIN)
self.player.show()
self.time_input = TimeInputLine(self)
self.time_input.move(AnimationToolsPanel.TIME_INPUT_X, AnimationToolsPanel.FRAME_WIDTH)
self.time_input.addAcceptListener(self.onAcceptListener)
self.time_input.addCancelListener(self.onCancelListener)
self.time_input.hide()
self.time_button = QPushButton('', self)
self.time_button.setIcon(assets.time)
self.time_button.setIconSize(QSize(AnimationToolsPanel.ICON_SIZE, AnimationToolsPanel.ICON_SIZE))
self.time_button.resize(AnimationToolsPanel.ICON_BUTTON_WIDTH, AnimationToolsPanel.HEIGHT)
self.time_button.move(AnimationToolsPanel.BUTTON_BLOCK_X, AnimationToolsPanel.FRAME_MARGIN)
self.time_button.setStyleSheet(button_stylesheet)
self.time_button.clicked.connect(self.timeFrameListener)
self.time_button.show()
self.copy_button = QPushButton('', self)
self.copy_button.setIcon(assets.copy)
self.copy_button.setIconSize(QSize(AnimationToolsPanel.ICON_SIZE, AnimationToolsPanel.ICON_SIZE))
self.copy_button.resize(AnimationToolsPanel.ICON_BUTTON_WIDTH, AnimationToolsPanel.HEIGHT)
self.copy_button.move(AnimationToolsPanel.BUTTON_BLOCK_X + AnimationToolsPanel.ICON_BUTTON_WIDTH, AnimationToolsPanel.FRAME_MARGIN)
self.copy_button.setStyleSheet(button_stylesheet)
self.copy_button.clicked.connect(self.copyFrameListener)
self.copy_button.show()
self.delete_button = QPushButton('', self)
self.delete_button.setIcon(assets.delete)
self.delete_button.setIconSize(QSize(AnimationToolsPanel.ICON_SIZE, AnimationToolsPanel.ICON_SIZE))
self.delete_button.resize(AnimationToolsPanel.ICON_BUTTON_WIDTH, AnimationToolsPanel.HEIGHT)
self.delete_button.move(AnimationToolsPanel.BUTTON_BLOCK_X + AnimationToolsPanel.ICON_BUTTON_WIDTH*2, AnimationToolsPanel.FRAME_MARGIN)
self.delete_button.setStyleSheet(button_stylesheet)
self.delete_button.clicked.connect(self.deleteListener)
self.delete_button.show()
""" Methods to show/hide the input time and frame-control buttons """
def showButtonBlock(self):
self.delete_button.show()
self.time_button.show()
self.copy_button.show()
self.time_input.hide()
def showInputTime(self):
self.delete_button.hide()
self.time_button.hide()
self.copy_button.hide()
self.time_input.label.setText(self.tools.framemenu.getActiveFrame()[0].text().split(":")[0] + ":")
self.time_input.show()
def hideAll(self):
self.delete_button.hide()
self.time_button.hide()
self.copy_button.hide()
self.time_input.hide()
self.save_animation.hide()
self.load_animation.hide()
self.setFrameShape(QFrame.NoFrame)
def showAll(self):
self.showButtonBlock()
self.save_animation.show()
self.load_animation.show()
self.setFrameShape(QFrame.StyledPanel)
""" time change listeners, which are called by the TimeInput component """
def onCancelListener(self):
self.showButtonBlock()
def onAcceptListener(self):
time = self.time_input.spinbox.value()
self.tools.framemenu.changeFrameTime(time)
self.showButtonBlock()
""" Listeners for delete, copy and time buttons """
def deleteListener(self):
self.tools.framemenu.deleteFrame(self)
def copyFrameListener(self):
self.tools.framemenu.copyFrame()
def timeFrameListener(self):
active_frame = self.tools.framemenu.getActiveFrame()
if not active_frame == None:
self.showInputTime()
""" listeners for XML binding and parsing """
def saveXML(self):
if len(self.tools.framemenu.getAllFrames()) > 1:
result = QFileDialog.getSaveFileName(self, 'Choose the destination for the animation file!', '.', 'Animation File (*.armo)')
if result[0] != "":
XML().toXML(self.tools.framemenu.getAllFrames(), result[0])
else:
QMessageBox.information(self, "Stickman Message", "You need at least 2 frames to save the animation!")
def fromXML(self):
file = QFileDialog.getOpenFileName(self, "Load Animation", ".", "Animation Files (*.armo)")
if file[0] != "":
try:
frames = XML().fromXML(file[0])
self.tools.framemenu.removeAllFrames()
for frame in frames:
self.tools.framemenu.addNewFrame(frame)
if len(frames) > 0:
getWorld().setWorldFrom(frames[0])
except:
QMessageBox.information(self, "Stickman Message", "The animation file is not valid!")
class Home(QWidget):
home_exit_sg = pyqtSignal()
rank_sg = pyqtSignal(list)
single_rank_sg = pyqtSignal(list)
def __init__(self, parent=None):
super(Home, self).__init__(parent)
self.desktop = QApplication.desktop()
self.screenRect = self.desktop.screenGeometry()
self.h = self.screenRect.height()
self.w = self.screenRect.width()
self.xr = self.w / 930
self.yr = self.h / 640
self.zr = min(self.xr, self.yr)
self.id_p = 0
self.token = ''
self.vertical_img = QLabel(self)
self.role_data_wi = QWidget(self)
self.rankexit_but = QPushButton(self)
self.role_header = QLabel(self.role_data_wi)
self.role_name = QLabel(self.role_data_wi)
self.role_rank = QPushButton(self.role_data_wi)
self.ranking = QPushButton(self.role_data_wi)
self.role_details = QWidget(self.role_data_wi)
self.bigcard_la = QLabel(self.role_details)
self.bigcard_wi = QWidget(self.role_details)
self.rate_la = QLabel(self.role_details)
self.rate_wi = QLabel(self.role_details)
self.role_special = QLabel(self.bigcard_wi)
self.set_ui()
with open('home.qss', 'r') as f:
self.setStyleSheet(f.read())
def set_ui(self):
self.setWindowTitle('Home')
self.setObjectName('home')
self.resize(self.w, self.h)
effect = QGraphicsDropShadowEffect()
effect.setOffset(10, 10)
effect.setColor(QColor(0, 0, 0, 80))
effect.setBlurRadius(20)
self.vertical_img.setObjectName('vertical')
self.vertical_img.resize(self.xr * 205, self.yr * 534)
self.vertical_img.move(self.xr * 79, self.yr * 39)
self.role_data_wi.setObjectName('role_data_wi')
self.role_data_wi.resize(self.xr * 552, self.yr * 534)
self.role_data_wi.move(self.xr * 320, self.yr * 39)
self.role_data_wi.setGraphicsEffect(effect)
self.rankexit_but.setObjectName('resexit')
self.rankexit_but.resize(self.zr * 38, self.zr * 38)
self.rankexit_but.move(self.xr * 852, self.yr * 22)
self.rankexit_but.clicked.connect(self.home_exit)
self.rankexit_but.setStyleSheet('border-radius:{}px;'.format(self.zr *
18))
self.role_header.setObjectName('role_header')
self.role_header.resize(self.zr * 70, self.zr * 70)
self.role_header.move(self.xr * 38, self.yr * 10)
self.role_name.setObjectName('role_name')
self.role_name.resize(self.xr * 129, self.yr * 43)
self.role_name.move(self.xr * 129, self.yr * 21)
self.role_name.setStyleSheet('border-radius:{}px;'.format(self.zr *
18))
effect1 = QGraphicsDropShadowEffect()
effect1.setOffset(10, 10)
effect1.setColor(QColor(0, 0, 0, 80))
effect1.setBlurRadius(20)
effect2 = QGraphicsDropShadowEffect()
effect2.setOffset(10, 10)
effect2.setColor(QColor(0, 0, 0, 80))
effect2.setBlurRadius(20)
self.role_rank.setObjectName('button')
self.role_rank.resize(self.xr * 120, self.yr * 31)
self.role_rank.move(self.xr * 269, self.yr * 27)
self.role_rank.setText('个人战绩')
self.role_rank.setGraphicsEffect(effect1)
self.role_rank.clicked.connect(self.show_single_rank)
self.ranking.setObjectName('button')
self.ranking.resize(self.xr * 120, self.yr * 31)
self.ranking.move(self.xr * 399, self.yr * 27)
self.ranking.setText('排行榜')
self.ranking.setGraphicsEffect(effect2)
self.ranking.clicked.connect(self.show_rank)
self.role_details.setObjectName('role_details')
self.role_details.resize(self.xr * 500, self.yr * 435)
self.role_details.move(self.xr * 28, self.yr * 89)
self.bigcard_la.setObjectName('icon')
self.bigcard_la.resize(self.xr * 120, self.yr * 23)
self.bigcard_la.move(self.xr * 12, self.yr * 34)
self.bigcard_la.setText('最近大牌')
self.bigcard_la.setAlignment(Qt.AlignCenter)
self.bigcard_wi.setObjectName('bigcard')
self.bigcard_wi.resize(self.xr * 477, self.yr * 120)
self.bigcard_wi.move(self.xr * 12, self.yr * 84)
for i in range(1, 14):
if i >= 9:
xp = 330
t = 9
elif i >= 4:
xp = 190
t = 4
else:
xp = 90
t = 1
exec('self.role_card{}=QLabel(self.bigcard_wi)'.format(i))
exec('self.role_card{}.setObjectName("card")'.format(i))
exec('self.role_card{}.resize(self.xr*40,self.yr*60)'.format(i))
exec('self.role_card{}.move(self.xr*(xp+({}-t)*20),self.yr*26)'.
format(i, i))
self.role_special.setObjectName('role_special')
self.role_special.resize(self.xr * 65, self.yr * 32)
self.role_special.move(self.xr * 15, self.yr * 40)
self.rate_la.setObjectName('icon')
self.rate_la.resize(self.xr * 120, self.yr * 23)
self.rate_la.move(self.xr * 12, self.yr * 234)
self.rate_la.setText('近期趋势')
self.rate_la.setAlignment(Qt.AlignCenter)
self.rate_wi.setObjectName('rate')
self.rate_wi.resize(self.xr * 477, self.yr * 120)
self.rate_wi.move(self.xr * 12, self.yr * 284)
self.role_data_wi.setStyleSheet('#role_data_wi{border-radius:' +
str(self.zr * 20) +
'px;}#role_header{border-radius:' +
str(self.zr * 30) +
'px;}#button{border-radius:' +
str(self.zr * 15) + 'px;font-size:' +
str(int(self.zr * 15)) +
'px;}#icon{border-radius:' +
str(self.zr * 10) + 'px;font-size:' +
str(int(self.zr * 15)) + 'px;}')
def home_exit(self):
self.home_exit_sg.emit()
def show_rank(self):
res = rank()
if res['status'] == 0:
self.rank_sg.emit(res['details'])
def show_single_rank(self):
res = srank(self.id_p, self.token)
if res['status'] == 0:
self.single_rank_sg.emit(res['details'])
def get_id(self, s):
self.id_p = s
def get_token(self, t):
self.token = t
class StickmanList(QWidget):
MARGIN_TOP = 20
BUTTON_WIDTH = 240
BUTTON_HEIGHT = 40
BUTTON_GAP = 5
MAX_LENGTH = 10
ICON_SIZE = 25
EVENT_SHIFT_X = 845
def __init__(self, parent):
super().__init__(parent)
self.resize(StickmanList.BUTTON_WIDTH, StickmanList.BUTTON_HEIGHT*(StickmanList.MAX_LENGTH + 2) + StickmanList.MARGIN_TOP)
self.initUI()
def initUI(self):
self.buttons = list()
self.button_style_passive = """
.QPushButton {
font-weight: bold;
font-size: 20px;
background-color:#D3D3D3;
border: 1px solid black;
}
"""
self.button_style_active = """
.QPushButton {
font-weight: bold;
font-size: 20px;
background-color:#B4B4B4;
border: 2px solid black;
}
"""
getWorld().addListener(self.onStickmanListener)
""" These are the buttons to control list of names scrolling. start_index is the index which points to the
first entry in the button list which is currently shown at the top of the visual list. """
scroll_button_style = """
.QPushButton {
font-weight: bold;
font-size: 20px;
background-color:#D3D3D3;
}
.QPushButton:pressed {
background-color:#B4B4B4;
}
"""
self.scroll_up_button = QPushButton("", self)
self.scroll_up_button.setIcon(assets.up)
self.scroll_up_button.setIconSize(QSize(StickmanList.ICON_SIZE*2, StickmanList.ICON_SIZE))
self.scroll_up_button.resize(StickmanList.BUTTON_WIDTH/2, StickmanList.BUTTON_HEIGHT)
self.scroll_up_button.move(0, StickmanList.BUTTON_HEIGHT*(StickmanList.MAX_LENGTH + 1) + StickmanList.MARGIN_TOP)
self.scroll_up_button.setStyleSheet(scroll_button_style)
self.scroll_up_button.clicked.connect(self.scrollListUp)
self.scroll_up_button.hide()
self.scroll_down_button = QPushButton("", self)
self.scroll_down_button.setIcon(assets.down)
self.scroll_down_button.setIconSize(QSize(StickmanList.ICON_SIZE*2, StickmanList.ICON_SIZE))
self.scroll_down_button.resize(StickmanList.BUTTON_WIDTH/2, StickmanList.BUTTON_HEIGHT)
self.scroll_down_button.move(StickmanList.BUTTON_WIDTH/2, StickmanList.BUTTON_HEIGHT*(StickmanList.MAX_LENGTH + 1) + StickmanList.MARGIN_TOP)
self.scroll_down_button.setStyleSheet(scroll_button_style)
self.scroll_down_button.clicked.connect(self.scrollListDown)
self.scroll_down_button.hide()
self.start_index = 0 #required to track the first element in the list which is shown
""" fixes button positions on the stickmen list after button addition or removal.
activates/deactivates buttons depending on which stickman is active.
In case there are morre than 10 buttons, shows scrolling buttons. Controls which buttons are hidden and which are shown. """
def rearrangeButtons(self):
i = 0
for button in self.buttons:
if i < self.start_index:
button.hide()
elif i > (self.start_index + StickmanList.MAX_LENGTH - 1):
button.hide()
else:
button.show()
button.move(0, (i-self.start_index)*(StickmanList.BUTTON_HEIGHT + StickmanList.BUTTON_GAP))
if getWorld().isActive(button.text()):
button.setStyleSheet(self.button_style_active)
else:
button.setStyleSheet(self.button_style_passive)
i = i+1
if len(self.buttons) > StickmanList.MAX_LENGTH:
self.scroll_up_button.show()
self.scroll_down_button.show()
else:
self.scroll_up_button.hide()
self.scroll_down_button.hide()
def scrollListUp(self):
if self.start_index > 0:
self.start_index = self.start_index - 1
self.rearrangeButtons()
def scrollListDown(self):
if self.start_index < len(self.buttons) - StickmanList.MAX_LENGTH:
self.start_index = self.start_index + 1
self.rearrangeButtons()
""" listener method which create on-screen buttons with stickman names or remove them. It redraws buttons if active state changes. Called from the World class """
def onStickmanListener(self, name, operation):
if operation == World.ADD_EVENT:
button = QPushButton(name, self)
button.resize(StickmanList.BUTTON_WIDTH, StickmanList.BUTTON_HEIGHT)
button.clicked.connect(self.onMousePressed)
button.show()
self.buttons.insert(0, button)
self.start_index = 0
self.rearrangeButtons()
elif operation == World.REMOVE_EVENT:
for button in self.buttons:
if button.text() == name:
self.buttons.remove(button)
button.setParent(None)
if self.start_index > 0:
self.start_index = self.start_index - 1
self.rearrangeButtons()
elif operation == World.ACTIVE_EVENT:
self.rearrangeButtons()
""" listener method used to switch active states of stickmen """
def onMousePressed(self):
getWorld().setActive(self.sender().text())
""" these listeners are required to pass mouse events to the canvas in case there are any, making this list transparent as a result """
def mousePressEvent(self, event):
getWorld().mousePressed(event.x() + StickmanList.EVENT_SHIFT_X, event.y() + StickmanList.MARGIN_TOP)
def mouseReleaseEvent(self, event):
getWorld().mouseReleased(event.x() + StickmanList.EVENT_SHIFT_X, event.y() + StickmanList.MARGIN_TOP)
def mouseMoveEvent(self, event):
getWorld().mouseMoved(event.x() + StickmanList.EVENT_SHIFT_X, event.y() + StickmanList.MARGIN_TOP)
class Index(QWidget):
show_mainindex_sg = pyqtSignal(int, str)
show_register_sg = pyqtSignal()
def __init__(self, parent=None):
super(Index, self).__init__(parent)
self.desktop = QApplication.desktop()
self.screenRect = self.desktop.screenGeometry()
self.h = self.screenRect.height()
self.w = self.screenRect.width()
self.xr = self.w / 930
self.yr = self.h / 640
self.zr = min(self.xr, self.yr)
self.top_wi = QWidget(self)
self.logo_la = QLabel(self.top_wi)
self.ind_wi = QWidget(self)
self.login_but = QPushButton(self.ind_wi)
self.joke_but = QPushButton(self.ind_wi)
self.register_but = QPushButton(self.ind_wi)
self.imp_la = QLabel(self.ind_wi)
self.account_le = QLineEdit(self.ind_wi)
self.psw_le = QLineEdit(self.ind_wi)
self.loading = QLabel(self)
self.gif = QMovie('./resource/image/load.gif')
self.set_ui()
with open('index.qss', 'r') as f:
self.setStyleSheet(f.read())
def set_ui(self):
self.setWindowTitle('Login')
self.setObjectName('index')
self.resize(self.w, self.h)
self.top_wi.setObjectName('top')
self.top_wi.resize(930 * self.xr, 95 * self.yr)
self.logo_la.setObjectName('logo')
self.logo_la.resize(65 * self.xr, 65 * self.zr)
self.logo_la.move(29 * self.xr, 16 * self.yr)
effect = QGraphicsDropShadowEffect()
effect.setOffset(10, 10)
effect.setColor(QColor(0, 0, 0, 80))
effect.setBlurRadius(20)
self.ind_wi.setObjectName('login')
self.ind_wi.resize(327 * self.xr, 388 * self.yr)
self.ind_wi.move(300 * self.xr, 150 * self.yr)
self.ind_wi.setGraphicsEffect(effect)
self.joke_but.setObjectName('joke')
self.joke_but.resize(130 * self.xr, 30 * self.yr)
self.joke_but.move(76 * self.xr, 234 * self.yr)
self.joke_but.setFlat(True)
self.joke_but.setText('忘记密码？我也没办法')
self.login_but.setObjectName('button')
self.login_but.move(64 * self.xr, 260 * self.yr)
self.login_but.resize(202 * self.xr, 45 * self.yr)
self.login_but.setText('登陆')
self.login_but.clicked.connect(self.login)
self.register_but.setObjectName('button')
self.register_but.move(64 * self.xr, 315 * self.yr)
self.register_but.resize(202 * self.xr, 45 * self.yr)
self.register_but.setText('注册')
self.register_but.clicked.connect(self.show_register)
self.imp_la.setObjectName('imp_label')
self.imp_la.resize(100 * self.zr, 100 * self.zr)
self.imp_la.move(115 * self.xr + 100 * (self.xr - self.zr) / 2, 15 * self.yr)
self.imp_la.setStyleSheet('border-radius:{}px;'.format(self.zr * 49))
self.account_le.setObjectName('input')
self.account_le.setTextMargins(20, 0, 0, 0)
self.account_le.resize(213 * self.xr, 45 * self.yr)
self.account_le.move(59 * self.xr, 126 * self.yr)
self.account_le.setPlaceholderText('账号')
self.psw_le.setObjectName('input')
self.psw_le.setTextMargins(20, 0, 0, 0)
self.psw_le.resize(213 * self.xr, 45 * self.yr)
self.psw_le.move(59 * self.xr, 181 * self.yr)
self.psw_le.setPlaceholderText('密码')
self.psw_le.setEchoMode(QLineEdit.Password)
self.loading.setObjectName('load')
self.loading.resize(self.xr * 150, self.yr * 150)
self.loading.move(self.xr * 760, self.yr * 500)
self.loading.setScaledContents(True)
self.loading.setMovie(self.gif)
self.gif.start()
self.ind_wi.setStyleSheet('#input{border-radius:' + str(self.zr * 20) + 'px;}' + '#button{border-radius:' + str(
self.zr * 20) + 'px;' + 'font-size:' + str(int(self.zr * 18)) + 'px;}')
def login(self):
account_p = self.account_le.text()
psw_p = self.psw_le.text()
dic = login(account_p, psw_p)
if dic['status'] == 0:
self.show_mainindex_sg.emit(dic['data']['user_id'], dic['data']['token'])
elif dic['status'] == 1:
self.account_le.clear()
self.psw_le.clear()
self.account_le.setStyleSheet('border:4px solid;border-color:red;')
self.account_le.setPlaceholderText('网络超时')
else:
self.account_le.clear()
self.psw_le.clear()
self.account_le.setStyleSheet('border:4px solid;border-color:red;')
self.account_le.setPlaceholderText('账号不存在或密码错误')
def show_register(self):
self.show_register_sg.emit()
class StickmanToolsPanel(QFrame):
WIDTH = 1100
HEIGHT = 45
FRAME_SIZE_X = 180
FRAME_WIDTH = 1
FRAME_MARGIN = 2
ICON_SIZE = 35
ICON_BUTTON_WIDTH = 60
INPUT_TEXT_WIDTH = 300
INPUT_START_X = 213
SAY_BLOCK_X = 520
PHOTO_BUTTON_WIDTH = 240
PHOTO_BUTTON_X = 858
def __init__(self, parent, tools):
super().__init__(parent)
self.tools = tools
self.initUI()
def initUI(self):
self.resize(StickmanToolsPanel.WIDTH, StickmanToolsPanel.HEIGHT + StickmanToolsPanel.FRAME_MARGIN*2)
self.setFrameStyle(QFrame.StyledPanel)
self.setFrameRect(QRect(0, 0, StickmanToolsPanel.FRAME_SIZE_X + StickmanToolsPanel.FRAME_MARGIN*2, StickmanToolsPanel.HEIGHT + StickmanToolsPanel.FRAME_MARGIN*2))
self.setLineWidth(StickmanToolsPanel.FRAME_WIDTH)
component_stylesheet = """
.QPushButton {
font-weight: bold;
font-size: 13px;
background-color:#E0E0E0;
}
.QPushButton:pressed {
background-color:#CCCCCC;
}
.QLineEdit {
font-weight: bold;
font-size: 24px;
}
"""
self.smile_button = QPushButton('', self)
self.smile_button.setIcon(assets.smile)
self.smile_button.setIconSize(QSize(StickmanToolsPanel.ICON_SIZE, StickmanToolsPanel.ICON_SIZE))
self.smile_button.resize(StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.HEIGHT)
self.smile_button.move(StickmanToolsPanel.FRAME_MARGIN, StickmanToolsPanel.FRAME_MARGIN)
self.smile_button.setStyleSheet(component_stylesheet)
self.smile_button.clicked.connect(self.changeExpression)
self.smile_button.show()
self.sad_button = QPushButton('', self)
self.sad_button.setIcon(assets.sad)
self.sad_button.setIconSize(QSize(StickmanToolsPanel.ICON_SIZE, StickmanToolsPanel.ICON_SIZE))
self.sad_button.resize(StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.HEIGHT)
self.sad_button.move(StickmanToolsPanel.FRAME_MARGIN + StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.FRAME_MARGIN)
self.sad_button.setStyleSheet(component_stylesheet)
self.sad_button.clicked.connect(self.changeExpression)
self.sad_button.show()
self.confused_button = QPushButton('', self)
self.confused_button.setIcon(assets.confused)
self.confused_button.setIconSize(QSize(StickmanToolsPanel.ICON_SIZE, StickmanToolsPanel.ICON_SIZE))
self.confused_button.resize(StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.HEIGHT)
self.confused_button.move(StickmanToolsPanel.FRAME_MARGIN + StickmanToolsPanel.ICON_BUTTON_WIDTH*2, StickmanToolsPanel.FRAME_MARGIN)
self.confused_button.setStyleSheet(component_stylesheet)
self.confused_button.clicked.connect(self.changeExpression)
self.confused_button.show()
self.say_text = QLineEdit(self)
self.say_text.setStyleSheet(component_stylesheet)
self.say_text.resize(StickmanToolsPanel.INPUT_TEXT_WIDTH, StickmanToolsPanel.HEIGHT)
self.say_text.move(StickmanToolsPanel.FRAME_MARGIN + StickmanToolsPanel.INPUT_START_X, StickmanToolsPanel.FRAME_MARGIN)
self.say_left = QPushButton('', self)
self.say_left.setIcon(assets.say_left)
self.say_left.setIconSize(QSize(StickmanToolsPanel.ICON_SIZE, StickmanToolsPanel.ICON_SIZE))
self.say_left.resize(StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.HEIGHT)
self.say_left.move(StickmanToolsPanel.SAY_BLOCK_X, StickmanToolsPanel.FRAME_MARGIN)
self.say_left.setStyleSheet(component_stylesheet)
self.say_left.clicked.connect(self.sayLeft)
self.say_right = QPushButton('', self)
self.say_right.setIcon(assets.say_right)
self.say_right.setIconSize(QSize(StickmanToolsPanel.ICON_SIZE, StickmanToolsPanel.ICON_SIZE))
self.say_right.resize(StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.HEIGHT)
self.say_right.move(StickmanToolsPanel.SAY_BLOCK_X + StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.FRAME_MARGIN)
self.say_right.setStyleSheet(component_stylesheet)
self.say_right.clicked.connect(self.sayRight)
self.say_exit = QPushButton('', self)
self.say_exit.setIcon(assets.exit)
self.say_exit.setIconSize(QSize(StickmanToolsPanel.ICON_SIZE, StickmanToolsPanel.ICON_SIZE))
self.say_exit.resize(StickmanToolsPanel.ICON_BUTTON_WIDTH, StickmanToolsPanel.HEIGHT)
self.say_exit.move(StickmanToolsPanel.SAY_BLOCK_X + StickmanToolsPanel.ICON_BUTTON_WIDTH*2, StickmanToolsPanel.FRAME_MARGIN)
self.say_exit.setStyleSheet(component_stylesheet)
self.say_exit.clicked.connect(self.sayClear)
self.photo = QPushButton('', self)
self.photo.setIcon(assets.camera)
self.photo.setIconSize(QSize(StickmanToolsPanel.ICON_SIZE, StickmanToolsPanel.ICON_SIZE))
self.photo.resize(StickmanToolsPanel.PHOTO_BUTTON_WIDTH, StickmanToolsPanel.HEIGHT)
self.photo.move(StickmanToolsPanel.PHOTO_BUTTON_X, StickmanToolsPanel.FRAME_MARGIN)
self.photo.setStyleSheet(component_stylesheet)
self.photo.clicked.connect(self.makePhoto)
def sayLeft(self):
search = getWorld().getActive()
if search != None:
search.sayLeft(self.say_text.text())
self.say_text.setText("")
def sayRight(self):
search = getWorld().getActive()
if search != None:
search.sayRight(self.say_text.text())
self.say_text.setText("")
def sayClear(self):
search = getWorld().getActive()
if search != None:
search.sayRemove()
self.say_text.setText("")
def changeExpression(self):
search = getWorld().getActive()
if search != None:
if self.sender() == self.smile_button:
search.setHappy()
elif self.sender() == self.sad_button:
search.setSad()
else:
search.setConfused()
def makePhoto(self):
self.tools.framemenu.addNewFrame(getWorld().getFrame())
class SettingChildWin(QDialog):
height_ = 25
def __init__(self, *args, **kwargs):
super().__init__(*args)
self.allModeGroup = QButtonGroup(self)
self.npkModeGroup = QButtonGroup(self)
if "mainWin" in kwargs.keys():
self.mainWin = kwargs["mainWin"]
self.setObjectName("settingWin")
self.setUi()
self.npkModeBox()
self.allExtractBox()
self.checkBox()
self.saveDirSelectBtn()
self.img2DirBtn()
self.portBtn = self.testPortBtn()
self.inputPort()
self.hide()
def setUi(self):
self.setFixedSize(400, 220)
self.setWindowModality(Qt.ApplicationModal)
self.setWindowTitle("设置")
# 0
def npkModeBox(self):
label_ = QLabel(self)
label_.resize(self.width() // 3, 25)
label_.setText("NPK提取模式:")
label_.setAlignment(Qt.AlignCenter)
label_.setStyleSheet("font-size: 15px")
# 选项AB
npkYes = QRadioButton(self)
npkYes.resize(self.width() // 3, 25)
npkYes.move(self.width() // 3, 0)
npkYes.setText("提取")
npkNo = QRadioButton(self)
npkNo.resize(self.width() // 3, 25)
npkNo.move(self.width() // 3 * 2, 0)
npkNo.setText("不提取")
npkNo.setChecked(True)
def npkYesFunc():
if not self.mainWin.npkDict:
QMessageBox.warning(self, "未设置NPK词典", "未设置NPK词典将不能设置NPK提取",
QMessageBox.Yes, QMessageBox.Yes)
npkNo.setChecked(True)
return False
if not self.mainWin.img2Dir:
QMessageBox.warning(self, "未设置img2目录", "未设置img2目录将不能设置NPK提取",
QMessageBox.Yes, QMessageBox.Yes)
npkNo.setChecked(True)
return False
npkYes.clicked.connect(npkYesFunc)
def yes():
self.mainWin.npkMode = True
npkYes.toggled.connect(yes)
def no():
self.mainWin.npkMode = False
npkNo.toggled.connect(no)
self.npkModeGroup.setObjectName("npkExtractMode")
self.npkModeGroup.addButton(npkYes)
self.npkModeGroup.addButton(npkNo)
# 1
def allExtractBox(self):
label_ = QLabel(self)
label_.resize(self.width() // 3, 25)
label_.move(0, 25)
label_.setText("全部提取模式:")
label_.setAlignment(Qt.AlignCenter)
label_.setStyleSheet("font-size: 15px")
# 选项AB
allYes = QRadioButton(self)
allYes.resize(self.width() // 3, 25)
allYes.move(self.width() // 3, 25)
allYes.setText("全部提取")
allNo = QRadioButton(self)
allNo.resize(self.width() // 3, 25)
allNo.move(self.width() // 3 * 2, 25)
allNo.setText("单个提取")
allNo.setChecked(True)
self.allModeGroup.setObjectName("allExtractMode")
self.allModeGroup.addButton(allYes)
self.allModeGroup.addButton(allNo)
# def setImg2Dir(self):
# 2
def saveDirSelectBtn(self):
btn = QPushButton("保存文件夹", self)
btn.setObjectName("saveDirSelectBtn")
btn.resize(self.width() / 2, self.height_)
btn.move(0, self.height_ * 2)
# btn.setStyleSheet("background-color: pink")
def btnFunc():
saveDirFunc(self)
btn.clicked.connect(btnFunc)
def img2DirBtn(self):
btn = QPushButton("ImagePacks2文件夹", self)
btn.setObjectName("saveDirSelectBtn")
btn.resize(self.width() / 2, self.height_)
btn.move(self.width() / 2, self.height_ * 2)
# btn.setStyleSheet("background-color: pink")
def btnFunc():
if img2DirFunc(self) is False:
QMessageBox.warning(self, "img2文件夹选择错误", "文件夹下无NPK文件，请重新选择",
QMessageBox.Yes, QMessageBox.Yes)
btn.clicked.connect(btnFunc)
# 3
def testPortBtn(self):
portBtn = QPushButton("默认端口测试", self)
portBtn.setObjectName("testPortBtn")
portBtn.resize((self.width() - 30) / 2, self.height_)
portBtn.move(0, self.height_ * 3)
# portBtn.setEnabled(False)
def portBtnFunc():
testPortFunc(self)
portBtn.clicked.connect(portBtnFunc)
return portBtn
# 3
def inputPort(self):
self.checkPort = QPushButton("√", self)
self.checkPort.resize(30, self.height_)
self.checkPort.move(self.width() - 30, self.height_ * 3)
# self.checkPort.hide()
self.inputLine = QLineEdit("输入端口", self)
self.inputLine.resize((self.width() - 30) / 2, 25)
self.inputLine.move((self.width() - 30) / 2, 25 * 3)
# self.inputLine.hide()
def inputPortF():
self.mainWin.port = self.inputLine.text()
self.portBtn.click()
self.checkPort.clicked.connect(inputPortF)
def checkBox(self):
#
confirmBtn = QPushButton("确认", self)
confirmBtn.resize(self.width() // 2, 25)
confirmBtn.move(0, self.height() - 25)
confirmBtn.clicked.connect(self.hide)
#
cancelBtn = QPushButton("取消", self)
cancelBtn.resize(self.width() // 2, 25)
cancelBtn.move(self.width() // 2, self.height() - 25)
cancelBtn.clicked.connect(self.close)
def closeEvent(self, closeEvt):
reply = QMessageBox.question(self, "", "关闭后，设置将不会保存", QMessageBox.Yes,
QMessageBox.No)
if reply == QMessageBox.Yes:
for button in self.checkedList:
button.setChecked(True)
self.hide()
else:
closeEvt.ignore()
def showEvent(self, showEvt):
self.checkedList = [
group.checkedButton() for group in self.findChildren(QButtonGroup)
]
return super().showEvent(showEvt)
def create_widgets(self):
btn = QPushButton('Button', self)
btn.setToolTip('This is <b>QPushButton</b> widget')
btn.resize(btn.sizeHint())
btn.move(50, 50)
