Cowyeet/cowyeet.py

#!/usr/bin/python3

import os
import pygame
import numpy
from tools import pg  # if you import pg from tools, you dont need to init pygame.
from tools.file_dict import FileDict


# integrated settings (I dont trust my own settings class.)
DEFAULT_WINDOW_SIZE = (800, 600)
FPS = 60
SAVE_SETTINGS_ON_EXIT = True


pygame.init()  # pygame initialization
screen = pygame.display.set_mode(DEFAULT_WINDOW_SIZE)
pygame.display.set_caption("Cowyeet 2.0")

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")

else:
    settings = FileDict()
    settings.path = "settings.txt"
    settings["win_size"] = DEFAULT_WINDOW_SIZE
    settings["level_size_multiplier"] = 1
    settings.save()

# loading screen
default_font = pygame.font.SysFont("ubuntu", 16)
loading_text = default_font.render("Loading...", True, (240, 240, 240))

screen.fill((40, 40, 40))
screen.blit(loading_text, (400 - loading_text.get_width() / 2, 300 - loading_text.get_height() / 2))
pygame.display.update()
# /loading screen


# functions

# images
def load_texture(path: str):
    if os.path.isfile(path):
        return pygame.image.load(path)

    else:
        return texture_not_found


def load_block_texture(path: str):
    texture = load_texture(path)

    return pygame.transform.scale(texture, (40 * settings["level_size_multiplier"], 40 * settings["level_size_multiplier"]))
# /images


# coordinate calculations
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)
# /coordinate calculations


# 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


# game logic
def start_level(lvl: int):
    global level

    page_switch("ingame")
    level = lvl

    load_level(lvl)


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:
        x = 0

        for block in row:
            rx = x * 40 * settings["level_size_multiplier"]
            ry = y * 40 * settings["level_size_multiplier"]

            blit_block(block, (rx, ry))
            x += 1

        y += 1


def blit_block(block, position: tuple):
    if not block == 0:
        if block == 1:
            level_surface.blit(stone_block_texture, position)

        elif block == 2:
            level_surface.blit(dirt_block_texture, position)

        elif block == 3:
            level_surface.blit(grass_block_texture, position)

        elif block == 4:
            level_surface.blit(rock_block_texture, position)

        else:
            level_surface.blit(texture_not_found, position)
# /game logic


# page system
def main_menu_page():
    screen.blit(full_icon_texture, (center_x(full_icon_texture.get_width()), 128))
    buttons[start_button].blit()


def level_selector_page():
    buttons[lvl_one_button].blit()

    screen.blit(choose_level_text, (screen.get_width() / 2 - choose_level_text.get_width() / 2, 16))


def ingame_page():
    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()

    screen.blit(catapult_frame_texture, (cx, cy))
    screen.blit(catapult_arm_texture, (cx + 27 * 5 * lvl_size, cy - 35 * 5 * lvl_size))


def page_selector():
    if page == "main_menu":
        main_menu_page()

    elif page == "level_selector":
        level_selector_page()

    elif page == "ingame":
        ingame_page()


def page_switch(new_page: str=None):
    global active_buttons
    global page

    if not new_page is None:
        page = new_page

    if page == "main_menu":
        active_buttons = [start_button]

    elif page == "level_selector":
        active_buttons = [lvl_one_button]

    elif page == "ingame":
        active_buttons = []

    # for button in buttons:
    #     button.active = False
    #
    # for button in active_buttons:
    #     button.active = True
# /page system


def close():
    global running
    running = False


def window_size_reload(new_size):
    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()
            return

        if event.type == pygame.MOUSEBUTTONDOWN:
            pressed = mouse.get_pressed()
            pos = mouse.get_pos()

            if not last_frame_mouse_pressed:
                for button in active_buttons:
                    buttons[button].check(pos, pressed)

            last_frame_mouse_pressed = True

        if event.type == pygame.VIDEORESIZE:

            window_size_reload(event.size)


def loop():
    global last_frame_mouse_pressed

    screen.fill(nero)

    get_events()

    if not running:
        return

    pressed = mouse.get_pressed()
    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)


# variables
nero = (40, 40, 40)  # colors (color names by https://www.color-blindness.com/color-name-hue/)
dim_gray = (100, 100, 100)
summer_sky = (50, 200, 220)
white_smoke = (240, 240, 240)

buttons = []  # misc
text_buttons = []
active_buttons = []
last_frame_mouse_pressed = False
page = "main_menu"
level = None
level_data = None
lvl_width = None
level_surface = None


# pygame objects
clock = pygame.time.Clock()  # misc
mouse = pygame.mouse

bigger_default_font = pygame.font.SysFont("ubuntu", 32)  # fonts

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"]))
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)
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()