Corrected some imports.

Working! (⌐■_■)

cowyeet.py

@@ -3,8 +3,8 @@
 import os
 import pygame
 import numpy
-from tools import pg  # if you import pg from tools, you dont need to init pygame.
+from wobbl_tools import pg  # if you import pg from tools, you dont need to init pygame.
-from tools.file_dict import FileDict
+from wobbl_tools.data_file import DictFile
 from physics.parabelfunc import berechneflugbahn
 
 
@@ -14,386 +14,337 @@ FPS = 60
 SAVE_SETTINGS_ON_EXIT = True
 
 
-pygame.init()  # pygame initialization
+class Cowyeet:
-screen = pygame.display.set_mode(DEFAULT_WINDOW_SIZE)
+    def __init__(self):
-pygame.display.set_caption("Cowyeet 2.0")
+        self.DEFAULT_WINDOW_SIZE = DEFAULT_WINDOW_SIZE
+        self.FPS = FPS
+        self.SAVE_SETTINGS_ON_EXIT = SAVE_SETTINGS_ON_EXIT
 
-if os.path.isfile("settings.txt"):  # If the settings exist, load them into a dict. Else create the settings with the default values.
+        pygame.init()  # pygame initialization
-    settings = FileDict("settings.txt")
+        self.screen = pygame.display.set_mode(DEFAULT_WINDOW_SIZE)
+        pygame.display.set_caption("Cowyeet 2.0")
 
-else:
+        self.settings = self.load_settings()
-    settings = FileDict()
+
+        self.draw_loading_screen()
+
+        # variables
+        self.nero = (40, 40, 40)  # colors (color names by https://www.color-blindness.com/color-name-hue/)
+        self.dim_gray = (100, 100, 100)
+        self.summer_sky = (50, 200, 220)
+        self.white_smoke = (240, 240, 240)
+
+        self.buttons = []  # misc
+        self.text_buttons = []
+        self.active_buttons = []
+        self.last_frame_mouse_pressed = False
+        self.page = "main_menu"
+        self.level = None
+        self.level_data = None
+        self.lvl_width = None
+        self.level_surface = None
+        self.cow_throwable = False
+        self.cow_flying = False
+        self.cow_position = (0, 0)
+        self.cow_flight_path = []
+        self.cow_flight_step = 0
+        self.pressed_keys = []
+        self.pressed_special_keys = pygame.key.get_mods()
+
+        # pygame objects
+        self.clock = pygame.time.Clock()  # misc
+        self.mouse = pygame.mouse
+        self.keyboard = pygame.key
+
+        self.bigger_default_font = pygame.font.SysFont("ubuntu", 32)  # fonts
+
+        self.choose_level_text = self.bigger_default_font.render("Choose a level:", True, self.white_smoke)  # texts
+
+        self.texture_not_found = pygame.image.load("textures/texture_not_found.png")
+        self.texture_not_found = pygame.transform.scale(self.texture_not_found, (40 * self.settings["level_size_multiplier"], 40 * self.settings["level_size_multiplier"]))
+
+        self.icon_texture = self.load_texture("textures/icon.png")
+        self.full_icon_texture = self.load_texture("textures/icon_full.png")
+        self.full_icon_texture = pygame.transform.scale(self.full_icon_texture, (260, 90))
+        self.catapult_frame_texture = self.load_texture("textures/catapult/frame.png")
+        self.catapult_frame_texture = pygame.transform.scale(self.catapult_frame_texture, (66 * 5 * self.settings["level_size_multiplier"], 31 * 5 * self.settings["level_size_multiplier"]))
+        self.catapult_arm_texture = self.load_texture("textures/catapult/arm.png")
+        self.catapult_arm_texture = pygame.transform.scale(self.catapult_arm_texture, (25 * 5 * self.settings["level_size_multiplier"], 53 * 5 * self.settings["level_size_multiplier"]))
+        self.cow = self.load_texture("textures/cow/head.png")
+        self.cow = pygame.transform.scale(self.cow, (64 * 5 * self.settings["level_size_multiplier"], 64 * 5 * self.settings["level_size_multiplier"]))
+        self.stone_block_texture = self.load_block_texture("textures/terrain/stone_01.png")
+        self.dirt_block_texture = self.load_block_texture("textures/terrain/dirt_01.png")
+        self.grass_block_texture = self.load_block_texture("textures/terrain/grass_01.png")
+        self.rock_block_texture = self.load_block_texture("textures/terrain/rock_01.png")
+
+        # buttons
+        self.buttons.append(
+            pg.TextButton("Start", self.center, self.screen, lambda: self.page_switch("level_selector"), text_color=self.white_smoke, bg_color=self.dim_gray, font=self.bigger_default_font))
+        self.start_button = len(self.buttons) - 1
+        self.text_buttons.append(self.start_button)
+
+        self.buttons.append(
+            pg.TextButton("1", (128, 128), self.screen, lambda: self.start_level(1), text_color=self.white_smoke, bg_color=self.dim_gray, font=self.bigger_default_font, padding=(17, 8)))
+        self.lvl_one_button = len(self.buttons) - 1
+        self.text_buttons.append(self.lvl_one_button)
+        # /buttons
+
+        # /variables
+
+        # loading completed
+
+        self.screen = pygame.display.set_mode(self.settings["win_size"], flags=pygame.RESIZABLE, vsync=1)
+        self.window_size_reload(self.settings["win_size"])
+        pygame.display.set_icon(self.icon_texture)
+        self.screen.fill(self.nero)
+        pygame.display.update()
+
+        self.page_switch("main_menu")
+
+        self.running = True
+
+    def load_settings(self):
+        if os.path.isfile("settings.txt"):  # If the settings exist, load them into a dict. Else create the settings with the default values.
+            settings = DictFile("settings.txt")
+
+        else:
+            settings = DictFile()
             settings.path = "settings.txt"
             settings["win_size"] = DEFAULT_WINDOW_SIZE
             settings["level_size_multiplier"] = 1
             settings.save()
 
