def configEditButtonPressed(self):
print("Edit Config Dialogue")
print("index: ", self.configComboBox.currentIndex())
print("text: ", self.configComboBox.currentText())
configFileName = self.configComboBox.currentText()
configPath = os.path.join("Config", configFileName)
if os.path.isfile(configPath):
ConfigFile.loadConfig(configFileName)
configDialog = ConfigWindow(configFileName, self)
#configDialog = CalibrationEditWindow(configFileName, self)
configDialog.show()
else:
#print("Not a Config File: " + configFileName)
message = "Not a Config File: " + configFileName
QtWidgets.QMessageBox.critical(self, "Error", message)
def openConfigWindow(self):
if not hasattr(self, "w") or not self.w.isVisible():
self.w = ConfigWindow(self)
self.w.show()
self.w.raise_()
else:
self.w.activateWindow()
def __init__(self):
Config.load()
self.master = Tk()
self.master.title("Tetris")
self.master.configure(background='grey25')
# Fenêtre de configuration de touches
self.configWindow = ConfigWindow(self)
# --- HOLD CANVAS --- #
self.hold_canvas = Canvas(self.master, width= 2 * Config.PIXEL_SIZE, height= 2 * Config.PIXEL_SIZE, bg=Config.COLORS[0], bd=0, highlightthickness=0)
self.hold_canvas.pack(side='left', padx=10)
# --- MAIN CANVAS --- #
self.canvas = Canvas(self.master, width=Config.CANVAS_WIDTH, height=Config.CANVAS_HEIGHT, bg=Config.COLORS[0], bd=0, highlightthickness=0)
self.canvas.pack(side='left')
# --- CONFIGURE BINDS --- #
self.configure_bind = Button(self.master, text="Configurer les touches", command=self.open_bind_window)
self.configure_bind.pack(pady=5)
# ------ RESTART BOUTON ------ #
self.restart_button = Button(self.master, text="Redemarrer la partie", command=self.restart_game)
self.restart_button.pack()
# --- LEVEL --- #
self.level_var = StringVar()
self.level_label = Label(self.master, textvariable=self.level_var, bg='grey25', foreground='white', width=10)
self.level_label.pack(pady=(30, 10), padx=30)
# --- SCORE --- #
self.score_var = StringVar()
self.score_label = Label(self.master, textvariable=self.score_var, bg='white', width=10)
self.score_label.pack(pady=(10, 30), padx=30)
# --- NEXT TETRI --- #
self.next_tetri_canv = [Canvas(self.master, width= 2 * Config.PIXEL_SIZE, height= 2 * Config.PIXEL_SIZE, bg=Config.COLORS[0], bd=0, highlightthickness=0) for _ in range(5)]
for canv in self.next_tetri_canv:
canv.pack(pady=5, padx=5)
# --- SOUND --- #
self.sound()
def configure(self, item):
path = self.pathFromItem(item)
AppData.initConfigParams()
loadParents(path, self.rootPath)
configDialog = ConfigWindow(os.path.normpath(path))
configDialog.exec()
class Tetris:
def __init__(self):
Config.load()
self.master = Tk()
self.master.title("Tetris")
self.master.configure(background='grey25')
# Fenêtre de configuration de touches
self.configWindow = ConfigWindow(self)
# --- HOLD CANVAS --- #
self.hold_canvas = Canvas(self.master, width= 2 * Config.PIXEL_SIZE, height= 2 * Config.PIXEL_SIZE, bg=Config.COLORS[0], bd=0, highlightthickness=0)
self.hold_canvas.pack(side='left', padx=10)
# --- MAIN CANVAS --- #
self.canvas = Canvas(self.master, width=Config.CANVAS_WIDTH, height=Config.CANVAS_HEIGHT, bg=Config.COLORS[0], bd=0, highlightthickness=0)
self.canvas.pack(side='left')
# --- CONFIGURE BINDS --- #
self.configure_bind = Button(self.master, text="Configurer les touches", command=self.open_bind_window)
self.configure_bind.pack(pady=5)
# ------ RESTART BOUTON ------ #
self.restart_button = Button(self.master, text="Redemarrer la partie", command=self.restart_game)
self.restart_button.pack()
# --- LEVEL --- #
self.level_var = StringVar()
self.level_label = Label(self.master, textvariable=self.level_var, bg='grey25', foreground='white', width=10)
self.level_label.pack(pady=(30, 10), padx=30)
# --- SCORE --- #
self.score_var = StringVar()
self.score_label = Label(self.master, textvariable=self.score_var, bg='white', width=10)
self.score_label.pack(pady=(10, 30), padx=30)
# --- NEXT TETRI --- #
self.next_tetri_canv = [Canvas(self.master, width= 2 * Config.PIXEL_SIZE, height= 2 * Config.PIXEL_SIZE, bg=Config.COLORS[0], bd=0, highlightthickness=0) for _ in range(5)]
for canv in self.next_tetri_canv:
canv.pack(pady=5, padx=5)
# --- SOUND --- #
self.sound()
def sound(self):
pygame.init()
APP_FOLDER = os.path.dirname(os.path.realpath(sys.argv[0]))
full_path = os.path.join(APP_FOLDER, "SON")
self.music = pygame.mixer.Sound(os.path.join(full_path, "Music.wav"))
self.bruit = [pygame.mixer.Sound(os.path.join(full_path, "1_lines.wav")), pygame.mixer.Sound(os.path.join(full_path, "2_lines.wav")), pygame.mixer.Sound(os.path.join(full_path, "3_lines.wav")), pygame.mixer.Sound(os.path.join(full_path, "4_lines.wav"))]
def open_bind_window(self):
if not self.configWindow.is_open:
if self.playing:
self.pause()
configWindowMaster = Toplevel(self.master)
self.configWindow.open(configWindowMaster)
def start_game(self):
self.playing = True
self.music.play()
self.master.bind("<Key>", self.__controls)
self.master.bind("<KeyRelease>", self.__controls_released)
self.board = self.__create_board(Config.GRID_WIDTH, Config.GRID_HEIGHT)
self.message_queue = list()
self.message_up = False
self.message_timer = 0
self.predict = None
self.next_tetri = [Tetrimino((0, 0), self.next_tetri_canv[i], previsualization=True) for i in range(5)]
self.change_tetri()
self.soft_droping = False
self.spining = False
self.holded = False
self.hold_tetri = None
self.spin_count = 0
self.tetri_count = 0
self.speed = Config.SPEED
self.level = 0
self.level_var.set("Level : " + str(self.level))
self.score = 0
self.score_var.set(str(self.score))
self.turn = 0
self.__draw_grid()
self.update()
self.master.mainloop()
def update(self):
if self.playing:
self.canvas.tag_raise('message') # On met le message au dessus du reste
self.canvas.tag_lower('predict')
self.canvas.tag_lower('grid') # On met le grid en dessous du reste
self.turn = self.turn + 1 # Incrémentation du tour actuel
self.__update_message()
if not self.current_tetri.move((0,1)):
if not self.spining:
self.spining = True
self.spin_count = 1
else:
if self.spin_count > 0:
self.spin_count = self.spin_count - 1
elif self.spin_count == 0:
self.spining = False
if not self.next():
self.__stop_game()
return
self.master.after(self.speed, self.update)
def update_predict(self):
if self.predict:
self.canvas.delete('predict')
self.predict = Tetrimino(self.current_tetri.pos, self.canvas, form=self.current_tetri.form, predict=True, predictParent=self.current_tetri)
self.predict.go_down()
def next(self):
if self.holded:
self.holded = False
self.tetri_count = self.tetri_count + 1
if self.tetri_count % 15 == 0:
self.level = self.level + 1
self.speed = self.speed - 5
self.level_var.set("Level : " + str(self.level))
self.__update_board()
self.__complete_lines()
if(self.is_game_over()):
return False
self.change_tetri()
return True
def change_tetri(self):
for canv in self.next_tetri_canv:
canv.delete('all')
self.current_tetri = Tetrimino((4, -1), self.canvas, form=self.next_tetri[0].form)
self.update_predict()
for i in range(len(self.next_tetri) - 1):
self.next_tetri[i] = Tetrimino((0, 0), self.next_tetri_canv[i], form=self.next_tetri[i + 1].form, previsualization=True)
self.next_tetri[-1] = Tetrimino((0, 0), self.next_tetri_canv[-1], previsualization=True)
def is_game_over(self):
""" Verifie si un tetrimino est au point le plus haut, renvoie True si cest le cas"""
for box in self.canvas.find_withtag('tetri'):
_, y, _, _ = self.canvas.coords(box)
if y < 0:
return True
return False
def pause(self):
if self.playing:
pygame.mixer.pause()
self.playing = not self.playing
self.paused_message = self.canvas.create_text(0,0, text="PAUSE", anchor='nw', fill='red', tag='pause_message', font=("Helvetica", 26))
coords = self.canvas.bbox(self.paused_message)
xOffset = (Config.CANVAS_WIDTH / 2) - (coords[2] - coords[0]) / 2
yOffset = (Config.CANVAS_HEIGHT / 2) - (coords[3] - coords[1]) / 2
self.canvas.move(self.paused_message, xOffset, yOffset)
self.canvas.tag_raise('pause_message')
else:
pygame.mixer.unpause()
self.playing = not self.playing
self.canvas.delete(self.paused_message)
self.update()
def __stop_game(self):
pygame.mixer.stop()
self.playing = False
self.master.unbind("<Key>")
restart = self.lossmsgbox = askretrycancel("Perdu, gros nullos", "Voulez vous réessayer ?")
if restart:
self.restart_game()
return
def restart_game(self):
if not self.playing:
self.canvas.delete('all')
self.hold_canvas.delete('all')
for canv in self.next_tetri_canv:
canv.delete('all')
self.start_game()
else:
self.__system_message(text="La partie doit être en pause", timer=1000)
# /!\ A REVOIR /!\
def __update_board(self):
""" Parcours tout les tetriminos pour etablir une matrice de la grille de jeu avec des 0 et des 1 """
self.board = self.__create_board(Config.GRID_WIDTH, Config.GRID_HEIGHT)
for box in self.canvas.find_withtag('tetri'):
x, y, _,_ = self.canvas.coords(box)
x = int(x / Config.PIXEL_SIZE)
y = int(y / Config.PIXEL_SIZE)
try:
self.board[y][x] = 1
except IndexError:
return False
return True
def __create_board(self, width, height):
return [[0 for _ in range(width)] for _ in range(height)]
def __draw_grid(self):
for i in range(len(self.board)):
for j in range(len(self.board[0])):
self.canvas.create_rectangle(j * Config.PIXEL_SIZE, i * Config.PIXEL_SIZE, (j+1) * Config.PIXEL_SIZE, (i+1) * Config.PIXEL_SIZE, outline='gray10', tag='grid')
def __complete_lines(self):
""" Verifie chaque ligne du board pour trouver si une est complete, dans ce cas les lignes complete sont suprime"""
indexes = [i for i, x in enumerate(self.board) if sum(x) == Config.GRID_WIDTH] # Liste des index des lignes complete
completed_lines = len(indexes) # Le nombre de lignes complete (pour le score)
for k in indexes:
self.board[k] = [0 for _ in range(Config.GRID_WIDTH)]
# Suppresion de toute les cases de la ligne complete
for box in self.canvas.find_overlapping(0, k * Config.PIXEL_SIZE + 1, Config.GRID_WIDTH * Config.PIXEL_SIZE, (k+1) * Config.PIXEL_SIZE - 1):
if 'tetri' in self.canvas.gettags(box):
self.canvas.delete(box)
# Descente de une unite pour chaque bloc au dessus de la ligne complete
for box in self.canvas.find_overlapping(0, 0, Config.GRID_WIDTH * Config.PIXEL_SIZE, k * Config.PIXEL_SIZE - 1):
if 'tetri' in self.canvas.gettags(box):
self.canvas.move(box, 0, Config.PIXEL_SIZE)
if completed_lines > 0: # Si une ligne a ete complete on affiche un message et on update le score
self.__system_message(text=Config.COMPLETE_QUOTES[completed_lines - 1], timer=1500)
self.__score_calculation(completed_lines)
self.bruit[completed_lines - 1].play()
self.__update_board() # Refresh du board pour la suite
def __score_calculation(self, completed_lines):
""" Calcul et met a jour le score en prenant en compte le niveau et le nombre de lignes complete"""
multiplier = [40, 100, 300, 1200]
# Calcul pour n = le niveau : [multiplieur lie aux nombres de lignes complete] * (n + 1)
self.score = self.score + multiplier[completed_lines - 1] * (self.level + 1)
self.score_var.set(self.score)
# --- Gestion des evenements claviers --- #
def hold(self):
"""Permet de sauvegarder le tetrimino actuel pour l'echanger avec celui sauvegarder avant (passe au suivant si il n'y a pas eu de sauvegarde avant)"""
if not self.holded:
self.hold_canvas.delete('all')
self.holded = True
if not self.hold_tetri:
self.current_tetri.destroy()
self.hold_tetri = Tetrimino((0,0), self.hold_canvas, form=self.current_tetri.base_form, previsualization=True)
self.next()
else:
hold_form = self.hold_tetri.form
pos = self.current_tetri.position
self.hold_tetri = Tetrimino((0,0), self.hold_canvas, form=self.current_tetri.base_form, previsualization=True)
self.current_tetri.destroy()
self.current_tetri = Tetrimino(pos, self.canvas, form=hold_form)
def __controls(self, event):
if self.playing:
if event.keycode == Config.HOTKEYS[0]:
self.current_tetri.move((-1,0)) # Mouvement gauche
self.update_predict()
elif event.keycode == Config.HOTKEYS[1]:
self.current_tetri.move((1,0)) # Mouvement droit
self.update_predict()
elif event.keycode == Config.HOTKEYS[2]:
self.current_tetri.rotate() # Rotation du tetrimino
self.update_predict()
elif event.keycode == Config.HOTKEYS[3]:
self.current_tetri.go_down() # Hard drop du tetrimino
self.next()
elif event.keycode == Config.HOTKEYS[4]:
if not self.soft_droping:
self.soft_droping = True
self.speed = int(self.speed / 4)
elif event.keycode == Config.HOTKEYS[5]:
self.hold()
self.update_predict()
if event.keycode == Config.HOTKEYS[6]:
self.pause()
def __controls_released(self, event):
if event.keycode == Config.HOTKEYS[4]:
if self.soft_droping:
self.soft_droping = False
self.speed = self.speed * 4
# -------------------------------------------- #
# ----------------- SYSTEM MESSAGES METHODS ----------------- #
def __system_message(self, text=None, timer=None, priority=False):
""" Creer un system message (message affiche milieu haut de lecran), si un autre message est deja affiche le message passe est mis en attente"""
if not self.message_up:
if self.message_queue and not text and not timer:
self.__create_message(self.message_queue[0][0], self.message_queue[0][1])
del self.message_queue[0]
elif text and timer:
self.__create_message(text, timer)
else:
if priority:
self.message_queue.insert(0, (text, timer))
else:
self.message_queue.append((text, timer))
return
def __create_message(self, text, timer):
self.message = self.canvas.create_text(0, 0, text=text, anchor='nw', fill=choice(Config.COLORS[1:]), tag='message', font=("Helvetica", 18))
self.message_up = True
self.message_timer = int(timer//self.speed)
coords = self.canvas.bbox(self.message)
xOffset = (Config.CANVAS_WIDTH / 2) - (coords[2] - coords[0]) / 2
self.canvas.move(self.message, xOffset, 50)
def __update_message(self):
if self.message_up:
self.message_timer = self.message_timer - 1
self.message_up = self.message_timer > 0
if not self.message_up:
self.__delete_message()
def __delete_message(self):
self.canvas.delete(self.message)
if self.message_queue:
self.__system_message()
from PySide2 import QtCore, QtWidgets, QtGui
import sys, traceback
from ConfigWindow import ConfigWindow
from MainWindow import MainWindow
from ErrorWindow import ErrorWindow
from Sensor import Sensor
import config
if __name__ == "__main__":
try:
app = QtWidgets.QApplication([])
config_window = ConfigWindow()
setup = config_window.get_setup()
if setup:
stream, batch_size, reuse_size = setup
assert batch_size < config.HISTORY
sensor = Sensor(stream, batch_size, reuse_size)
main_window = MainWindow(sensor)
main_window.show()
sys.exit(app.exec_())
except Exception as e:
def onConfig(self,e):
frame = ConfigWindow(None, -1, "SL:LED Driver",self.app.oafRoot)
frame.Show(True)
class MainWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = uic.loadUi("./ui/mainwindow.ui", self)
self.registry = Registry()
self.registry.objects["config"] = Config()
self.conf = self.registry.objects["config"]
self.new_messages = {}
self.popup_man = PopUpMan()
self.sound = QtGui.QSound(r"./data/sounds/bb2.wav")
self.online_icon = QtGui.QIcon(r"./data/pics/online.png")
self.offline_icon = QtGui.QIcon(r"./data/pics/offline.png")
self.mail_icon = QtGui.QIcon(r"./data/pics/mail.png")
# connect signals and slots
self.actionLogin.triggered.connect(self.login)
self.actionExit.triggered.connect(self.close)
self.actionOptions.triggered.connect(self.openConfigWindow)
self.contactList.itemDoubleClicked.connect(self.openChatWindow)
self.connect(self.popup_man, self.popup_man.signal, self.openChatTabFromPopUp)
if self.registry.objects["config"].isLoggedIn():
self.actionLogin.setEnabled(False)
# widgets handlers
def login(self):
if not hasattr(self, "loginWidget") or not self.loginWidget.isVisible():
self.loginWidget = LoginWidget(self)
self.loginWidget.show()
self.loginWidget.raise_()
else:
self.loginWidget.activateWindow()
def openConfigWindow(self):
if not hasattr(self, "w") or not self.w.isVisible():
self.w = ConfigWindow(self)
self.w.show()
self.w.raise_()
else:
self.w.activateWindow()
""" I will uncomment this whenever I find a way to make application quit instead of folding when X is pressed
def hideEvent (self, e):
self.trayIcon = QtGui.QSystemTrayIcon (QtGui.QIcon (r"./data/pics/icon.png"))
self.trayIcon.setToolTip ("VPythonte messenger")
self.trayIcon.activated.connect (self.unfold)
self.trayIcon.show()
self.hide()
self.setWindowFlags (QtCore.Qt.Tool)
def unfold (self, e):
self.trayIcon.hide()
self.setWindowFlags (QtCore.Qt.WindowMinMaxButtonsHint | QtCore.Qt.WindowCloseButtonHint )
self.show()
self.showNormal()
self.activateWindow()
"""
# other methods
def updateConfig(self):
self.conf = self.registry.objects["config"]
if "vk" in self.registry.objects:
vk = self.registry.objects["vk"]
self.UpdateContactList(vk.online)
def server_connection_init(self):
self.registry.objects["vk"] = VkClientThread(self.conf.config["token"])
vk = self.registry.objects["vk"]
vk.start()
self.connect(vk, vk.updateOnlineForMainWindow, self.UpdateContactList)
self.connect(vk, vk.recieveMessagesForMainWindow, self.RecieveNewMessages)
def UpdateContactList(self, names):
self.contactList.clear()
vk = self.registry.objects["vk"]
showed = set()
# TODO: fix if user is not friend
for user in self.new_messages:
item = QtGui.QListWidgetItem(vk.id_to_name[user])
item.setIcon(self.mail_icon)
self.contactList.addItem(item)
showed.add(user)
for user in names:
if user not in showed:
item = QtGui.QListWidgetItem(vk.id_to_name[user])
item.setIcon(self.online_icon)
self.contactList.addItem(item)
showed.add(user)
conf = Registry().objects["config"]
if conf.config["showOffline"]:
for id in vk.id_to_name:
if id not in showed:
item = QtGui.QListWidgetItem(vk.id_to_name[id])
item.setIcon(self.offline_icon)
self.contactList.addItem(item)
def RecieveNewMessages(self, msgs):
vk = self.registry.objects["vk"]
msgs.pop(0)
mark_as_read = []
old_messages = self.new_messages
cnt = 0
self.new_messages = {}
for msg in reversed(msgs):
if hasattr(self, "ChatWindow") and msg["uid"] in self.ChatWindow.tabs:
uid = msg["uid"]
name = vk.id_to_name[uid]
cur_idx = self.ChatWindow.currentIndex()
if self.ChatWindow.tabs[uid] == cur_idx:
self.ChatWindow.getTab(msg["uid"]).add_message(msg["body"], name)
mark_as_read.append(msg["mid"])
if not self.ChatWindow.widget(self.ChatWindow.tabs[uid]).isActiveWindow():
self.ChatWindow.setTabIcon(self.ChatWindow.tabs[uid], self.mail_icon)
self.popup_man.create(msg["uid"], msg["mid"], msg["body"], cnt)
if self.conf.config["enableSound"]:
self.sound.play()
else:
if msg["uid"] not in old_messages or (
msg["uid"] in old_messages and msg["mid"] not in old_messages[msg["uid"]]
):
self.popup_man.create(msg["uid"], msg["mid"], msg["body"], cnt)
if self.conf.config["enableSound"]:
self.sound.play()
cnt += 1
if msg["uid"] in self.new_messages:
self.new_messages[msg["uid"]].append(msg["mid"])
else:
self.new_messages[msg["uid"]] = [msg["mid"]]
if mark_as_read:
vk.markAsRead(mark_as_read)
if self.new_messages or mark_as_read:
self.UpdateContactList(vk.online)
def openChatTab(self, id, show_history_mes=3):
if not hasattr(self, "ChatWindow"):
self.ChatWindow = ChatWindow()
vk = self.registry.objects["vk"]
name = vk.id_to_name[id]
self.ChatWindow.addChatTab(id, name, show_history_mes)
self.ChatWindow.show()
def openChatTabFromPopUp(self, id):
vk = self.registry.objects["vk"]
vk.markAsRead(self.new_messages[id])
reg = Registry()
loadHistory = reg.objects["config"].config["loadHistory"]
if loadHistory:
historyCount = reg.objects["config"].config["historyCount"]
else:
historyCount = 0
self.openChatTab(id, len(self.new_messages[id]) + historyCount)
del self.new_messages[id]
self.UpdateContactList(vk.online)
def openChatWindow(self, entry):
name = entry.text()
vk = self.registry.objects["vk"]
id = vk.name_to_id[unicode(name)]
reg = Registry()
loadHistory = reg.objects["config"].config["loadHistory"]
if loadHistory:
historyCount = reg.objects["config"].config["historyCount"]
else:
historyCount = 0
if id in self.new_messages:
vk.markAsRead(self.new_messages[id])
self.openChatTab(id, len(self.new_messages[id]) + historyCount)
del self.new_messages[id]
self.UpdateContactList(vk.online)
else:
self.openChatTab(id, historyCount)
