Wobbl/Cowyeet
Wobbl/Cowyeet
2
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

Converted cowyeet.py to OOP.

Browse source 
Working! (⌐■_■)
This commit is contained in:
The Wobbler 2024-01-31 15:49:57 +01:00
parent 5a04f262a4
commit a45b823879
1 changed files with 268 additions and 313 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

465
cowyeet.py
View file

@ -14,386 +14,341 @@ FPS = 60
SAVE_SETTINGS_ON_EXIT = True 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
self.screen = pygame.display.set_mode(DEFAULT_WINDOW_SIZE)
pygame.display.set_caption("Cowyeet 2.0")
self.settings = self.load_settings()
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 = FileDict("settings.txt") settings = FileDict("settings.txt")
else: else:
settings = FileDict() settings = FileDict()
settings.path = "settings.txt" settings.path = "settings.txt"
settings["win_size"] = DEFAULT_WINDOW_SIZE settings["win_size"] = DEFAULT_WINDOW_SIZE
settings["level_size_multiplier"] = 1 settings["level_size_multiplier"] = 1
settings.save() 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): if os.path.isfile(path):
return pygame.image.load(path) return pygame.image.load(path)
else: 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 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 = img.get_size()
w, h = w * 2, h * 2 w, h = w * 2, h * 2
img2 = pygame.Surface((w, h), pygame.SRCALPHA) img2 = pygame.Surface((w, h), pygame.SRCALPHA)
img2.blit(img, (w / 2 - pos[0], h / 2 - pos[1])) img2.blit(img, (w / 2 - pos[0], h / 2 - pos[1]))
return img2, (w, h) 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 x = 0
y = 0 y = 0
for row in level_data.data_array: for row in self.level_data.data_array:
x = 0 x = 0
for block in row: 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 x += 1
y += 1 y += 1
def blit_block(self, block, position: tuple):
def blit_block(block, position: tuple):
if not block == 0: if not block == 0:
if block == 1: if block == 1:
level_surface.blit(stone_block_texture, position) self.level_surface.blit(self.stone_block_texture, position)
elif block == 2: elif block == 2:
level_surface.blit(dirt_block_texture, position) self.level_surface.blit(self.dirt_block_texture, position)
elif block == 3: elif block == 3:
level_surface.blit(grass_block_texture, position) self.level_surface.blit(self.grass_block_texture, position)
elif block == 4: elif block == 4:
level_surface.blit(rock_block_texture, position) self.level_surface.blit(self.rock_block_texture, position)
else: 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 *= 40
lvl_x *= settings["level_size_multiplier"] lvl_x *= self.settings["level_size_multiplier"]
lvl_y *= 40 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 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: 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: # for button in buttons:
# button.active = False # button.active = False
# #
# for button in active_buttons: # for button in active_buttons:
# button.active = True # 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(): for event in pygame.event.get():
if event.type == pygame.QUIT: if event.type == pygame.QUIT:
close() self.close()
return return
if event.type == pygame.MOUSEBUTTONDOWN: 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: elif event.type == pygame.VIDEORESIZE:
window_size_reload(event.size) self.window_size_reload(event.size)
elif event.type == pygame.KEYDOWN: elif event.type == pygame.KEYDOWN:
key = event.key 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: elif key == pygame.K_SPACE:
if page == "ingame": if self.page == "ingame":
yeet_cow() self.yeet_cow()
def loop(self):
def loop():
global last_frame_mouse_pressed global last_frame_mouse_pressed
global pressed_keys global pressed_keys
global pressed_special_keys global pressed_special_keys
screen.fill(nero) self.screen.fill(self.nero)
pressed_keys = keyboard.get_pressed() self.pressed_keys = self.keyboard.get_pressed()
pressed_special_keys = keyboard.get_mods() self.pressed_special_keys = self.keyboard.get_mods()
get_events() self.get_events()
if not running: if not self.running:
return 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() 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!")