-# loading screen
+        return settings
-default_font = pygame.font.SysFont("ubuntu", 16)
-loading_text = default_font.render("Loading...", True, (240, 240, 240))
 
-screen.fill((40, 40, 40))
+    def draw_loading_screen(self):
-screen.blit(loading_text, (400 - loading_text.get_width() / 2, 300 - loading_text.get_height() / 2))
+        default_font = pygame.font.SysFont("ubuntu", 16)
-pygame.display.update()
+        loading_text = default_font.render("Loading...", True, (240, 240, 240))
-# /loading screen
 
+        self.screen.fill((40, 40, 40))
+        self.screen.blit(loading_text, (400 - loading_text.get_width() / 2, 300 - loading_text.get_height() / 2))
+        pygame.display.update()
 
-# functions
+    def load_texture(self, path: str):
-
-# images
-def load_texture(path: str):
         if os.path.isfile(path):
             return pygame.image.load(path)
 
         else:
-        return texture_not_found
+            return self.texture_not_found
 
+    def load_block_texture(self, path: str):
+        texture = self.load_texture(path)
 
-def load_block_texture(path: str):
+        return pygame.transform.scale(texture, (40 * self.settings["level_size_multiplier"], 40 * self.settings["level_size_multiplier"]))
-    texture = load_texture(path)
 
-    return pygame.transform.scale(texture, (40 * settings["level_size_multiplier"], 40 * settings["level_size_multiplier"]))
+    def center_x(self, width: int):
-# /images
+        return self.screen.get_width() / 2 - width / 2
 
+    def center_y(self, height: int):
+        return self.screen.get_height() / 2 - height / 2
 
-# coordinate calculations
+    def center(self, size):
-def center_x(width: int):
-    return screen.get_width() / 2 - width / 2
-
-
-def center_y(height: int):
-    return screen.get_height() / 2 - height / 2
-
-
-def center(size):
         width, height = size
 
-    return center_x(width), center_y(height)
+        return self.center_x(width), self.center_y(height)
-# /coordinate calculations
 
-
+    def set_rot_point(self, img, pos):
-# image calculations
-def set_rot_point(img, pos):
         w, h = img.get_size()
         w, h = w * 2, h * 2
 
         img2 = pygame.Surface((w, h), pygame.SRCALPHA)
         img2.blit(img, (w / 2 - pos[0], h / 2 - pos[1]))
         return img2, (w, h)
-# / image calculations
 
+    def start_level(self, lvl: int):
+        self.page_switch("ingame")
+        self.level = lvl
 
-# game logic
+        self.load_level(lvl)
-def start_level(lvl: int):
-    global level
-    global cow_throwable
 
-    page_switch("ingame")
+        self.cow_throwable = True
-    level = lvl
 
-    load_level(lvl)
+    def load_level(self, lvl):
+        self.level_data = __import__("data.levels." + str(lvl), fromlist="data.levels")
 
-    cow_throwable = True
+        self.lvl_width, lvl_height = self.level_data.level_size
 
