Switched GameObjects class and Follower childclass to modules directory

modules/GameObject.py

@@ -0,0 +1,196 @@
+import pygame
+
+class GameObject():
+    __color = (0,0,0)
+    __size_rect_x:int
+    __size_rect_y:int
+    __movespeed = int()
+    __rectobjekt:pygame.Rect
+    __surface:pygame.Surface
+    __mainscreensize:tuple
+    __hide = False
+    __collided = False
+    __is_player = False
+    __is_rect = False
+    __has_follower = False
+    count = 0
+
+    __movedirection = {"up":False, "down":False, "left":False, "right":False}
+    
+    def __init__(self, name:str, surface, mainscreensize:tuple, posx_init:int=0, posy_init:int=0, move_speed:int=0, is_player:bool = False, is_rect:bool = True, rect_size:tuple = (10,10)) -> None:
+        self.__name = name
+        self.__pos_x = posx_init
+        self.__pos_y = posy_init
+        self.pos_array = (posx_init,posy_init)
+        self.__inital_pos_x = posx_init
+        self.__initial_pos_y = posx_init
+        self.__movespeed = move_speed
+        self.__is_player = is_player
+        self.__is_rect = is_rect
+        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.__surface = surface
+        self.__mainscreensize = mainscreensize
+
+        #self.__rectobjekt = rect
+
+    def change_direction(self, direction:dict):
+        if(direction):
+            for key in self.__movedirection.keys():
+                self.__movedirection[key] = False
+            self.__movedirection[direction] = True
+            print(direction)
+        pass
+
+    def move(self, *speed:int):
+        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 = self.__mainscreensize[1]
+
+        elif(self.__movedirection['down']):
+            if(not speed): self.__pos_y += MOVE_SPEED
+            else: self.__pos_y += speed[0]
+            if(self.__pos_y >= self.__mainscreensize[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 = self.__mainscreensize[0]          
+
+        elif(self.__movedirection['right']):
+            if(not speed): self.__pos_x += MOVE_SPEED
+            else: self.__pos_x += speed[0]
+            if(self.__pos_x >= self.__mainscreensize[0]): 
+                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 = self.__mainscreensize[1]
+
+        elif(self.__movedirection['down']):
+            if(not speed): self.__pos_y += MOVE_SPEED
+            else: self.__pos_y += speed[0]
+            if(self.__pos_y >= self.__mainscreensize[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 = self.__mainscreensize[0]          
+
+        elif(self.__movedirection['right']):
+            if(not speed): self.__pos_x += MOVE_SPEED
+            else: self.__pos_x += speed[0]
+            if(self.__pos_x >= self.__mainscreensize[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):
+        #font = pygame.font.SysFont(None, 70)
+        #text = font.render("TEST", True, (0,0,0) )
+        if(not self.__hide):
+            self.__rectobjekt = pygame.draw.rect(self.__surface, self.__color, [self.__pos_x, self.__pos_y,self.__size_rect_x,self.__size_rect_y])
+
+    def get_name(self, debug=False):
+        if(debug):
+            print(self.__name)
+        return self.__name
+
+    def get_position(self, debug=False):
+        if(debug):
+            print((self.__pos_x, self.__pos_y))
+        return (self.__pos_x, self.__pos_y)
+
+    def get_rect(self):
+        return self.__rectobjekt
+    
+    def get_rect_size(self):
+        return (self.__size_rect_x, self.__size_rect_y)
+    
+    def get_movespeed(self):
+        return self.__movespeed
+    
+    def get_playermovedirection(self):
+        return self.__movedirection
+    
+    def has_follower(self):
+        return self.__has_follower
+    
+    def set_follower(self):
+        self.__has_follower = True
+    
+    def is_collided(self) -> bool:
+        return self.__collided
+    
+    def set_collided(self):
+        self.__collided = True
+
+    def set_position(self, pos:tuple):
+        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())
+        """TODO: Hitbox with Objectsize"""
+            
+        if(pygame.rect.Rect.colliderect(self.__rectobjekt, GameObject.get_rect()) and not self.is_collided()):
+            print("Kollision\n") #Funktioniert für das erste!
+            self.set_collided()
+            return True
+            #self.hide() #Löscht das Objekt nach einem Zusammenstoß mit Playerobject
+        return False
+    
+    def hide(self):
+        if(self.__hide != True):
+            print("Gameoject mit der ID " + self.__name + " gelöscht!")
+            self.__hide = True
+        """TODO: Delete obeject function"""
+
+
+
+class Follower(GameObject):
+    def __init__(self, name: str, surface, mainscreensize: tuple, posx_init: int = 0, posy_init: int = 0, move_speed: int = 0, is_player: bool = False, is_rect: bool = True, rect_size: tuple = ...) -> None:
+        super().__init__(name, surface, mainscreensize, posx_init, posy_init, move_speed, is_player, is_rect, rect_size)
+
+    def set_position_player(self, pos:tuple, playermovedirection:list, debug=False):
+        if(playermovedirection["up"]):
+            super().set_position((pos[0],pos[1]+super().get_rect_size()[1]))
+            print(pos)
+        if(playermovedirection["down"]):
+            super().set_position((pos[0],pos[1]-super().get_rect_size()[1]))
+            print(pos)
+        if(playermovedirection["left"]):
+            super().set_position((pos[0]+super().get_rect_size()[0],pos[1]))  
+            print(pos)         
+        if(playermovedirection["right"]):
+            super().set_position((pos[0]-super().get_rect_size()[0],pos[1]))  
+            print(pos) 
+    def test(self):
+        print(super().get_position())

pygame-test.py

@@ -3,6 +3,7 @@ import pygame_menu
 import random as rand
 from copy import deepcopy
 import modules.User as User
+from modules.GameObject import *
 
 pygame.init()
 MAINSCREEN_SIZE = (1024,768)
@@ -18,175 +19,7 @@ clock = pygame.time.Clock()
 
 #TODO: Make Grid for running Rect
 
-class GameObject():
-    __color = (0,0,0)
-    __size_rect_x:int
-    __size_rect_y:int
-    __movespeed = int()
-    __rectobjekt:pygame.Rect
-    __surface = MAINSCREEN
-    __hide = False
-    __collided = False
-    __is_player = False
-    __is_rect = False
-    __has_follower = False
-    count = 0
 
-    __movedirection = {"up":False, "down":False, "left":False, "right":False}
-    
-    def __init__(self, name:str, posx_init:int=0, posy_init:int=0, move_speed:int=0, is_player:bool = False, is_rect:bool = True, rect_size:tuple = (10,10)) -> None:
-        self.__name = name
-        self.__pos_x = posx_init
-        self.__pos_y = posy_init
-        self.pos_array = (posx_init,posy_init)
-        self.__inital_pos_x = posx_init
-        self.__initial_pos_y = posx_init
-        self.__movespeed = move_speed
-        self.__is_player = is_player
-        self.__is_rect = is_rect
-        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
-
-    def change_direction(self, direction:dict):
-        if(direction):
-            for key in self.__movedirection.keys():
-                self.__movedirection[key] = False
-            self.__movedirection[direction] = True
-            print(direction)
-        pass
-
-    def move(self, *speed:int):
-        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        
-
-
-    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):
-        #font = pygame.font.SysFont(None, 70)
-        #text = font.render("TEST", True, (0,0,0) )
-        if(not self.__hide):
-            self.__rectobjekt = pygame.draw.rect(self.__surface, self.__color, [self.__pos_x, self.__pos_y,self.__size_rect_x,self.__size_rect_y])
-
-    def get_name(self, debug=False):
-        if(debug):
-            print(self.__name)
-        return self.__name
-
-    def get_position(self, debug=False):
-        if(debug):
-            print((self.__pos_x, self.__pos_y))
-        return (self.__pos_x, self.__pos_y)
-
-    def get_rect(self):
-        return self.__rectobjekt
-    
-    def get_rect_size(self):
-        return (self.__size_rect_x, self.__size_rect_y)
-    
-    def get_movespeed(self):
-        return self.__movespeed
-    
-    def get_playermovedirection(self):
-        return self.__movedirection
-    
-    def has_follower(self):
-        return self.__has_follower
-    
-    def set_follower(self):
-        self.__has_follower = True
-    
-    def is_collided(self) -> bool:
-        return self.__collided
-    
-    def set_collided(self):
-        self.__collided = True
-
-    def set_position(self, pos:tuple):
-        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())
-        """TODO: Hitbox with Objectsize"""
-            
-        if(pygame.rect.Rect.colliderect(self.__rectobjekt, GameObject.get_rect()) and not self.is_collided()):
-            print("Kollision\n") #Funktioniert für das erste!
-            self.set_collided()
-            return True
-            #self.hide() #Löscht das Objekt nach einem Zusammenstoß mit Playerobject
-        return False
-    
-    def hide(self):
-        if(self.__hide != True):
-            print("Gameoject mit der ID " + self.__name + " gelöscht!")
-            self.__hide = True
-        """TODO: Delete obeject function"""
 
 #Behandelt später die Hauptschleife und Klassenobjekte
 class Game():
@@ -195,26 +28,6 @@ class Game():
         pass
 #Handles all collided objects an adds it as Playerfollower
 
-class Follower(GameObject):
-    def __init__(self, name: str, posx_init: int = 0, posy_init: int = 0, move_speed: int = 0, is_player: bool = False, is_rect: bool = True, rect_size: tuple = (10, 10)) -> None:
-        super().__init__(name, posx_init, posy_init, move_speed, is_player, is_rect, rect_size)
-
-    def set_position_player(self, pos:tuple, playermovedirection:list, debug=False):
-        if(playermovedirection["up"]):
-            super().set_position((pos[0],pos[1]+super().get_rect_size()[1]))
-            print(pos)
-        if(playermovedirection["down"]):
-            super().set_position((pos[0],pos[1]-super().get_rect_size()[1]))
-            print(pos)
-        if(playermovedirection["left"]):
-            super().set_position((pos[0]+super().get_rect_size()[0],pos[1]))  
-            print(pos)         
-        if(playermovedirection["right"]):
-            super().set_position((pos[0]-super().get_rect_size()[0],pos[1]))  
-            print(pos) 
-    def test(self):
-        print(super().get_position())
-
 def start_game():
     menu.disable()
     return 0
@@ -239,7 +52,7 @@ count_follower = 0
 
 def append_follwer(x,y):
     print("x: "+str(x), "y: "+str(y))
-    newfollower = Follower("Follower "+str(count_follower), is_rect=True, rect_size=(x,y))
+    newfollower = Follower("Follower "+str(count_follower), MAINSCREEN, MAINSCREEN_SIZE, is_rect=True, rect_size=(x,y))
     colided_objects.append(newfollower)
 
 User = User.User()
@@ -254,12 +67,12 @@ def spawn_entities(x:int, list_of_objects:list):
     count = 0
     for y in range(x):
         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 = GameObject("Entitiy-"+str(count), MAINSCREEN, MAINSCREEN_SIZE, 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)
         count += 1
 
-Player = GameObject("Player", 10, 10, 10, is_player=False, is_rect=True, rect_size=(50,50))
+Player = GameObject("Player", MAINSCREEN, MAINSCREEN_SIZE, 10, 10, 10, is_player=False, is_rect=True, rect_size=(50,50))
 
 background = pygame.surface.Surface((640,480))
 
@@ -326,14 +139,13 @@ while active == True:
         pass
 
     #TODO:Berechne Position follower Objekte anhand Position aus letztem Frame
-
     for follower in colided_objects:
         follower:Follower
         if(i >= 0):
-            #colided_objects[0].set_position_player(Player.get_position(), Player.get_playermovedirection(), True)
+            colided_objects[0].set_position_player(Player.get_position(), Player.get_playermovedirection(), True)
             pass
         if(i > 0 and i <= len(colided_objects)):
-            #follower.set_position_player(colided_objects[i].get_position(), Player.get_playermovedirection(), True)
+            #colided_objects[i].set_position_player(follower.set_position(colided_objects[i-1].get_position()), Player.get_playermovedirection(), True)
             pass
         follower.draw()
         i += 1