438 lines
13 KiB
Python
438 lines
13 KiB
Python
import sqlite3
|
|
import time
|
|
import threading
|
|
import tkinter
|
|
from turtle import left, width
|
|
import User
|
|
import sys
|
|
import tkinter as tk
|
|
from direct import task
|
|
from tkinter import Scale, StringVar
|
|
from random import random
|
|
|
|
#TODO Klassen erstellten
|
|
|
|
def button_event_close():
|
|
print("Programm wird geschlossen")
|
|
|
|
return 0;
|
|
|
|
def guithread():
|
|
|
|
window_size_x = 1024
|
|
window_size_y = 786
|
|
|
|
label_logged_in = tk.Label
|
|
label_highscore = tk.Label
|
|
label_lastlogin = tk.Label
|
|
|
|
|
|
#Hauptfenster-Block
|
|
window1 = tk.Tk() #Instanzierung von Fensterelement
|
|
window1.wm_title("Snake v1.0")
|
|
window1.geometry("1024x768")
|
|
window1.attributes("-topmost", True)
|
|
|
|
|
|
print("Erstelle User-Klassen Objekt")
|
|
us = User.User()
|
|
|
|
#Mit der Parameterübergabe der Klasseninstantz Tk, kann auch in einer Methode oder Funktion die Instantz direkt manipuliert werden!
|
|
def mainwindow_test(mainwindow : tk.Tk):
|
|
mainwindow.quit()
|
|
pass
|
|
|
|
def close_mainwindow():
|
|
print("Programm wird geschlossen!")
|
|
window1.quit()
|
|
|
|
def read_user(username, schaltf2:tk.Label, label_user_exists:tk.Label, all_listed_radiob:list): #Eingabeprüfung, bei Exception bei leerem String oder Eingabefeld
|
|
unametemp = username #eingabefeld_wert.get()
|
|
if(len(unametemp) != 0):
|
|
print("Lese Nutzereingabe: ", unametemp, "\n")
|
|
if(us.select(unametemp) == True):
|
|
welcome_msg = "Willkommen, " + us.getusername()
|
|
highscore_msg = "Dein letzter Highscore lag bei: " + str(us.gethighscore()) + " Punkten"
|
|
lastlogin_msg = "Du warst das letzte Mal am: " + us.getlastlogin() + " am Spielen"
|
|
label_logged_in = tk.Label(window1, text=welcome_msg)
|
|
label_highscore = tk.Label(window1, text=highscore_msg)
|
|
label_lastlogin = tk.Label(window1, text=lastlogin_msg)
|
|
label_logged_in.place(x=180, y=50)
|
|
label_highscore.place(x=180, y=80)
|
|
label_lastlogin.place(x=180, y=110)
|
|
label_user_exists.destroy()
|
|
schaltf2.destroy()
|
|
|
|
#Zerstört alle gezeichneten Insantzen von Radiobuttons
|
|
for radiobutton in all_listed_radiob:
|
|
radiobutton.destroy()
|
|
return
|
|
else:
|
|
print("Bitte etwas eingeben... Das Feld war leer!")
|
|
return
|
|
|
|
def input_new_user(*events):
|
|
|
|
#Eingabefenster-Block
|
|
subwindow1 = tk.Toplevel(window1)
|
|
subwindow1.wm_title("Eingabe")
|
|
subwindow1.geometry("400x200")
|
|
subwindow1.resizable(0,0) #Blockiert ein Skalieren des Fensters
|
|
window1.attributes("-topmost", False)
|
|
subwindow1.attributes("-topmost", True)
|
|
subwindow1.lift() #Hebt das Child-Fenster zumsammen mit attributes in den Vordergrund
|
|
|
|
|
|
eingabewert = StringVar(subwindow1)
|
|
def check_input():
|
|
if(len(eingabewert.get()) <= 0):
|
|
print("Es wurde keine Eingabe gemacht!")
|
|
else:
|
|
print(eingabewert.get())
|
|
us.createuser(eingabewert.get())
|
|
subwindow1.destroy()
|
|
build_mainwindow(window1)
|
|
return
|
|
|
|
textlabel = tk.Label(subwindow1, text="Bitte gib deinen Benutzernamen ein: ")
|
|
label_new_user = tk.Entry(subwindow1, width=40, textvariable=eingabewert)
|
|
button_ok = tk.Button(subwindow1, text="Erstellen", height=1, width=10, command=check_input)
|
|
button_abort = tk.Button(subwindow1, text="Abbrechen", command=subwindow1.destroy)
|
|
|
|
textlabel.place(x=5, y=5)
|
|
label_new_user.place(x=6, y=25)
|
|
button_ok.place(x=5, y=150)
|
|
button_abort.place(x=140, y=150)
|
|
#label_new_user.place(x=window_size_x*0.25, y=window_size_y*0.6)
|
|
|
|
def build_mainwindow(window1 : tk.Tk):
|
|
#Programmüberschrift
|
|
label1 = tk.Label(window1, text="Snake v1.0 written by CB") #Fenster Funktion für Textausgabe
|
|
label1.grid(row=0, column=0)
|
|
#Schaltflächen und Buttons
|
|
schaltf1 = tk.Button(window1, text="Fenster schließen", command=close_mainwindow)
|
|
schaltf1.place(x=5, y=window_size_y-50)
|
|
|
|
aktuell_ausgewaehlt =""
|
|
|
|
|
|
|
|
if(us.checkuserdb() == False):
|
|
#Anmeldedialog
|
|
print("Noch kein Nutzer angelegt!")
|
|
#messagebox.Message(master=None, message="Es wurde noch kein Spieler angelegt!", type=messagebox.OK, icon=messagebox.WARNING).show()
|
|
input_new_user()
|
|
|
|
elif(us.checkuserdb() == True):
|
|
print("Nutzer bereits vorhanden, wähle einen aus!")
|
|
#us.listallusers()
|
|
|
|
users = us.listallusers()
|
|
ausgewaehlt = tk.StringVar()
|
|
|
|
ausgewaehlt.set(0)
|
|
def value_select():
|
|
aktuell_ausgewaehlt = str(ausgewaehlt.get())
|
|
print(aktuell_ausgewaehlt)
|
|
return 0
|
|
|
|
print (aktuell_ausgewaehlt)
|
|
|
|
all_listed_radiob = list()
|
|
|
|
i = 0
|
|
for einzelwert in users:
|
|
radiob = tk.Radiobutton(window1, text=einzelwert, value=einzelwert, variable=ausgewaehlt, command=value_select)
|
|
all_listed_radiob.append(radiob)
|
|
print (users)
|
|
radiob.place(x=5, y=150+i)
|
|
i+=30
|
|
|
|
print("Alle Radiobuttons gesetzt!")
|
|
|
|
def login_user():
|
|
print("Melde ausgewählten Nutzer an!\n")
|
|
read_user(ausgewaehlt.get(), schaltf2, label_user_exists, all_listed_radiob)
|
|
return 0
|
|
|
|
label_user_exists = tk.Label(window1, text="Wähle deinen Spieler aus: ")
|
|
label_user_exists.place(x=2, y=30)
|
|
#eingabefeld_wert=tk.StringVar()
|
|
|
|
#eingabefeld=tk.Entry(window1, textvariable=eingabefeld_wert)
|
|
#eingabefeld.place(x=2, y=80)
|
|
schaltf2 = tk.Button(window1, text="Auswählen", command=login_user)
|
|
schaltf2.place(x=150, y=75)
|
|
|
|
build_mainwindow(window1)
|
|
|
|
#Nützliches Feature um zeitgesteuerte Events in Mainloop ausführen zu können
|
|
def message():
|
|
print('Keep yourself hyderated.')
|
|
window1.after(2000, message)
|
|
|
|
#window1.after(2000, message)
|
|
window1.mainloop() #Hauptschleife für gezeichnetes Fenster
|
|
us.__del__() #Stellt sicher, dass User-Klassenobjekt im korrekten Thread beendet wird
|
|
return 0;
|
|
|
|
|
|
|
|
class woscht(User.User):
|
|
def __init__(self) -> None:
|
|
UserInstanz = User
|
|
print("Unterklasser der Userklasse erstellt!\n")
|
|
print("So funktioniert die Klassenvererbung in Python...")
|
|
print("Dies ermöglicht eine modulare Aufbauweise ohne sich ständig bei kleineren Abweichung wiederholen zu müssen ober ganze Abschnitte zu kopieren und einzufügen\n")
|
|
|
|
def Testfunkiton(self):
|
|
print("Das ist eine Funktion, welche ausgeführt wird in einer Kindklasse. Sie existiert nicht in der Elternklasse!\n")
|
|
pass
|
|
def Testfunktion2(self):
|
|
print("Weitere Funktion, welche bei initialisieren der Klasse aufgerufen wird.\n")
|
|
pass
|
|
|
|
class woscht2(woscht):
|
|
def __init__(self) -> None:
|
|
woscht().Testfunktion2()
|
|
print("Unterklasse der Woschtklasse\n")
|
|
print("Die stellt eine Vererbung auf eine Vererbung dar. Hier können weitere Ergänzungen vorgenommen werden\n")
|
|
pass
|
|
|
|
#Eine Schleife, welche unter Zuhilfenahme einer Rekursion entsteht.
|
|
def recursive(zahl):
|
|
if(zahl==100):
|
|
print("Vorgang abgeschlossen!")
|
|
return
|
|
elif(zahl <= 100):
|
|
zahl += 1
|
|
time.sleep(0.001)
|
|
print(zahl, end="\r")
|
|
return recursive(zahl)
|
|
else:
|
|
print("Ergeniss konnte nicht erreicht werden!")
|
|
return
|
|
|
|
|
|
def main():
|
|
#t = threading.Thread(target=guithread ,args=())
|
|
#t.start()
|
|
#recursive(0)
|
|
#while(True):
|
|
# pass
|
|
|
|
"""
|
|
test = woscht()
|
|
test.getusername()
|
|
|
|
test2 = woscht2()
|
|
test2.Testfunkiton()
|
|
|
|
testtu = list()
|
|
|
|
#Mit dieser Funktion können mehrer Instanzen einer KLasse erstellt werden und im späteren Verlauf über den Listenindex bearbeitet werden.
|
|
for i in range(5):
|
|
testtu.append(woscht2())
|
|
|
|
print("Es wurden folgenden Klassen erstellt: ")
|
|
print (len(testtu))
|
|
|
|
|
|
for i in testtu:
|
|
print(i)
|
|
"""
|
|
|
|
|
|
# FH = open("user.txt", "w")
|
|
# FH.write(us.getusername())
|
|
# FH.close()
|
|
time.sleep(1)
|
|
|
|
return 0
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
|
|
from math import pi, sin, cos
|
|
|
|
from direct.showbase.ShowBase import ShowBase
|
|
from direct.task import Task
|
|
from direct.actor.Actor import Actor
|
|
from direct.interval.IntervalGlobal import Sequence
|
|
from panda3d.core import Point3
|
|
from panda3d.core import WindowProperties
|
|
from panda3d.core import Loader
|
|
|
|
|
|
|
|
#class Game(ShowBase):
|
|
# def __init__(self):
|
|
# ShowBase.__init__(self)
|
|
# properties = WindowProperties()
|
|
# properties.setSize(1024, 768)
|
|
# properties.setTitle("Snake v1 written by CB")
|
|
# properties.setUndecorated(False)
|
|
# self.win.requestProperties(properties)
|
|
|
|
# self.scene = self.loader.loadModel("models/environment")
|
|
# self.scene.reparentTo(self.render)
|
|
# self.pandaActor = Actor("models/panda-model",
|
|
# {"walk": "models/panda-walk4"})
|
|
# self.pandaActor.reparentTo(self.render)
|
|
|
|
|
|
|
|
#game = Game()
|
|
#game.run()
|
|
|
|
from direct.showbase.ShowBase import ShowBase #Grundmodul zum Starten eines Fenster mit Grundszene
|
|
from direct.gui.OnscreenText import OnscreenText #Ermöglicht die direkte Einblendung von Texten
|
|
from direct.gui.DirectGui import * #Ermöglicht das Einblenden von Menüs und deren Manipulation
|
|
from panda3d.core import TextNode #Texte
|
|
from direct.task import Task
|
|
|
|
from panda3d.core import loadPrcFile #Ermöglicht das Laden eigener Konfigurationsdatein zur Panda3D API
|
|
loadPrcFile("conf/conf.prc") #Pfadangabe zum .prc File
|
|
|
|
|
|
class User_login:
|
|
__username = str()
|
|
__us = User.User
|
|
__btn = DirectButton
|
|
def __init__(self, username:str(), us:User.User, btn:DirectButton) -> None:
|
|
print("Loginklasse erstellt")
|
|
self.__btn = btn
|
|
self.__us=us
|
|
self.__username=username
|
|
|
|
def user_select(self):
|
|
print("Wähle Spieler aus: "+self.__username)
|
|
if(self.__us.select(self.__username) == True):
|
|
print("Spieler " + self.__us.getusername() + " wurde angelegt")
|
|
print("Dein letzter Highscore: " + str(self.__us.gethighscore()))
|
|
print("Dein letzter Login: " + self.__us.getlastlogin())
|
|
|
|
print(self.__btn)
|
|
self.__btn.destroy()
|
|
#self.__btn.clearText(self.__btn)
|
|
def setButtonObject(self, btn:DirectButton):
|
|
self.__btn = btn
|
|
print(self.__btn)
|
|
|
|
class MyApp(ShowBase):
|
|
|
|
us = User.User
|
|
|
|
def button_select_click(self, *username:str()):
|
|
__username = username
|
|
def button_select_click_login(self):
|
|
print(self.__username)
|
|
|
|
def __init__(self):
|
|
ShowBase.__init__(self) #Insantziert das Hauptfenster, diese stellen immer eine Instanz der ShowBase-Klasse dar
|
|
|
|
def button_enter_pressed():
|
|
print("Die Taste Enter wurde gedrückt!")
|
|
#print(label_input.get())
|
|
us.createuser(label_input.get())
|
|
self.destroy()
|
|
def user_select_button():
|
|
print("Spielerauswahl-Button wurde gedrückt!")
|
|
|
|
us = User.User()
|
|
#Erstellt ein DialogFenster
|
|
self.gameOverScreen = DirectDialog(frameSize = (-0.7, 0.7, -0.7, 0.7),
|
|
fadeScreen = 0.4,
|
|
relief = DGG.FLAT)
|
|
|
|
#Erstellt einen Button zum Parent-Dialogfenster
|
|
self.btn = DirectButton(text = "Quit",
|
|
command = self.quit,
|
|
pos = (0.3, 0, -0.2),
|
|
parent = self.gameOverScreen,
|
|
scale = 0.09)
|
|
|
|
label_menu = DirectDialog(text="Hauptmenü", parent=self.gameOverScreen, scale = 1, pos=(0,0,0.5))
|
|
if(us.checkuserdb() == False):
|
|
#label_enter_name_msg = DirectDialog(parent=self.gameOverScreen, text="Gib deinen Namen ein:", scale=0.05, pos=(-0.6, 0.5,0))
|
|
label_input = DirectEntry(parent=self.gameOverScreen, text="Name", width=15, scale = 0.05, pos=(-0.6,0.5,0), relief=DGG.SUNKEN)
|
|
|
|
elif(us.checkuserdb() == True):
|
|
pos_button_x = 0
|
|
pos_button_y = 0
|
|
for users in us.listallusers():
|
|
label_users = DirectButton
|
|
u = User_login(str(users), us, label_users)
|
|
label_users = DirectButton(text=str(users), command=u.user_select, parent=self.gameOverScreen, scale=0.09, pos=(-0.5,0,pos_button_y))
|
|
print(label_users)
|
|
u.setButtonObject(label_users)
|
|
#selected_user += str(users)
|
|
pos_button_y -= 0.2
|
|
|
|
#self.taskMgr.doMethodLater(0.2,self.exampleTask, "exampleTask") #Hängt einen zustäzlichen Task in den Taskmanager ein
|
|
|
|
self.gameOverScreen.show()
|
|
|
|
# Create scene 1
|
|
self.scene1_background = self.loader.loadModel("data/panda_example/Environment/environment")
|
|
self.scene1_background.reparentTo(self.render)
|
|
self.scene1 = self.render.attachNewNode("Scene 1")
|
|
self.scene1_text = OnscreenText(text="Scene 1", pos=(0, 0), scale=0.1, align=TextNode.ACenter)
|
|
if(us.checkuserdb() == False):
|
|
self.accept('enter', button_enter_pressed)
|
|
self.scene1_text.show()
|
|
|
|
|
|
# Create scene 2
|
|
self.scene2 = self.render.attachNewNode("Scene 2")
|
|
self.scene2_text = OnscreenText(text="Scene 2", pos=(0, 0), scale=0.1, align=TextNode.ACenter)
|
|
self.scene2_text.hide()
|
|
|
|
# Create toggle text
|
|
self.toggle_text = OnscreenText(text="Toggle Scene: [SPACE] if it works!", pos=(0, -0.9), scale=0.08, align=TextNode.ACenter)
|
|
|
|
# Set initial scene
|
|
self.current_scene = 1
|
|
|
|
# Set key bindings
|
|
self.accept('space', self.toggle_scene)
|
|
self.accept('escape', self.quit)
|
|
|
|
# Position and orient the camera
|
|
self.camera.setPos(0, -10, 0) # Set camera position
|
|
self.camera.lookAt(0, 0, 0) # Point camera towards the origin
|
|
"""
|
|
for i in range(5):
|
|
time.sleep(3)
|
|
label_menu['text'] = "WOSCHT" + str(i)"""
|
|
|
|
|
|
def toggle_scene(self):
|
|
if self.current_scene == 1:
|
|
self.scene1_text.hide()
|
|
self.scene2_text.show()
|
|
self.current_scene = 2
|
|
else:
|
|
self.scene2_text.hide()
|
|
self.scene1_text.show()
|
|
self.current_scene = 1
|
|
|
|
def quit(self):
|
|
#self.taskMgr.destroy() #Bereitet unter Linux Probleme
|
|
#self.us.__del__(self.us)
|
|
app.finalizeExit()
|
|
|
|
|
|
#Dieser Task wird bei Berechnungs jeden Frames ausgeführt
|
|
"""
|
|
x=0
|
|
def exampleTask(self, task):
|
|
self.btn['text'] = "Woscht" + str(self.x)
|
|
if(self.x==200):
|
|
return task.done
|
|
self.x +=1
|
|
return task.again
|
|
"""
|
|
app = MyApp()
|
|
app.run()
|