-
+        self.level_surface = pygame.Surface((self.lvl_width * 40 * self.settings["level_size_multiplier"], lvl_height * 40 * self.settings["level_size_multiplier"]), pygame.SRCALPHA, 32)
-def load_level(lvl):
-    global level_data
-    global lvl_width
-    global level_surface
-
-    level_data = __import__("data.levels." + str(lvl), fromlist="data.levels")
-
-    lvl_width, lvl_height = level_data.level_size
-
-    level_surface = pygame.Surface((lvl_width * 40 * settings["level_size_multiplier"], lvl_height * 40 * settings["level_size_multiplier"]), pygame.SRCALPHA, 32)
 
         x = 0
         y = 0
 
-    for row in level_data.data_array:
+        for row in self.level_data.data_array:
             x = 0
 
             for block in row:
-            rx = x * 40 * settings["level_size_multiplier"]
+                rx = x * 40 * self.settings["level_size_multiplier"]
-            ry = y * 40 * settings["level_size_multiplier"]
+                ry = y * 40 * self.settings["level_size_multiplier"]
 
-            blit_block(block, (rx, ry))
+                self.blit_block(block, (rx, ry))
                 x += 1
 
             y += 1
 
-
+    def blit_block(self, block, position: tuple):
-def blit_block(block, position: tuple):
         if not block == 0:
             if block == 1:
-            level_surface.blit(stone_block_texture, position)
+                self.level_surface.blit(self.stone_block_texture, position)
 
             elif block == 2:
-            level_surface.blit(dirt_block_texture, position)
+                self.level_surface.blit(self.dirt_block_texture, position)
 
             elif block == 3:
-            level_surface.blit(grass_block_texture, position)
+                self.level_surface.blit(self.grass_block_texture, position)
 
             elif block == 4:
-            level_surface.blit(rock_block_texture, position)
+                self.level_surface.blit(self.rock_block_texture, position)
 
             else:
-            level_surface.blit(texture_not_found, position)
+                self.level_surface.blit(self.texture_not_found, position)
 
+    def yeet_cow(self):
+        if self.cow_throwable:
+            self.cow_throwable = False
 
-def yeet_cow():
+            lvl_x, lvl_y = self.level_data.level_size
-    global cow_throwable
-    global cow_flying
-    global cow_flight_path
-    global cow_flight_step
-
-    if cow_throwable:
-        cow_throwable = False
-
-        lvl_x, lvl_y = level_data.level_size
             lvl_x *= 40
-        lvl_x *= settings["level_size_multiplier"]
+            lvl_x *= self.settings["level_size_multiplier"]
             lvl_y *= 40
-        lvl_y *= settings["level_size_multiplier"]
+            lvl_y *= self.settings["level_size_multiplier"]
 
-        cow_flight_path = berechneflugbahn(lvl_x, lvl_y, lvl_x + 100, 34, 128, xstep=10)
+            self.cow_flight_path = berechneflugbahn(lvl_x, lvl_y, lvl_x + 100, 34, 128, xstep=10)
 
-        cow_flying = True
+            self.cow_flying = True
-        cow_flight_step = 0
+            self.cow_flight_step = 0
-# /game logic
 
+    def main_menu_page(self):
+        self.screen.blit(self.full_icon_texture, (self.center_x(self.full_icon_texture.get_width()), 128))
+        self.buttons[self.start_button].blit()
 
-# page system
+    def level_selector_page(self):
-def main_menu_page():
+        self.buttons[self.lvl_one_button].blit()
-    screen.blit(full_icon_texture, (center_x(full_icon_texture.get_width()), 128))
-    buttons[start_button].blit()
 
+        self.screen.blit(self.choose_level_text, (self.screen.get_width() / 2 - self.choose_level_text.get_width() / 2, 16))
 
-def level_selector_page():
+    def ingame_page(self):
-    buttons[lvl_one_button].blit()
+        self.screen.fill(self.summer_sky)
+        self.screen.blit(self.level_surface, (0, self.screen.get_height() - self.level_surface.get_height()))
 
-    screen.blit(choose_level_text, (screen.get_width() / 2 - choose_level_text.get_width() / 2, 16))
+        lvl_size = self.settings["level_size_multiplier"]
 
-
+        cx, cy = self.level_data.catapult_pos
-def ingame_page():
-    global cow_flight_step
-    global cow_position
-    global cow_flying
-    global cow_throwable
-
-    screen.fill(summer_sky)
-    screen.blit(level_surface, (0, screen.get_height() - level_surface.get_height()))
-
-    lvl_size = settings["level_size_multiplier"]
-
-    cx, cy = level_data.catapult_pos
         cx = cx * 40 * lvl_size
-    cy = screen.get_height() - level_surface.get_height() + cy * 40 * lvl_size - catapult_frame_texture.get_height()
+        cy = self.screen.get_height() - self.level_surface.get_height() + cy * 40 * lvl_size - self.catapult_frame_texture.get_height()
 
