Changed Projectstructure + Some changes on pygame-test

Added Username function
Added Gameobjectposition lastframe
Added prototype function  stepping_movement
Code cleanup

SnakeTest.py

@@ -1,5 +1,5 @@
-import Game
+import modules.Game as Game
-import User
+import modules.User as User
 import Controls
 import subprocess
 

gui-tests.py

@@ -4,7 +4,7 @@ import time
 import threading
 import tkinter
 from turtle import left, width
-import User
+import modules.User as User
 import sys
 import tkinter as tk
 from direct import task

modules/Game.py

@@ -1,5 +1,5 @@
-import User
+import modules.User as User
-import Statics
+import modules.Statics as Statics
 import Controls
 
 from math import pi, sin, cos

pygame-tests/User.py

@@ -0,0 +1,130 @@
+import sqlite3
+
+#from sqlite3.dbapi2 import Cursor
+
+# Start einer Userklasse
+# Lade, sofern vorhanden, Spieler aus der Datenbank
+
+
+class User:
+	__usercount = 0
+	__highscore = 0
+	__uid = -1
+	__username = ""
+	__db_player_exist = 0
+	__lastlogin = ""
+	__played_time = 0
+	__all_listed_users = list()	
+	#__sql_create_table = "CREATE TABLE IF NOT EXISTS user ( `id` INTEGER PRIMARY KEY, `username` VARCHAR(100) NOT NULL , `highscore` INT NOT NULL)"
+	__sql_create_table = 	"""CREATE TABLE IF NOT EXISTS "user" (
+	"id"	INTEGER UNIQUE,
+	"username"	VARCHAR(100) NOT NULL,
+	"highscore"	INT NOT NULL,
+	"lastlogin"	TEXT,
+	"played_time"	INTEGER,
+	PRIMARY KEY("id")
+);"""
+
+	__sqlhandle = 0 #Statichandle
+
+	def __init__(self) -> None:
+		
+		print("Userklasse erstellt")
+		
+		if(len(self.__username) <= 0 or self.__user == "") and (self.__uid == -1):
+			#print("Es existieren noch keine Daten!")
+
+			if(self.__sqlhandle == 0):
+				self.__sqlhandle = sqlite3.connect("user.db")
+				cursor = self.__sqlhandle.cursor()
+				cursor.execute(self.__sql_create_table)
+				self.__sqlhandle.commit()
+
+	def __del__(self):
+		print("Userklasse zerstört")
+		if(self.__sqlhandle != 0):
+			print(self.__sqlhandle)
+			print("Datenbank wird ordentlich geschlossen\n")
+			self.__sqlhandle.close()
+			#self.__sqlhandle = 0
+			#print(self.__sqlhandle) Debug only
+		
+
+	def createuser(self, username :str):
+		if(len(username) > 0):
+			cursor = self.__sqlhandle.cursor()
+			if(cursor != 0):
+				if(self.__username == ""):
+					print("SQLHANDLE:", self.__sqlhandle)
+					sql = "INSERT INTO user (username, highscore, lastlogin) VALUES('"+username+"', 0, datetime())"
+					try:
+						cursor.execute(sql)
+						self.__sqlhandle.commit()
+						print("User hinzugefügt!")
+					except:
+						print("Es ist beim Erstellen es Spielers ein Fehler aufgetreten!")
+			else:
+				print("Scheinbar besteht keine Verbindung zur Datenbank")
+		else:
+			print("Es wurde kein Name übergeben")
+
+
+	def select(self, username):
+		sql = "SELECT * FROM user WHERE username ='"+username+"'"
+		sql_update_login_date = "UPDATE user SET lastlogin = datetime() WHERE username = '"+username+"'"
+		try:
+			c = self.__sqlhandle.cursor()
+			row = c.execute(sql)
+			res = row.fetchone()
+			c.execute(sql_update_login_date)
+			
+			self.__sqlhandle.commit()
+			self.__uid = res[0]
+			self.__username = res[1]
+			self.__highscore = res[2]
+			self.__lastlogin = res[3]
+			
+		except:
+			print("Fehler bei der Nutzerauswahl")
+			return False
+			
+		return True
+	
+	def getplayed_time(self):
+		return self.__played_time
+	
+	def getlastlogin(self):
+		return self.__lastlogin
+
+	def getusername(self):
+		return self.__username
+
+	
+	def gethighscore(self):
+		return self.__highscore
+
+	def getuid(self):
+		return self.__uid
+
+	def listallusers(self):
+		cursor = self.__sqlhandle.cursor()
+
+		for row in cursor.execute("SELECT * FROM user"):
+			print("ID:",row[0],", Username:", row[1], ", Highscore:", row[2])
+			self.__all_listed_users.append(row[1])
+			print (self.__all_listed_users)
+
+		cursor.close()
+		self.__sqlhandle.commit()
+
+		return self.__all_listed_users
+
+	def checkuserdb(self):
+		cursor = self.__sqlhandle.cursor()
+		rows=cursor.execute("SELECT * FROM user")
+		rows_count =len(list(rows))
+		if(rows_count >= 1):
+			#print("Es gibt", rows_count, "Datensätze")
+			return True
+		else:
+			return False

