class VideoPlayer(QMediaPlayer):
"""docstring for VideoPlayer"""
def __init__(self):
super(VideoPlayer, self).__init__(None, QMediaPlayer.VideoSurface)
self.view = QVideoWidget()
self.view.setWindowTitle('Video Player')
self.setVideoOutput(self.view)
def widget(self):
return self.view
def show(self):
self.view.show()
def hide(self):
self.view.hide()
def isVisible(self):
return self.view.isVisible()
def setSize(self, width, height):
self.view.resize(width, height)
def toggle(self):
if self.state() == self.PlayingState:
self.pause()
else:
self.play()
def loadMedia(self, fullPath):
self.setMedia(QMediaContent(QUrl.fromLocalFile(fullPath)))
self.stop()
class Player(QDialog):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# self.show()
self.ui.btn_play.clicked.connect(self.playvideo) #включить видео
self.ui.btn_stop.clicked.connect(self.stopvideo) #остановить видео
self.ui.btn_pause.clicked.connect(self.pausevideo) #пауза
self.ui.btn_back.clicked.connect(self.hidewindow) #скрыть окно плеера
self.ui.verticalSlider.valueChanged.connect(self.setvolume) #громкость
# self.ui.horizontalSlider.valueChanged.connect(self.settimevideo) #перемотка - починить функцию
self.ui.listWidget.addItems(listdir("records")) #генерация списка файлов в папке records
self.ui.listWidget.itemClicked.connect(self.playthis) #выбор видео
self.player = QMediaPlayer()
self.player.positionChanged.connect(self.setvideoonslider)#автодвижение ползунка
self.video = QVideoWidget(self.ui.label)
self.video.resize(621, 451)
self.video.move(0, 0)
self.player.setVideoOutput(self.video)
self.video.show()
self.ui.label.customContextMenuRequested.connect(self.testfun) #ПРАВАЯ КНОПКА МЫШИ
def testfun(self):
print("Тест успешен")
def playvideo(self):
self.player.play()
self.ui.horizontalSlider.setMaximum(self.player.duration())
self.ui.horizontalSlider.setPageStep(self.player.duration() / 10)
def stopvideo(self):
self.player.stop()
def pausevideo(self):
self.player.pause()
def hidewindow(self):
self.hide()
def setvolume(self):
self.player.setVolume(self.ui.verticalSlider.value())
def settimevideo(self):
self.player.setPosition(self.ui.horizontalSlider.value())
def playthis(self):
self.player.setMedia(QMediaContent(QUrl.fromLocalFile("records/" + str(self.ui.listWidget.currentItem().text()))))
def setvideoonslider(self):
self.ui.horizontalSlider.setValue(self.player.position())
self.ui.lbl_time.setText(str(int(self.player.position() / 1000)) + "/" + str(int(self.player.duration() / 1000)))
def test(self):
print("Тест пройден")
class VideoPlayer:
def __init__(self):
self.video = QVideoWidget()
self.video.resize(300, 300)
self.video.move(0, 0)
self.player = QMediaPlayer()
self.player.setVideoOutput(self.video)
self.player.setMedia(
QMediaContent(
QUrl.fromLocalFile("/home/akhil/Videos/SoftwareTrial.mp4")))
def callback(self):
self.player.setPosition(
0) # to start at the beginning of the videowidget every time
self.video.show()
self.player.play()
def loose(self):
if globals.loose_animation:
video = QVideoWidget()
video.resize(500, 400)
video.setWindowTitle("GAME OVER")
player = QMediaPlayer()
player.setVideoOutput(video)
player.setMedia(
QMediaContent(QUrl.fromLocalFile("../Video/bum.gif")))
video.show()
player.play()
self.signals.add_music.emit()
time.sleep(5.5)
self.signals.delete_music.emit()
player.stop()
video.close()
else:
__loose_statement = QMessageBox.question(
QMessageBox(), "GAME OVER!!",
"You loose!!!\nYour time: {}".format(globals.time),
QMessageBox.Ok)
class VideoPlayer:
def __init__(self):
self.video = QVideoWidget()
self.video.resize(300, 300)
self.video.move(0, 0)
self.player = QMediaPlayer()
self.player.setVideoOutput(self.video)
self.player.setMedia(QMediaContent(QUrl.fromLocalFile("D:/FILM/film/data/video/2.mp4")))
self.timer = QTimer()
self.timer.timeout.connect(self.check)
self.timer.start(1000)
def callback(self):
self.player.setPosition(0) # to start at the beginning of the video every time
self.video.show()
self.player.play()
def check(self):
print('DADA')
class Frogger(QWidget):
def __init__(self):
super().__init__()
Config.mainWindow = self #odma se postavi koji objekat je mainWindow da bi tamo u Rectangle.py Qlabeli znali gde treba da se nacrtaju. Lose je resenje, al radi bar za testiranje
self.Menu = None # glavni meni
self.InitFlagsAndVariables()
self.scoreboard = Scoreboard(self)
self.highscore = HighScore()
self.highscore.readFromFile()
###############################################
self.videoWidget = QVideoWidget(self)
self.videoWidget.resize(Config.mapSize * Config.gridSize,
Config.mapSize * Config.gridSize + 50)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.setMedia(
QMediaContent(QUrl(Config.spriteLocation + "Intro.wmv")))
###############################################
self.setWindowState(Qt.WindowNoState)
self.__init_ui__()
self.key_notifier = KeyNotifier()
self.key_notifier.key_signal.connect(self.__update_position__)
self.key_notifier.start()
self.ZevsJavljaVremeQueue = Queue()
self.procUKomZiviZevs = Zeus.PokreniZevsa(
self.ZevsJavljaVremeQueue
) #pokrece proces koji u kju stavlja kakvo vreme treba da bude (sunce, kisa, sneg)
def InitFlagsAndVariables(self):
self.Map = [] # lista lejnova
self.previousWeather = 'n'
self.player1 = None
self.player2 = None
self.player1RectId = -1 # ovo je potrebno za mrezu
self.player2RectId = -1 # ovo je potrebno za mrezu
self.gamePaused = False
self.GameOverBrojac = 0 # za zivote, ako je 2PlayerMode, kad igrac izgubi sve zivote povecava brojac za 1, kad oba izgube sve zivote, brojac je 2 i tad je gameOver
# ako je SinglePlayer mod onda je gameOver ako je brojac 1
self.Level = 1 # za levele
Config.p1Score = 0
Config.p2Score = 0
Config.p1Lives = 5
Config.p2Lives = 5
try:
self.ShutDownHost()
except:
pass
try:
self.ShutDownClient()
except:
pass
self.host = None
self.client = None
self.isHost = False
self.isClient = False
def initVideo(self):
self.videoWidget.show()
self.mediaPlayer.play()
def __init_ui__(self):
self.setWindowTitle('Frogger')
self.setWindowIcon(QtGui.QIcon(Config.spriteLocation +
'iconFrog.png')) #ikonica
self.resize(Config.mapSize * Config.gridSize,
Config.mapSize * Config.gridSize + 50)
self.FixWindowSize()
self.show()
self.initVideo()
q = QTimer()
q.singleShot(6000, self.DisplayMainMenu)
def HsFunkc(self):
self.Menu.HsElementsShow(self.highscore.top3)
#obicna funkcija za fiksiranje velicine prozora
def FixWindowSize(self):
self.setMinimumHeight((Config.mapSize + 1) * Config.gridSize)
self.setMinimumWidth(Config.mapSize * Config.gridSize)
self.setMaximumHeight((Config.mapSize + 1) * Config.gridSize)
self.setMaximumWidth(Config.mapSize * Config.gridSize)
def RemoveVideoIntro(self):
try:
self.mediaPlayer.stop()
self.videoWidget.setParent(None)
self.videoWidget = None
except:
pass
def DisplayMainMenu(self):
self.RemoveVideoIntro()
self.Menu = None
self.Menu = Meni(self, self.SinglePlayerMode, self.TwoPlayerMode,
self.HsFunkc, self.MainMenuHostClick,
self.MainMenuJoinClick, self.CloseWindow)
def PauseGame(self):
self.gamePaused = True
self.updaterGameObjekataThread.PauseGame()
def ResumeGame(self):
self.gamePaused = False
self.updaterGameObjekataThread.ResumeGame()
def RemoveAllGameUIObjects(self):
for lejer, lista in Rectangle.allRectangles.items():
for rect in lista:
rect.RemoveFromScreen()
GameObject.allGameObjects = []
Rectangle.allRectangles = {}
Rectangle.ResetId()
def SinglePlayerMode(self):
self.ClearZeusQueue()
self.Menu.HideMainMenu()
self.DisplayMap(
) #u displayMap se kreira objekat self.updaterGameObjekataThread i zato DisplayMap mora ici prvi
self.createThreadToUpdateGameObjects()
self.startThreadForUpdatingGameObjects()
self.scoreboard.ShowScore()
self.CreatePlayers()
Config.collectLilypadsToAdvanceLevel = 1
def ClearZeusQueue(self):
while not self.ZevsJavljaVremeQueue.empty():
self.ZevsJavljaVremeQueue.get()
def TwoPlayerMode(self, OverNetworkGame=False):
self.ClearZeusQueue()
self.Menu.HideMainMenu()
if not OverNetworkGame: #kad je preko mreze onda updateovanje krece kad klijent bude spreman
self.createThreadToUpdateGameObjects()
self.startThreadForUpdatingGameObjects()
self.DisplayMap(TwoPlayers=True)
self.scoreboard.ShowScores()
self.CreatePlayers(TwoPlayers=True)
Config.collectLilypadsToAdvanceLevel = 3
def MainMenuHostClick(self):
self.HostServer(Config.serverAddress, Config.serverPort)
def MainMenuJoinClick(self):
#self.Menu.JoinWidgetHide()
self.setFocus()
#ovde sacuvamo ip adresu i port u fajl. da kad se sledeci put upali igra da odma ucita tu ipadresu i port
try:
with open(Config.lastIp_filename, "w") as f:
f.write(str(self.Menu.ipAddr) + ":" + str(self.Menu.port))
except:
pass
self.JoinServer(self.Menu.ipAddr, int(self.Menu.port))
def CreatePlayers(self, TwoPlayers=False):
self.player1 = Frog(Config.player1StartPosition[0],
Config.player1StartPosition[1], self.GameOverCheck,
self.updateP1Score, self.createGreenLives)
self.player1RectId = self.player1.id
if TwoPlayers:
self.player2 = Frog(Config.player2StartPosition[0],
Config.player2StartPosition[1],
self.GameOverCheck,
self.updateP2Score,
self.createPinkLives,
isPlayerTwo=True)
self.player2RectId = self.player2.id
def updateP1Score(self, newScore):
self.scoreboard.updateP1Score(newScore)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P1S_" +
str(newScore)) #P2L => Player 2 Lives
def updateP2Score(self, newScore):
self.scoreboard.updateP2Score(newScore)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P2S_" +
str(newScore)) #P2L => Player 2 Lives
def createPinkLives(self, lives):
self.scoreboard.CreatePinkLives(lives)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P2L_" +
str(lives)) #P2L => Player 2 Lives
def createGreenLives(self, lives):
self.scoreboard.CreateGreenLives(lives)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P1L_" +
str(lives)) #P1L => Player 2 Lives
def DisplayMap(self, TwoPlayers=False):
self.Map.append(Lane.GenerateSafetyLane()) #prvi je uvek sejf lejn
self.GenerateLanes('Road') #fja da generise lejnove za put
#self.Map.append(Lane.GenerateSafetyLane())
##ovaj ce da bude uvek tu da bi se moglo duze igrati
##lejn sa zivotom
self.Map.append(Lane.GenerateSafetyLaneWithDeus())
self.GenerateLanes('Water') #fja da generise lejnove za reku
if TwoPlayers:
self.Map.append(Lane.GenerateFinalLane(
self.LevelPassed)) # zadnji je uvek finalLane
else:
self.Map.append(
Lane.GenerateFinalLane(
self.LevelPassed,
lilyPadPattern=Config.lilypadPatternBO5Standard)
) # zadnji je uvek finalLane
def GameOverCheck(self, isPlayerTwo):
#fja koja se poziva kada igrac ima 0 zivota, prosledjuje se igracima kroz konstruktor
self.GameOverBrojac += 1
if self.player1 != None and self.player2 != None:
if self.GameOverBrojac == 1:
if isPlayerTwo:
self.highscore.checkIfHighScore(self.player2.playerName,
self.player2.score)
self.player2.RemoveFromScreen()
self.player2 = None
Config.p2Lives = 0
else:
self.highscore.checkIfHighScore(self.player1.playerName,
self.player1.score)
self.player1.RemoveFromScreen()
self.player1 = None
Config.p1Lives = 0
elif self.player1 != None:
self.highscore.checkIfHighScore(self.player1.playerName,
self.player1.score)
self.GameOver()
elif self.player2 != None:
self.highscore.checkIfHighScore(self.player2.playerName,
self.player2.score)
self.GameOver()
def GameOver(self):
# javimo klijentu da bi se vratio na meni
if self.isHost:
self.host.SendToClient(Config.network_ConnectionError)
#fja koja se poziva kad su svi igraci igraci ostali bez zivota
self.stopThreadForUpdatingObjects()
self.DeleteMap(deleteP1=True, deleteP2=True)
self.Menu.ShowMainMenu()
Lane.ResetLaneStartingIndex()
self.scoreboard.HideScores()
self.Menu.kisa.hide()
self.Menu.sneg.hide()
self.scoreboard.CreateGreenLives(0)
self.scoreboard.CreatePinkLives(0)
self.InitFlagsAndVariables()
def ShutDownHost(self):
if self.host != None:
print("gasim hosta")
self.host.StopHosting()
self.isHost = False
self.host = None
def ShutDownClient(self):
if self.client != None:
self.client.StopClienting()
self.isClient = False
self.client = None
def LevelPassed(self):
#fja koja se poziva kad su svih 5 Lilypada popunjena, prosledjuje se u konstruktoru, prvo finalLejnu pa samim objektima
self.Level += 1
Lane.ResetLaneStartingIndex()
self.GameOverBrojac = 0
self.DeleteMap()
if self.player1 != None and self.player2 != None:
Config.p1Score = self.player1.score
Config.p2Score = self.player2.score
Config.p1Lives = self.player1.lives
Config.p2Lives = self.player2.lives
self.DisplayMap(TwoPlayers=True)
self.CreatePlayers(TwoPlayers=True)
elif self.player1 != None:
Config.p1Score = self.player1.score
Config.p1Lives = self.player1.lives
self.DisplayMap()
self.CreatePlayers()
elif self.player2 != None:
Config.p2Score = self.player2.score
Config.p2Lives = self.player2.lives
self.DisplayMap()
self.CreatePlayers(TwoPlayers=True)
self.player1.RemoveFromScreen()
self.player1 = None
if self.isHost and self.player2 != None:
self.SendClientToReplicateObjects()
def DeleteMap(self, deleteP1=False, deleteP2=False):
if deleteP1:
try:
self.player1.RemoveFromScreen()
self.player1 = None
except:
print('P1 vec postavljen na None')
if deleteP2:
try:
self.player2.RemoveFromScreen()
self.player2 = None
except:
print('P2 vec postavljen na None')
for lane in self.Map:
for obs in lane.obstacles:
obs.RemoveFromScreen()
lane.obstacles.clear()
lane.RemoveFromScreen()
for layer, listOfRectanglesInLayer in Rectangle.allRectangles.items():
for rect in listOfRectanglesInLayer:
rect.RemoveFromScreen()
listOfRectanglesInLayer.clear()
self.Map.clear()
def DisplayTestMap(self):
Lane.ResetLaneStartingIndex()
self.Map.append(Lane.GenerateSafetyLane())
self.Map.append(Lane.GenerateEasyLane())
self.Map.append(Lane.GenerateEasyLane())
self.Map.append(Lane.GenerateEasyLane())
self.Map.append(Lane.GenerateSafetyLane())
self.Map.append(Lane.GenerateFinalLane())
self.Map.append(
Lane.GenerateFinalLane(lilyPadPattern=Config.lilypadPatternBO3))
self.Map.append(
Lane.GenerateFinalLane(lilyPadPattern=Config.lilypadPatternBO5V2))
self.Map.append(Lane.GenerateFinalLane(randomPatternBO5=True))
def keyPressEvent(self, event):
if not event.isAutoRepeat():
self.key_notifier.add_key(event.key())
def __update_position__(self, key):
if not self.isClient:
if key == Qt.Key_Escape and self.gamePaused:
self.ResumeGame()
elif key == Qt.Key_Escape and not self.gamePaused:
self.PauseGame()
if self.isClient: #ako sam klijent onda pored pomeranja zabe, hocu da posaljem INPUT serveru
if key == Qt.Key_Right:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"DESNO")
elif key == Qt.Key_Down:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"DOLE")
elif key == Qt.Key_Up:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"GORE")
elif key == Qt.Key_Left:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"LEVO")
if key == Qt.Key_T:
for go in GameObject.allGameObjects:
print(str(go.id) + "__" + str(go.loadedSprite))
if self.gamePaused: #sve sto je ispod nece biti odradjeno kad je game pauziran
return
if self.player1 != None:
self.player1.KeyPress(key)
if self.player2 != None:
self.player2.KeyPress(key)
def CloseWindow(self):
# OVDE TREBA DA SE POZOVE KOD KOJI CE DA ZAUSTAVI ZEVSA
# (ako uopste postoji neko toliko jak da zaustavi zevsa)
try:
self.procUKomZiviZevs.terminate()
except:
pass
try:
self.updaterGameObjekataThread.updaterThreadWork = False # self.updaterGameObjekataThread se kreira samo kad pocne IGRA. Ako budes na meniju i nista ne radis nece se kreirati
except:
pass
self.key_notifier.die()
def closeEvent(self, event):
self.CloseWindow()
def createThreadToUpdateGameObjects(self):
self.updaterGameObjekataThread = GOUpdater()
self.updaterGameObjekataThread.nekiObjekat.connect(
self.updateAllGameObjects)
#OVO (thread koji updateuje objekte) SE POKRECE KAD KLIJENT BUDE SPREMAN (nakon sto preuzme sve objekte i nacrta ih na ekranu), ili kad pocne neki od lokalnih game modova
#self.updaterGameObjekataThread.start()
def startThreadForUpdatingGameObjects(self):
self.updaterGameObjekataThread.start()
def stopThreadForUpdatingObjects(self):
try: #na klijentu ovaj objekat za updateovanje ce biti null
self.updaterGameObjekataThread.updaterThreadWork = False
except:
pass
def updateAllGameObjects(self, dummy): #callback funkcija
for gameObject in GameObject.allGameObjects:
gameObject.update()
# ako je instanca server i postoje gameobjekti onda da salje klijentu pozicije tih objekata
if self.isHost and len(GameObject.allGameObjects) > 0:
self.SendRectPositionUpdateToClient()
if not self.ZevsJavljaVremeQueue.empty():
self.updateWeather(self.ZevsJavljaVremeQueue.get())
else:
return
def updateWeather(self, newWeather):
if self.isHost:
self.host.SendToClient(Config.network_updateWeatherInfo + ":" +
newWeather)
if newWeather == 'k':
if self.previousWeather == 'k':
self.ZaustaviKisu()
elif self.previousWeather == 's':
self.ZaustaviSneg()
self.PokreniKisu()
elif newWeather == 's':
if self.previousWeather == 'k':
self.ZaustaviKisu()
elif self.previousWeather == 's':
self.ZaustaviSneg()
self.PokreniSneg()
elif newWeather == 'n':
if self.previousWeather == 'k':
self.ZaustaviKisu()
elif self.previousWeather == 's':
self.ZaustaviSneg()
self.previousWeather = newWeather
def createLanes(self, niz, type):
#funkcija koja generise lejnove u zavisnosti od prosledjenog niza i karaktera u njemu
if type == 'Road':
for letter in niz:
if letter == 'e':
self.Map.append(Lane.GenerateEasyLane())
elif letter == 'm':
self.Map.append(Lane.GenerateMediumLane())
elif letter == 'h':
self.Map.append(Lane.GenerateHardLane())
elif type == 'Water':
for letter in niz:
if letter == 'e':
self.Map.append(Lane.GenerateEasyWaterLane())
elif letter == 'm':
self.Map.append(Lane.GenerateMediumWaterLane())
elif letter == 'h':
self.Map.append(Lane.GenerateHardWaterLane())
elif type == 'Random':
for letter in niz:
if letter == 's': # safe lane
self.Map.append(Lane.GenerateSafetyLane())
elif letter == 'e': # easy lane, if generated -1 -> easyWaterLane if 1 easyTrafficLane, isto vazi za ostale samo se menja tezina s,m,h...
if [-1, 1][randrange(2)] == -1:
self.Map.append(Lane.GenerateEasyWaterLane())
else:
self.Map.append(Lane.GenerateEasyLane())
elif letter == 'm':
if [-1, 1][randrange(2)] == -1:
self.Map.append(Lane.GenerateMediumWaterLane())
else:
self.Map.append(Lane.GenerateMediumLane())
elif letter == 'h':
if [-1, 1][randrange(2)] == -1:
self.Map.append(Lane.GenerateHardWaterLane())
else:
self.Map.append(Lane.GenerateHardLane())
def GenerateLanes(self, type):
# 6 lejnova, fja u kojoj se odlucuje tezina po levelima, moze da se menja po volji
nizTezine = []
if self.Level <= 2:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
elif self.Level > 2 and self.Level <= 4:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
type = 'Random'
elif self.Level > 4 and self.Level <= 6:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
elif self.Level > 6 and self.Level <= 8:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
type = 'Random'
elif self.Level > 8 and self.Level <= 10:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
elif self.Level > 10 and self.Level <= 12:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
type = 'Random'
elif self.Level > 12 and self.Level <= 14:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
elif self.Level > 12 and self.Level <= 14:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
type = 'Random'
elif self.Level > 14 and self.Level <= 16:
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
elif self.Level > 16:
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
type = 'Random'
shuffle(nizTezine) #permutuj niz da lejnovi budu random
self.createLanes(nizTezine, type)
def PokreniKisu(self): #Fja da se prikaze kisa
self.Menu.PrikaziPadavinu('kisa')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(
Config.speedChange) #brzina drveca se povecava kad je kisa
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(-Config.speedChange
) #brzina automobila se smanjuje kad je kisa
def PokreniSneg(self): #Fja da se prikaze sneg
self.Menu.PrikaziPadavinu('sneg')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(-Config.speedChange
) #brzina drveca se smanjuje kad je sneg
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(Config.speedChange
) #brzina automobila se povecava kad je sneg
def ZaustaviKisu(self): #Fja da se zaustavi kisa
self.Menu.SakrijPadavinu('kisa')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(
-Config.speedChange
) #obrnuto, ako smo bili povecali brzinu drveca kad je kisa pocela, sad je smanjujemo, vracamo na default
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(
Config.speedChange
) #obrnuto, ako smo bili smanjili brzinu automobila kad je kisa pocela, sad je povecavamo, vracamo na default
def ZaustaviSneg(self): #Fja da se zaustavi sneg
self.Menu.SakrijPadavinu('sneg')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(
Config.speedChange
) #obrnuto, ako smo bili smanjili brzinu drveca kad je poceo sneg, sad je povecavamo, vracamo na default
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(
-Config.speedChange
) #obrnuto, ako smo bili povecali brzinu automobila kad je poceo sneg, sad je smanjujemo, vracamo na default
################################################################################
#FUNKCIJE ISPOD SE KORISTE SAMO ZA MULITPLAYER
################################################################################
def HostServer(self, address, port):
self.isHost = True
self.host = Host(address, port)
self.host.receiveCallBack.connect(self.ReceiveFromClient)
self.host.start()
def JoinServer(self, address, port):
self.isClient = True
self.client = Client(address, port)
self.client.receiveCallBack.connect(self.ReceiveFromServer)
self.client.start()
def SendClientToReplicateObjects(self):
self.host.SendToClient(Config.network_kreirajSveObjekteNaKlijentu +
":" + self.CreateInitObjectsString())
# ovo ce biti pozvano kad server primi poruku od klijenta
def ReceiveFromClient(self, data):
# print("Primio od klijenta: " + str(data))
if data == Config.network_clientIsReady: # kad primi ovo znaci da se klijent povezao
self.TwoPlayerMode(OverNetworkGame=True)
self.player2.keyBoardInputEnabled = False
self.SendClientToReplicateObjects(
) #da ne generise updater svaki put kad se predje level, vec samo incijalno kad se uspostavi veza
elif data == Config.network_potvrdaKlijentaDaJeNapravioSveObjekte and self.Level == 1: # klijent je potvrdio da je napravio sve objekte i sad pokrecemo igru (pravimo i pokrecemo thread koji updateuje igru)
self.createThreadToUpdateGameObjects()
self.startThreadForUpdatingGameObjects()
elif Config.network_inputKlijentaPrefix in data and self.player2 != None: #ovo da li je igrac razlicit od None je ustvari provera da li je ziv
if Config.network_inputKlijentaPrefix + "DESNO" == data:
self.player2.GoRight()
elif Config.network_inputKlijentaPrefix + "DOLE" == data:
self.player2.GoDown()
elif Config.network_inputKlijentaPrefix + "GORE" == data:
self.player2.GoUp()
elif Config.network_inputKlijentaPrefix + "LEVO" == data:
self.player2.GoLeft()
elif Config.network_ConnectionError == data:
print("Klijent je otiso :(")
self.ResetGameStateOnError()
# ovo ce biti pozvano kad klijent primi poruku od servera
def ReceiveFromServer(self, data):
#print("Primio od servera: " + str(data))
if data == Config.network_serverWelcomeMsg: # znaci da smo se uspesno povezali sa serverom i inicijalizujemo gejm
self.InitNetworkGame()
elif Config.network_kreirajSveObjekteNaKlijentu in data:
self.GenerateObjects(data.split(":")[1])
self.client.SendToServer(
Config.network_potvrdaKlijentaDaJeNapravioSveObjekte)
elif Config.network_updateSveObjekteNaKlijentu in data:
self.UpdateObjectsPosition(data.split(":")[1])
elif Config.network_updateGameScoreAndLives in data:
#ako ovde udje PAYLOAD moze da izgleda ovako:
#P2L_3
#P1S_2
#P2S_4
#P1L_1
payload = data.split(":")[1]
player, scoreOrLives = payload.split('_')
#print(str(payload))
if "P1" in player:
if "S" in player:
self.updateP1Score(scoreOrLives)
elif "L" in player:
self.createGreenLives(int(scoreOrLives))
elif "P2" in player:
if "S" in player:
self.updateP2Score(scoreOrLives)
elif "L" in player:
self.createPinkLives(int(scoreOrLives))
elif Config.network_updateWeatherInfo in data:
self.updateWeather(data.split(":")[1])
elif Config.network_ConnectionError == data:
self.ResetGameStateOnError()
#ovo se poziva na klijentu.
def InitNetworkGame(self):
self.TwoPlayerMode(
OverNetworkGame=True
) #nije potrebno ovo True, al da se dzabe nebi pravio thread koji se ne koristi :D
#sklanjamo sve objekte, jer ce nam server poslati sta je on generisao (velicine, pozicije, sprajtove)
for go in GameObject.allGameObjects:
go.RemoveFromScreen()
GameObject.allGameObjects.clear()
#klijent javi serveru da je spreman (spreman da primi podatke o svim objektima)
self.client.SendToServer(Config.network_clientIsReady)
#poziva se ako dodje do greske prilikom komunikacije sa klijentom
def ResetGameStateOnError(self):
self.RemoveAllGameUIObjects()
self.GameOver()
#poziva se samo na serveru
def SendRectPositionUpdateToClient(self):
self.host.SendToClient(Config.network_updateSveObjekteNaKlijentu +
":" + self.CreateUpdateObjectsString())
#ova metoda moze ici u GameObject Klasu
def CreateInitObjectsString(self):
objektiUString = []
for go in GameObject.allGameObjects: #saljemo podatke koji su potrebni da bi se napravili objekti na klijentu
objektiUString.append(
str(go.id) + "%" + go.loadedSprite + "%" + str(go.x) + "%" +
str(go.y) + "%" + str(go.w) + "%" + str(go.h))
return "#".join(objektiUString)
# ova metoda moze ici u GameObject Klasu
def CreateUpdateObjectsString(self):
objektiUString = []
for go in GameObject.allGameObjects: #saljemo podatke koji su potrebni da bi se updateovale pozicije objekata na klijentu
#optimizovano, ne saljem update za sve gameObjecte vec samo one koji su u lejeru prepreke i imaju neku brzinu
if go.layer == Config.layerPrepreke and go.speed != 0:
objektiUString.append(
str(go.id) + "%" + str(go.x) + "%" + str(go.y))
elif go.layer == Config.layerZabe or go.layer == Config.layerLilypad: #igraci i lokvanji mogu da promene sprite i zato saljem i sprite :D
objektiUString.append(
str(go.id) + "%" + str(go.x) + "%" + str(go.y) + "%" +
str(go.loadedSprite))
# ovo je dodato ako neki od igraca umre da ga klijent skloni sa ekrana (sprite se stavi na prazan string)
if self.player1 == None and self.player1RectId != -1:
objektiUString.append(
str(self.player1RectId) + "%" + str(0) + "%" + str(0) +
"%DEAD")
self.player1RectId = -1
if self.player2 == None and self.player2RectId != -1:
objektiUString.append(
str(self.player2RectId) + "%" + str(0) + "%" + str(0) +
"%DEAD")
self.player2RectId = -1
return "#".join(objektiUString)
#ova funkcija se poziva na klijentu, da napravi objekte iste kao sto su na serveru. Pozove se samo na pocetku
def GenerateObjects(self, data):
for layer, listOfRects in Rectangle.allRectangles.items():
for rect in listOfRects:
rect.RemoveFromScreen()
listOfRects.clear()
objs = data.split("#")
Rectangle.ResetId()
for obj in objs:
objData = obj.split("%")
r = Rectangle(float(objData[2]),
float(objData[3]),
int(objData[4]),
int(objData[5]),
objData[1],
layer=objData[0],
forceId=int(objData[0]))
r.Show()
#ova funkcija se poziva na klijentu, sluzi za updateovanje (samo X i Y kordinate) svih rectanglova na klijentu.
#server ce ovo slati klijentu svaki frejm (30 puta u sekundi)
def UpdateObjectsPosition(self, data):
objs = data.split("#")
dictObj = {}
for obj in objs:
objData = obj.split("%")
if len(objData) == 4:
dictObj[objData[0]] = (float(objData[1]), float(objData[2]),
objData[3])
elif len(objData) == 3:
dictObj[objData[0]] = (float(objData[1]), float(objData[2]))
for go in GameObject.allGameObjects:
strId = str(go.id)
if strId in dictObj.keys():
go.SetPosition(dictObj[strId][0], dictObj[strId][1])
if len(dictObj[strId]
) == 3: #ako je 3 znaci da imamo i sprite poslat
go.ChangeSprite(dictObj[strId][2])
class Final(QWidget):
def __init__(self):
super().__init__()
self.setGeometry(0, 0, w, h)
self.backgroundImage = QLabel(self)
self.textBubble = QLabel(self)
self.previousButton = QPushButton(self)
self.nextButton = QPushButton(self)
self.textField = QLabel(self)
# self.video = VideoPlayer(self)
self.inputPassword = QLineEdit(self)
self.checkButton = QPushButton('QED', self)
self.initWindow()
self.show()
def initWindow(self):
pixmap = QPixmap(
resource_path("./images/examen3/merceClasse2.JPG")).scaled(w, h)
self.backgroundImage.setPixmap(pixmap)
self.previousButton.move(0.12 * w, 0.83 * h)
self.previousButton.setIcon(
QIcon(resource_path('./images/icons/previous.png')))
self.previousButton.setStyleSheet(
"QPushButton{background: transparent;}")
self.previousButton.hide()
bubblePM = QPixmap(resource_path("./images/icons/textBubble.png"))
self.textBubble.setPixmap(bubblePM)
self.textBubble.move(0.1 * w, 0.75 * h)
self.textField.setText(
'''<p> - I la resposta és... 432! Doncs crec que ja ho tindríem, primer exercici... segon exercici... i tercer! Tots acabats i en fulls separats, crec que va sent hora d'entregar aquest examen d'aquesta assignatura de merda, per fi me'n puc desfer, per fi podré no gastar l'hora i mitja de dilluns i divendres que els meus solidaris companys feien servir per restregar-me lo bé que s'ho passaven fent birres al bar. I tot això? Per a què? Per a que acabin traient la mateixa nota que jo, o millor? N'estic fart. <b> ( Silenci ) </b> Hola Morsè, et vinc a entregar el final de la millor assignatura que he fet en la meva vida, gràcies per tot.</p>'''
)
self.textField.setAlignment(Qt.AlignJustify)
self.textField.setWordWrap(True)
self.textField.resize(600, 200)
self.textField.move(0.167 * w, 0.76 * h)
self.textField.show()
self.inputPassword.setGeometry(0.2 * w, 0.83 * h, 0.2 * w, 0.04 * h)
self.inputPassword.setMaxLength(20)
self.inputPassword.setFrame(False)
self.inputPassword.hide()
self.checkButton.move(0.45 * w, 0.83 * h)
self.checkButton.clicked.connect(self.checkAnswerSecondExercise)
self.checkButton.hide()
self.nextButton.move(0.85 * w, 0.83 * h)
self.nextButton.setIcon(QIcon(
resource_path('./images/icons/next.png')))
self.nextButton.setStyleSheet("QPushButton{background: transparent;}")
try:
self.nextButton.clicked.disconnect()
self.textBubble.show()
self.textField.show()
self.nextButton.show()
except:
pass
self.nextButton.clicked.connect(self.finalFirst)
# self.video.resize(w, h)
# self.video.hide()
self.hide()
self.show()
def finalFirst(self):
self.textField.setText(
'''<p> <b> Morsè Oller: </b> . ... -.-. --- .-.. - .- -. --- .. -. --- .... .- ... .--. --- ... .- - .-. . ... .- .-.. ·----· .- .--. .- .-. - .- - -.. ·----· .- ... ... .. --. -. .- - ..- .-. .- <br> - Que no he posat res a l'apartat d'assignatura?! (M'ha enxampat) És que... com t'explico això Morsè... resulta que aquesta part no me l'he pogut estudiar, tenia pensat fer-ho avui al matí però... al final m'he liat (toma aresta) i no he pogut... No tindries pas una pista per ajudar-me? De quina assignatura estem parlant?</p>'''
)
self.textField.setAlignment(Qt.AlignJustify)
self.textField.setWordWrap(True)
self.textField.resize(600, 200)
self.textField.move(0.167 * w, 0.78 * h)
try:
self.previousButton.clicked.disconnect()
except:
pass
self.previousButton.clicked.connect(self.initWindow)
self.nextButton.clicked.disconnect()
self.nextButton.clicked.connect(self.videoFinal)
def videoFinal(self):
self.nextButton.hide()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget(self)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(path)))
self.videoWidget.show()
self.videoWidget.resize(w, h)
self.textField.hide()
self.textBubble.hide()
self.backgroundImage.hide()
self.nextNewButton = QPushButton(self)
self.nextNewButton.setStyleSheet(
"QPushButton{background-color: white;}")
# self.nextNewButton.setStyleSheet("QPushButton{background: transparent;}")
self.nextNewButton.move(0.85 * w, 0.83 * h)
self.nextNewButton.setIcon(
QIcon(resource_path('./images/icons/next.png')))
self.nextNewButton.show()
self.mediaPlayer.play()
# self.video.show()
try:
self.nextNewButton.clicked.disconnect()
except:
pass
self.nextNewButton.clicked.connect(self.finalAnswer)
def finalAnswer(self):
self.nextNewButton.hide()
self.videoWidget.hide()
self.textField.setText(
'''<p> - Finalment, de quina assignatura ha sigut l'examen que has fet avui? </p>'''
)
self.textField.setAlignment(Qt.AlignJustify)
self.textField.setWordWrap(True)
self.textField.resize(600, 200)
self.textField.move(0.167 * w, 0.78 * h)
self.inputPassword.show()
self.checkButton.show()
self.textField.show()
self.textBubble.show()
def checkAnswerSecondExercise(self):
self.finalFinal = FinalFinal()
self.close()
class Widgets(QWidget):
def __init__(self, dispositivoCamara, parent=None):
super(Widgets, self).__init__(parent)
self.parent = parent
self.estadoFoto = False
self.byteArrayFoto = QByteArray()
# ==========================================================
frame = QFrame(self)
frame.setFrameShape(QFrame.Box)
frame.setFrameShadow(QFrame.Sunken)
frame.setFixedWidth(505)
frame.setFixedHeight(380)
frame.move(10, 10)
# Instancias
self.paginaVisor = QVideoWidget()
self.paginaVisor.resize(500, 375)
self.visor = QCameraViewfinder(self.paginaVisor)
self.visor.resize(500, 375)
self.labelFoto = QLabel()
self.labelFoto.setAlignment(Qt.AlignCenter)
self.labelFoto.resize(500, 375)
# QStackedWidget
self.stackedWidget = QStackedWidget(frame)
self.stackedWidget.addWidget(self.paginaVisor)
self.stackedWidget.addWidget(self.labelFoto)
self.stackedWidget.resize(500, 375)
self.stackedWidget.move(2, 2)
# ======================== BOTONES =========================
self.buttonTomarFoto = QPushButton("Tomar foto", self)
self.buttonTomarFoto.resize(110, 26)
self.buttonTomarFoto.move(525, 10)
self.buttonEliminarFoto = QPushButton("Eliminar foto", self)
self.buttonEliminarFoto.resize(110, 26)
self.buttonEliminarFoto.move(525, 50)
self.buttonGuardarFoto = QPushButton("Guardar foto", self)
self.buttonGuardarFoto.resize(110, 26)
self.buttonGuardarFoto.move(525, 82)
# ======================== EVENTOS =========================
self.buttonTomarFoto.clicked.connect(self.tomarFoto)
self.buttonEliminarFoto.clicked.connect(self.eliminarFoto)
self.buttonGuardarFoto.clicked.connect(self.guardarFoto)
# ================== FUNCIONES AUTOMÁTICAS =================
self.setCamara(dispositivoCamara)
# ======================= FUNCIONES ============================
def setCamara(self, dispositivoCamara):
if dispositivoCamara.isEmpty():
self.camara = QCamera()
else:
self.camara = QCamera(dispositivoCamara)
self.camara.stateChanged.connect(self.actualizarEstadoCamara)
self.capturaImagen = QCameraImageCapture(self.camara)
self.camara.setViewfinder(self.visor)
self.actualizarEstadoCamara(self.camara.state())
self.capturaImagen.imageCaptured.connect(self.procesarImagenCapturada)
self.capturaImagen.imageSaved.connect(self.imagenGuardada)
self.camara.isCaptureModeSupported(QCamera.CaptureStillImage)
self.camara.start()
self.paginaVisor.update()
def actualizarDispositivoCamara(self, action):
self.setCamara(action.data())
def actualizarEstadoCamara(self, estado):
if estado == QCamera.ActiveState:
self.parent.accionIniciarCamara.setEnabled(False)
self.parent.accionDetenerCamara.setEnabled(True)
if not self.estadoFoto:
self.buttonTomarFoto.setEnabled(True)
self.buttonEliminarFoto.setEnabled(False)
self.buttonGuardarFoto.setEnabled(False)
elif estado in (QCamera.UnloadedState, QCamera.LoadedState):
self.parent.accionIniciarCamara.setEnabled(True)
self.parent.accionDetenerCamara.setEnabled(False)
if not self.estadoFoto:
self.buttonTomarFoto.setEnabled(False)
self.buttonEliminarFoto.setEnabled(False)
self.buttonGuardarFoto.setEnabled(False)
def iniciarCamara(self):
self.camara.start()
def detenerCamara(self):
self.camara.stop()
def tomarFoto(self):
rutaFoto = "{}/fotoTemporal.jpg".format(getcwd())
self.capturaImagen.capture(rutaFoto)
self.estadoFoto = True
def procesarImagenCapturada(self, requestId, imagen):
foto = QPixmap.fromImage(imagen)
buffer = QBuffer(self.byteArrayFoto)
buffer.open(QIODevice.WriteOnly)
buffer.close()
foto.save(buffer, "PNG")
fotoEscalada = foto.scaled(self.labelFoto.size())
self.labelFoto.setPixmap(fotoEscalada)
self.mostrarImagenCapturada()
def visualizarVisor(self):
self.stackedWidget.setCurrentIndex(0)
def mostrarImagenCapturada(self):
self.stackedWidget.setCurrentIndex(1)
self.buttonTomarFoto.setEnabled(False)
self.buttonEliminarFoto.setEnabled(True)
self.buttonGuardarFoto.setEnabled(True)
def imagenGuardada(self, id, nombreFoto):
if QFile.exists(nombreFoto):
remove(nombreFoto)
def eliminarFoto(self):
self.estadoFoto = False
self.byteArrayFoto.clear()
self.labelFoto.clear()
self.actualizarEstadoCamara(self.camara.state())
self.visualizarVisor()
def guardarFoto(self):
guardarComo, extension = QFileDialog.getSaveFileName(
self,
"Guardar como",
"Foto",
"JPG (*.jpg);;PNG (*.png);;ICO (*.ico);;BMP (*.bmp)",
options=QFileDialog.Options())
if guardarComo:
foto = QPixmap()
foto.loadFromData(self.byteArrayFoto, "PNG", Qt.AutoColor)
foto.save(guardarComo, quality=100)
QMessageBox.information(
self, "Guardar foto",
"Foto guardada con éxito ")
self.eliminarFoto()
class Ui_selectVideo(object):
def openFtoAWindow(self):
self.Window = QtWidgets.QWidget()
self.ui = addFaceToAnalyze.AFTA_Ui_Form()
self.ui.setupUi(self.Window)
self.ui.getVideo(video=self.video)
self.Window.show()
self.widget.hide()
def getVideo(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(None,
"Select Video",
options=options)
if fileName:
'''vidcap = cv2.VideoCapture(fileName)
total = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
num = total/2
vidcap.set(cv2.CAP_PROP_POS_MSEC,num)
success,image = vidcap.read()'''
shortenedFileName = self.getShortenedFilename(fileName)
self.movieImageLabel.setPixmap(QtGui.QPixmap())
self.movieImageLabel.clear()
self.movieImageLabel.setGeometry(QtCore.QRect(140, 240, 201, 201))
self.movieImageLabel.setStyleSheet("border: 1px solid black;")
self.movieImageLabel.setAlignment(QtCore.Qt.AlignCenter)
font = QtGui.QFont()
font.setPointSize(20)
self.movieImageLabel.setFont(font)
self.movieImageLabel.setText(shortenedFileName)
self.pushButton_2.setEnabled(True)
self.video = fileName
def getShortenedFilename(self, filename):
temp = ""
i = len(filename) - 1
while i > 0:
if (filename[i] == '/' or filename[i] == '\\'):
return temp
temp = filename[i] + temp
i -= 1
return temp
def setupUi(self, selectVideo):
selectVideo.setObjectName("selectVideo")
selectVideo.resize(508, 584)
self.label = QtWidgets.QLabel(selectVideo)
self.label.setGeometry(QtCore.QRect(90, 40, 331, 61))
font = QtGui.QFont()
font.setPointSize(24)
self.label.setFont(font)
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.label.setObjectName("label")
self.pushButton = QtWidgets.QPushButton(selectVideo)
self.pushButton.setGeometry(QtCore.QRect(140, 160, 201, 41))
self.pushButton.setObjectName("pushButton")
self.pushButton.clicked.connect(self.getVideo)
self.pushButton_2 = QtWidgets.QPushButton(selectVideo)
self.pushButton_2.setGeometry(QtCore.QRect(140, 490, 201, 41))
self.pushButton_2.setCheckable(False)
self.pushButton_2.setObjectName("pushButton_2")
self.pushButton_2.clicked.connect(self.openFtoAWindow)
self.pushButton_2.setEnabled(False)
self.movieImageLabel = QtWidgets.QLabel(selectVideo)
self.movieImageLabel.setGeometry(QtCore.QRect(160, 240, 211, 201))
self.movieImageLabel.setText("")
self.movieImageLabel.setPixmap(QtGui.QPixmap("../camera.jpg"))
self.movieImageLabel.setObjectName("movieImageLabel")
self.video = QVideoWidget()
self.video.resize(300, 300)
self.video.move(0, 0)
self.player = QMediaPlayer()
self.player.setVideoOutput(self.video)
self.retranslateUi(selectVideo)
QtCore.QMetaObject.connectSlotsByName(selectVideo)
self.widget = selectVideo
def retranslateUi(self, selectVideo):
_translate = QtCore.QCoreApplication.translate
selectVideo.setWindowTitle(_translate("selectVideo", "Form"))
self.label.setText(_translate("selectVideo", "Select a video"))
self.pushButton.setText(_translate("selectVideo", "Select"))
self.pushButton_2.setText(_translate("selectVideo", "Continue"))
class Ui_MainWindow(object):
def __init__(self):
self.timer_thread = TimerThread()
self.timer_thread.update_signal.connect(self.update_lcd)
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
self.rpi.handlesignalend(self.cleanup_revpi)
self.rpi.io.I_1.reg_event(toggle_input, prefire=True)
self.rpi.io.I_1.reg_event(self.send_toggle_signal)
def setup_ui(self, MainWindow):
MainWindow.setObjectName("KnockOutMachine")
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.main_picture = QtWidgets.QLabel(self.centralwidget)
self.pixmap = QtGui.QPixmap("display/main_menu.png")
self.scaledPixmap = self.pixmap.scaled(900, 900, QtCore.Qt.KeepAspectRatio)
self.main_picture.setPixmap(self.scaledPixmap)
self.pictures = QtWidgets.QLabel()
self.pictures.setObjectName("pictures")
self.pictures.setAlignment(QtCore.Qt.AlignCenter)
self.pictures.setMinimumSize(500, 500)
self.pictures.hide()
self.player = QtMultimedia.QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.video_frame = QVideoWidget()
self.video_frame.resize(960, 540)
self.video_frame.hide()
palette = QtGui.QPalette()
palette.setColor(QtGui.QPalette.Text, QtCore.Qt.white)
mfont = QtGui.QFont("Times", 80, QtGui.QFont.Bold)
self.messages = QtWidgets.QLineEdit(self.centralwidget)
self.messages.setObjectName("messages")
self.messages.setAlignment(QtCore.Qt.AlignCenter)
self.messages.setPalette(palette)
self.messages.setReadOnly(True)
self.messages.setFont(mfont)
self.messages.setFixedSize(1400, 200)
self.messages.hide()
self.model = QtGui.QStandardItemModel(self.centralwidget)
tableFont = QtGui.QFont("Times", 16)
self.tableview = QtWidgets.QTableView(self.centralwidget)
self.tableview.setObjectName("tableView")
self.tableview.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
self.tableview.setMaximumWidth(500)
self.tableview.setMaximumHeight(900)
self.tableview.verticalHeader().setDefaultSectionSize(85)
self.tableview.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
self.tableview.setFont(tableFont)
self.tableview.setModel(self.model)
self.tableview.hide()
self.input_window = QtWidgets.QWidget()
self.input_window.setWindowTitle("Bitte Namen eingeben")
self.input_window.resize(300, 100)
self.input_window.move(850, 820)
# self.input_window.setWindowFlags(
# QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowStaysOnTopHint)
self.input_window.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.input_layout = QtWidgets.QFormLayout()
self.input_dialogue = QtWidgets.QLineEdit(self.centralwidget)
self.input_dialogue.setMaxLength(30)
buttonFont = QtGui.QFont("Times", 16, QtGui.QFont.Bold)
self.startButton = QtWidgets.QPushButton(self.centralwidget)
self.startButton.setFixedSize(191, 71)
self.startButton.setFont(buttonFont)
self.startButton.setObjectName("startButton")
self.startButton.clicked.connect(lambda: self.on_start_button_clicked())
self.inputButton = QtWidgets.QPushButton(self.centralwidget)
self.inputButton.setObjectName("inputButton")
self.inputButton.resize(self.inputButton.sizeHint())
self.inputButton.setDisabled(True)
self.highscoreButton = QtWidgets.QPushButton(self.centralwidget)
self.highscoreButton.setFont(buttonFont)
self.highscoreButton.setObjectName("highscoreButton")
self.highscoreButton.setFixedSize(191, 71)
self.highscoreButton.clicked.connect(lambda: self.on_high_score_button_clicked())
self.cancelTimerButton = QtWidgets.QPushButton(self.centralwidget)
self.cancelTimerButton.setFont(buttonFont)
self.cancelTimerButton.setObjectName("cancelTimerButton")
self.cancelTimerButton.setFixedSize(191, 71)
self.cancelTimerButton.clicked.connect(lambda: self.exit_timer_function())
self.cancelTimerButton.hide()
self.cancelScoreButton = QtWidgets.QPushButton(self.centralwidget)
self.cancelScoreButton.setFont(buttonFont)
self.cancelScoreButton.setObjectName("cancelScoreButton")
self.cancelScoreButton.setFixedSize(191, 71)
self.cancelScoreButton.clicked.connect(lambda: self.exit_score_function())
self.cancelScoreButton.hide()
self.lcdCounter = QtWidgets.QLCDNumber(self.centralwidget)
self.lcdCounter.setEnabled(False)
self.lcdPalette = self.lcdCounter.palette()
self.lcdCounter.setFixedSize(1350, 750)
self.lcdCounter.setSmallDecimalPoint(False)
self.lcdCounter.setDigitCount(5)
self.lcdCounter.setObjectName("lcdCounter")
self.lcdCounter.display("00.00")
self.lcdCounter.hide()
self.glass_not_set_timer, self.glass_set_timer = QtCore.QTimer(), QtCore.QTimer()
self.glass_set_timer.setSingleShot(True)
self.glass_set_timer.setInterval(100)
self.glass_set_timer.timeout.connect(self.glass_set)
self.glass_not_set_timer.setSingleShot(True)
self.glass_not_set_timer.setInterval(100)
self.glass_not_set_timer.timeout.connect(self.glass_not_set)
self.vboxPictures = QtWidgets.QVBoxLayout()
self.vboxPictures.addWidget(self.main_picture, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.lcdCounter, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.messages, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.pictures, 1)
self.vboxPictures.addWidget(self.video_frame, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.tableview, 0, QtCore.Qt.AlignCenter)
self.hboxButtons = QtWidgets.QHBoxLayout()
self.hboxButtons.addWidget(self.startButton)
self.hboxButtons.addWidget(self.highscoreButton)
self.hboxButtons.addWidget(self.cancelTimerButton)
self.hboxButtons.addWidget(self.cancelScoreButton)
self.input_layout.addRow("", self.input_dialogue)
self.input_layout.addRow("", self.inputButton)
self.input_window.setLayout(self.input_layout)
self.vbox = QtWidgets.QVBoxLayout()
self.vbox.addLayout(self.vboxPictures)
self.vbox.addStretch(1)
self.vbox.addLayout(self.hboxButtons)
self.vbox.addStretch(1)
self.input_dialogue.textChanged.connect(self.enable_input_button)
self.input_dialogue.returnPressed.connect(self.inputButton.click)
self.inputButton.clicked.connect(lambda: self.update_scores(self.input_dialogue.text(), runTime))
self.inputButton.clicked.connect(lambda: self.input_window.close())
self.inputButton.clicked.connect(lambda: self.exit_timer_function())
self.centralwidget.setLayout(self.vbox)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
locale.setlocale(locale.LC_ALL, '')
self.retranslate_ui(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslate_ui(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("KnockOutMachine", "KnockOutMachine"))
MainWindow.showFullScreen()
MainWindow.setStyleSheet("background-color: #113f0c;")
self.startButton.setText(_translate("KnockOutMachine", "Messung starten"))
self.startButton.setStyleSheet("background-color: white;")
self.inputButton.setText(_translate("KnockOutMachine", "Eingabe bestätigen"))
self.messages.setStyleSheet("border: none;")
self.highscoreButton.setText(_translate("KnockOutMachine", "Bestenliste"))
self.highscoreButton.setStyleSheet("background-color: white;")
# self.cancelButton.setText(_translate("KnockOutMachine", "Abbrechen"))
self.cancelTimerButton.setIcon(QtGui.QIcon("display/cancel_button.png"))
self.cancelTimerButton.setIconSize(QtCore.QSize(50, 50))
self.cancelTimerButton.setStyleSheet("background-color: white;")
self.cancelScoreButton.setIcon(QtGui.QIcon("display/cancel_button.png"))
self.cancelScoreButton.setIconSize(QtCore.QSize(50, 50))
self.cancelScoreButton.setStyleSheet("background-color: white;")
self.lcdCounter.setStyleSheet("background-color: #113f0c;")
self.lcdCounter.setStyleSheet("color: white;")
self.tableview.setStyleSheet("background-color: white;")
def enable_input_button(self):
if len(self.input_dialogue.text()) > 0:
self.inputButton.setDisabled(False)
else:
self.inputButton.setDisabled(True)
def on_start_button_clicked(self):
self.lcdCounter.display("00.00")
self.movie = QtGui.QMovie("")
self.lcdCounter.setEnabled(True)
self.lcdCounter.show()
self.cancelTimerButton.show()
self.startButton.hide()
self.highscoreButton.hide()
self.main_picture.hide()
self.rpi.mainloop(blocking=False)
if Input_I1:
self.glass_not_set()
else:
self.glass_set()
def on_high_score_button_clicked(self):
self.highscoreButton.hide()
self.startButton.setDisabled(True)
self.startButton.hide()
self.main_picture.hide()
self.video_frame.hide()
self.cancelScoreButton.show()
self.tableview.show()
self.model.clear()
self.model.setHorizontalHeaderLabels(['Name', 'Zeit in Sekunden'])
self.model.setHeaderData(0, QtCore.Qt.Horizontal, QtCore.Qt.AlignJustify, QtCore.Qt.TextAlignmentRole)
self.delimiter = ';'
try:
with open('timeList.csv', 'r') as timeFile:
reader = csv.reader(timeFile, delimiter=self.delimiter)
reader = [[x.replace(',', '.') for x in l] for l in reader]
highscore_list_sorted = sorted(reader, key=lambda x: float(x[1]))[:10]
for row in highscore_list_sorted:
times = [
QtGui.QStandardItem(field.replace(".", ","))
for field in row
]
self.model.appendRow(times)
self.tableview.setColumnHidden(2, True)
except FileNotFoundError:
print("Timelist File does not exist")
def glass_not_set(self):
self.glass_not_set_timer.start()
self.messages.show()
self.messages.setText("Bitte Glas vor Sensor stellen!")
if not Input_I1:
self.glass_not_set_timer.stop()
self.glass_set()
def glass_set(self):
self.glass_set_timer.start()
self.messages.show()
self.messages.setText("Glas erkannt, wenn bereit los!")
if Input_I1:
self.glass_set_timer.stop()
self.start_timer()
def start_timer(self):
self.messages.hide()
# self.pictures.setMovie(self.movie)
# self.lcdCounter.display(runTime)
self.timer_thread.start()
def update_lcd(self):
self.lcdCounter.display(runTime)
def update_scores(self, inputName, runTime):
self.datetime = QtCore.QDateTime.currentDateTime()
self.delimiter = ';'
row = [inputName, runTime.replace(".", ","), self.datetime.toString(QtCore.Qt.DefaultLocaleShortDate)]
with open('timeList.csv', 'a', newline='') as timeFile:
writer = csv.writer(timeFile, delimiter=self.delimiter)
writer.writerow(row)
self.input_dialogue.clear()
def play_sound(self, fileName, playVideo):
if playVideo:
self.file_path = "/var/lib/revpipyload/KnockOutMachine/display/" + fileName
self.video_frame.show()
self.player.setVideoOutput(self.video_frame)
self.player.setPosition(0)
else:
self.file_path = "/var/lib/revpipyload/KnockOutMachine/sounds/" + fileName
self.url = QtCore.QUrl.fromLocalFile(self.file_path)
self.content = QtMultimedia.QMediaContent(self.url)
self.player.setMedia(self.content)
self.player.play()
def show_pictures(self, runTime):
self.messages.hide()
self.lcdCounter.setFixedSize(1050, 450)
self.play_video = False
if runTime <= 200:
self.file_name = "cheering.mp3"
self.rand = randint(0, 2)
self.case = lambda x: self.rand < x
#if self.case(1):
self.pictures.show()
self.movie = QtGui.QMovie("display/Trump.gif")
#else:
#self.file_name = "endlich_normale_leute.mp4"
#self.play_video = True
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
elif runTime <= 500:
self.file_name = "applause-2.mp3"
self.rand = randint(0, 6)
self.case = lambda x: self.rand < x
if self.case(1):
self.pictures.show()
self.movie = QtGui.QMovie("display/Bier.gif")
elif self.case(2):
self.pictures.show()
self.movie = QtGui.QMovie("display/2.gif")
elif self.case(3):
self.pictures.show()
self.movie = QtGui.QMovie("display/3.gif")
elif self.case(4):
self.pictures.show()
self.movie = QtGui.QMovie("display/4.gif")
elif self.case(5):
self.pictures.show()
self.movie = QtGui.QMovie("display/5.gif")
else:
self.pictures.show()
self.movie = QtGui.QMovie("display/6.gif")
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
elif runTime <= 800:
self.file_name = "laughter-2.mp3"
self.rand = randint(0, 2)
self.case = lambda x: self.rand < x
if self.case(1):
self.pictures.show()
self.movie = QtGui.QMovie("display/Bier2.gif")
else:
self.pictures.show()
self.movie = QtGui.QMovie("display/1.jpeg")
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
else:
self.pictures.show()
self.file_name = "laughter-2.mp3"
self.movie = QtGui.QMovie("display/dog.gif")
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
# TODO toggle outputs in certain pattern
def change_output(self, highscore):
# red leds
if highscore:
self.rpi.io.O_5 = True
self.rpi.io.O_6 = True
self.rpi.io.O_7 = True
t_end = time.time() + 10
while time.time() < t_end:
self.rpi.io.O_1 = not self.rpi.io.O_1
self.rpi.io.O_2 = not self.rpi.io.O_2
self.rpi.io.O_3 = not self.rpi.io.O_3
def send_toggle_signal(self, ioname, iovalue):
self.timer_thread.toggle_signal.emit()
def exit_score_function(self):
self.tableview.hide()
self.cancelScoreButton.hide()
self.pictures.hide()
self.highscoreButton.show()
self.startButton.setEnabled(True)
self.startButton.show()
self.main_picture.show()
def exit_timer_function(self):
self.rpi.exit(full=False)
self.timer_thread.stop_timer_signal.emit()
self.glass_set_timer.stop()
self.glass_not_set_timer.stop()
self.player.stop()
self.lcdCounter.setEnabled(False)
self.lcdCounter.hide()
self.lcdCounter.setFixedSize(1350, 750)
self.tableview.hide()
self.video_frame.hide()
self.cancelTimerButton.hide()
self.messages.hide()
self.pictures.hide()
self.highscoreButton.show()
self.startButton.setEnabled(True)
self.startButton.show()
self.main_picture.show()
# TODO add cleanup if necessary
def cleanup_revpi(self):
return None