-    screen.blit(catapult_frame_texture, (cx, cy))
+        self.screen.blit(self.catapult_frame_texture, (cx, cy))
-    screen.blit(catapult_arm_texture, (cx + 27 * 5 * lvl_size, cy - 35 * 5 * lvl_size))
+        self.screen.blit(self.catapult_arm_texture, (cx + 27 * 5 * lvl_size, cy - 35 * 5 * lvl_size))
 
-    if cow_flying:
+        if self.cow_flying:
-        cow_flight_step += 1
+            self.cow_flight_step += 1
 
-        x = cow_flight_path[cow_flight_step * 2]
+            x = self.cow_flight_path[self.cow_flight_step * 2]
-        y = cow_flight_path[cow_flight_step * 2 + 1]
+            y = self.cow_flight_path[self.cow_flight_step * 2 + 1]
-        cow_position = (x, screen.get_height() - y - 64 * 5 * settings["level_size_multiplier"])
+            self.cow_position = (x, self.screen.get_height() - y - 64 * 5 * self.settings["level_size_multiplier"])
 
-        if cow_flight_step * 2 == len(cow_flight_path) - 2:
+            if self.cow_flight_step * 2 == len(self.cow_flight_path) - 2:
-            cow_flying = False
+                self.cow_flying = False
-            cow_throwable = True
+                self.cow_throwable = True
 
-    screen.blit(cow, cow_position)
+        self.screen.blit(self.cow, self.cow_position)
 
+    def page_selector(self):
+        if self.page == "main_menu":
+            self.main_menu_page()
 
-def page_selector():
+        elif self.page == "level_selector":
-    if page == "main_menu":
+            self.level_selector_page()
-        main_menu_page()
 
-    elif page == "level_selector":
+        elif self.page == "ingame":
-        level_selector_page()
+            self.ingame_page()
-
-    elif page == "ingame":
-        ingame_page()
-
-
-def page_switch(new_page: str=None):
-    global active_buttons
-    global page
 
+    def page_switch(self, new_page: str=None):
         if not new_page is None:
-        page = new_page
+            self.page = new_page
 
-    if page == "main_menu":
+        if self.page == "main_menu":
-        active_buttons = [start_button]
+            self.active_buttons = [self.start_button]
 
-    elif page == "level_selector":
+        elif self.page == "level_selector":
-        active_buttons = [lvl_one_button]
+            self.active_buttons = [self.lvl_one_button]
 
-    elif page == "ingame":
+        elif self.page == "ingame":
-        active_buttons = []
+            self.active_buttons = []
 
         # for button in buttons:
         #     button.active = False
         #
         # for button in active_buttons:
         #     button.active = True
-# /page system
 
+    def close(self):
+        self.running = False
 
-def close():
+    def window_size_reload(self, new_size):
-    global running
+        for button in self.text_buttons:
-    running = False
+            self.buttons[button].update()
 
+        self.settings["win_size"] = new_size
 
-def window_size_reload(new_size):
+    def get_events(self):
-    for button in text_buttons:
-        buttons[button].update()
-
-    settings["win_size"] = new_size
-
-
-def get_events():
-    global last_frame_mouse_pressed
-
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
-            close()
+                self.close()
                 return
 
             if event.type == pygame.MOUSEBUTTONDOWN:
-            pressed = mouse.get_pressed()
+                pressed = self.mouse.get_pressed()
-            pos = mouse.get_pos()
+                pos = self.mouse.get_pos()
 
-            if not last_frame_mouse_pressed:
+                for button in self.active_buttons:
-                for button in active_buttons:
+                    self.buttons[button].check(pos, pressed)
-                    buttons[button].check(pos, pressed)
 
-            last_frame_mouse_pressed = True
+                self.last_frame_mouse_pressed = True
 
             elif event.type == pygame.VIDEORESIZE:
 
-            window_size_reload(event.size)
+                self.window_size_reload(event.size)
 
             elif event.type == pygame.KEYDOWN:
                 key = event.key
 
-            if key == pygame.K_c and pressed_special_keys & pygame.KMOD_CTRL:
+                if key == pygame.K_c and self.pressed_special_keys & pygame.KMOD_CTRL:
-                close()
+                    self.close()
 
                 elif key == pygame.K_SPACE:
-                if page == "ingame":
+                    if self.page == "ingame":
-                    yeet_cow()
+                        self.yeet_cow()
 
+    def loop(self):
+        self.screen.fill(self.nero)
 