pygame-tests/pygame-test.py

@@ -46,6 +46,8 @@ class GameObject():
         self.__size_rect_x = rect_size[0]
         self.__size_rect_y = rect_size[1]
         self.count += 1
+        self.__pos_lf_x = 0
+        self.__pos_lf_y = 0
 
         #self.__rectobjekt = rect
 
@@ -86,6 +88,35 @@ class GameObject():
                 self.__pos_x = -self.__size_rect_x        
 
 
+    def move_in_steps(self, *speed:int, steps=10):
+        MOVE_SPEED = 1
+        #self.__rectobjekt.x += MOVE_SPEED
+
+        if(self.__movedirection['up']):
+            if(not speed): self.__pos_y -= MOVE_SPEED
+            else: self.__pos_y -= speed[0]
+            if(self.__pos_y <= -self.__size_rect_y): 
+                self.__pos_y = MAINSCREEN_SIZE[1]
+
+        elif(self.__movedirection['down']):
+            if(not speed): self.__pos_y += MOVE_SPEED
+            else: self.__pos_y += speed[0]
+            if(self.__pos_y >= MAINSCREEN_SIZE[1]): 
+               self.__pos_y = -self.__size_rect_y           
+
+        elif(self.__movedirection['left']):
+            if(not speed): self.__pos_x -= MOVE_SPEED
+            else: self.__pos_x -= speed[0]
+            if(self.__pos_x <= -self.__size_rect_x): 
+                self.__pos_x = MAINSCREEN_SIZE[0]          
+
+        elif(self.__movedirection['right']):
+            if(not speed): self.__pos_x += MOVE_SPEED
+            else: self.__pos_x += speed[0]
+            if(self.__pos_x >= MAINSCREEN_SIZE[0]): 
+                self.__pos_x = -self.__size_rect_x       
+
+        
         #print("Objekt-Koordinaten "+self.__name+"= X: "+str(self.__rectobjekt.x)+" Y: "+str(self.__rectobjekt.y), end="\r")
     
     def draw(self):
@@ -132,6 +163,12 @@ class GameObject():
         self.__pos_x = pos[0]
         self.__pos_y = pos[1]
     
+    def update_pos_lastframe(self,x,y,debug=False):
+        if (debug):
+            print("Letzte Position: " + str((x,y)))
+        self.__pos_lf_x = x
+        self.__pos_lf_y = y
+
     def collide(self, GameObject) -> bool:
         #print(GameObject)
         #print(GameObject.get_rect())
@@ -163,31 +200,29 @@ class Follower(GameObject):
 
     def set_position_player(self, pos:tuple, playermovedirection:list, debug=False):
         if(playermovedirection["up"]):
-            super().set_position((pos[0],pos[1]+60))
+            super().set_position((pos[0],pos[1]+super().get_rect_size()[1]))
             print(pos)
         if(playermovedirection["down"]):
-            super().set_position((pos[0],pos[1]-60))
+            super().set_position((pos[0],pos[1]-super().get_rect_size()[1]))
             print(pos)
         if(playermovedirection["left"]):
-            super().set_position((pos[0]+60,pos[1]))  
+            super().set_position((pos[0]+super().get_rect_size()[0],pos[1]))  
             print(pos)         
         if(playermovedirection["right"]):
-            super().set_position((pos[0]-60,pos[1]))  
+            super().set_position((pos[0]-super().get_rect_size()[0],pos[1]))  
             print(pos) 
-
-        if(debug):
-            print(pos)
-
     def test(self):
         print(super().get_position())
 
-
-
 def start_game():
     menu.disable()
     return 0
 
-def apply_name():
+def apply_name(input):
+    print(input)
+    if(len(input) <= 0):
+        print("Kein Name eingegeben!")
+    else:
         menu.disable()
     #TODO: Add function for save name
     pass
@@ -200,7 +235,7 @@ def append_follwer(x,y):
     colided_objects.append(newfollower)
 
 menu = pygame_menu.Menu("Snake v1.0", 400, 300,)
-menu.add.text_input("Name: ", onreturn=apply_name)
+menu.add.text_input("Name: ", onreturn=(apply_name))
 menu.add.button('Play', start_game)
 menu.add.button('Quit', pygame_menu.events.EXIT)
 menu.mainloop(MAINSCREEN)
@@ -208,7 +243,7 @@ menu.mainloop(MAINSCREEN)
 def spawn_entities(x:int, list_of_objects:list):
     count = 0
     for y in range(x):
-        rect_size = rand.randint(50, 100)
+        rect_size = 60
         Entity = GameObject("Entitiy-"+str(count), rand.randint(1,MAINSCREEN_SIZE[0]), rand.randint(1,MAINSCREEN_SIZE[1]), rand.randint(1,15), is_rect=True, rect_size=(rect_size,rect_size))
         Entity.get_name(True)
         list_of_objects.append(Entity)
@@ -251,8 +286,10 @@ while active == True:
                 Player.change_direction("left")
 
     Player.draw()
+    Player.update_pos_lastframe(Player.get_position()[0], Player.get_position()[1], True)
     Player.move(5)
-    print("Aktuell kollidierte Objekte: ", str(count_hidden_entities))
+    print("Aktuelle Position: " + str(Player.get_position()))
+    #print("Aktuell kollidierte Objekte: ", str(count_hidden_entities))
     #Spawns the Entities
     for y in spawned_entities:
         y:GameObject
@@ -270,13 +307,26 @@ while active == True:
 
     #Zeichnet alle Verfolgerobjekte, sofern sie vorliegend sind
     #TODO: Follower sollen ab dem zweiten Objekt dem vorangegangenen Objekt folgen und nicht dem player
+
+    #if(colided_objects):
+     #   colided_objects[0].set_position_player(Player.get_position(), Player.get_playermovedirection(), True)
+    i=0
+
+    if(colided_objects):
+        pass
+
+    #TODO:Berechne Position follower Objekte anhand Position aus letztem Frame
+
     for follower in colided_objects:
         follower:Follower
-        follower.set_position_player(Player.get_position(), Player.get_playermovedirection(), True)
+        if(i >= 0):
-        if(len(colided_objects) >= 1):
+            #colided_objects[0].set_position_player(Player.get_position(), Player.get_playermovedirection(), True)
-            follower.set_position_player(follower.get_position(), Player.get_playermovedirection(), True)
+            pass
-        print("Zeichne: " + follower.get_name())
+        if(i > 0 and i <= len(colided_objects)):
+            #follower.set_position_player(colided_objects[i].get_position(), Player.get_playermovedirection(), True)
+            pass
         follower.draw()
+        i += 1