-def loop():
+        self.pressed_keys = self.keyboard.get_pressed()
-    global last_frame_mouse_pressed
+        self.pressed_special_keys = self.keyboard.get_mods()
-    global pressed_keys
+        self.get_events()
-    global pressed_special_keys
 
-    screen.fill(nero)
+        if not self.running:
-
-    pressed_keys = keyboard.get_pressed()
-    pressed_special_keys = keyboard.get_mods()
-    get_events()
-
-    if not running:
             return
 
-    pressed = mouse.get_pressed()
+        self.page_selector()
-    if not pressed[0] and not pressed[1] and not pressed[2]:
-        last_frame_mouse_pressed = False
-
-    page_selector()
 
         pygame.display.update()
 
-    clock.tick(FPS)
+        self.clock.tick(self.FPS)
 
 
-# variables
+if __name__ == "__main__":
-nero = (40, 40, 40)  # colors (color names by https://www.color-blindness.com/color-name-hue/)
+    game = Cowyeet()
-dim_gray = (100, 100, 100)
-summer_sky = (50, 200, 220)
-white_smoke = (240, 240, 240)
 
-buttons = []  # misc
+    while game.running:
-text_buttons = []
+        game.loop()
-active_buttons = []
-last_frame_mouse_pressed = False
-page = "main_menu"
-level = None
-level_data = None
-lvl_width = None
-level_surface = None
-cow_throwable = False
-cow_flying = False
-cow_position = (0, 0)
-cow_flight_path = []
-cow_flight_step = 0
-pressed_keys = []
-pressed_special_keys = pygame.key.get_mods()
 
+    pygame.quit()
 
-# pygame objects
+    if game.SAVE_SETTINGS_ON_EXIT:
-clock = pygame.time.Clock()  # misc
+        game.settings.save()
-mouse = pygame.mouse
-keyboard = pygame.key
 
-bigger_default_font = pygame.font.SysFont("ubuntu", 32)  # fonts
+    print("Bye!")
-
-choose_level_text = bigger_default_font.render("Choose a level:", True, white_smoke)  # texts
-
-texture_not_found = pygame.image.load("textures/texture_not_found.png")
-texture_not_found = pygame.transform.scale(texture_not_found, (40 * settings["level_size_multiplier"], 40 * settings["level_size_multiplier"]))
-
-icon_texture = load_texture("textures/icon.png")
-full_icon_texture = load_texture("textures/icon_full.png")
-full_icon_texture = pygame.transform.scale(full_icon_texture, (260, 90))
-catapult_frame_texture = load_texture("textures/catapult/frame.png")
-catapult_frame_texture = pygame.transform.scale(catapult_frame_texture, (66 * 5 * settings["level_size_multiplier"], 31 * 5 * settings["level_size_multiplier"]))
-catapult_arm_texture = load_texture("textures/catapult/arm.png")
-catapult_arm_texture = pygame.transform.scale(catapult_arm_texture, (25 * 5 * settings["level_size_multiplier"], 53 * 5 * settings["level_size_multiplier"]))
-cow = load_texture("textures/cow/head.png")
-cow = pygame.transform.scale(cow, (64 * 5 * settings["level_size_multiplier"], 64 * 5 * settings["level_size_multiplier"]))
-stone_block_texture = load_block_texture("textures/terrain/stone_01.png")
-dirt_block_texture = load_block_texture("textures/terrain/dirt_01.png")
-grass_block_texture = load_block_texture("textures/terrain/grass_01.png")
-rock_block_texture = load_block_texture("textures/terrain/rock_01.png")
-
-
-
-# buttons
-buttons.append(pg.TextButton("Start", center, screen, lambda: page_switch("level_selector"), text_color=white_smoke, bg_color=dim_gray, font=bigger_default_font))
-start_button = len(buttons) - 1
-text_buttons.append(start_button)
-buttons.append(pg.TextButton("1", (128, 128), screen, lambda: start_level(1), text_color=white_smoke, bg_color=dim_gray, font=bigger_default_font, padding=(17, 8)))
-lvl_one_button = len(buttons) - 1
-text_buttons.append(lvl_one_button)
-# /buttons
-
-# /variables
-
-
-# loading completed
-
-screen = pygame.display.set_mode(settings["win_size"], flags=pygame.RESIZABLE, vsync=1)
-window_size_reload(settings["win_size"])
-pygame.display.set_icon(icon_texture)
-screen.fill(nero)
-pygame.display.update()
-
-page_switch("main_menu")
-
-running = True
-
-while running:
-    loop()
-
-pygame.quit()
-
-if SAVE_SETTINGS_ON_EXIT:
-    settings.save()
-
-print("Bye!")