EndiumEngine

try:
    import pygame
    from pygame.locals import *
except:
    raise ImportError("Unable to import pygame")
    import sys
    sys.exit()

try:
    import json
except:
    raise ImportError("Unable to import JSON!")
    import sys
    sys.exit()

try:
    import time
except:
    raise ImportError("Unable import time!")
    import sys
    sys.exit()

try:
    import io
except:
    raise ImportError("Unable import io!")
    import sys
    sys.exit()

try:
    import base64
except:
    raise ImportError("Unable import base64!")
    import sys
    sys.exit()

try:
    import runpy
except:
    raise ImportError("Unable import runpy!")
    import sys
    sys.exit()

class EndiumEngine:
    KEYPRESS = pygame.KEYDOWN
    KEYUP = pygame.KEYUP
    MOUSEBUTTONDOWN = pygame.MOUSEBUTTONDOWN
    MOUSEBUTTONUP = pygame.MOUSEBUTTONUP
    MOUSEMOTION = pygame.MOUSEMOTION
    EXIT = pygame.QUIT

    CURSOR_DEFAULT = pygame.SYSTEM_CURSOR_ARROW
    CURSOR_IBEAM = pygame.SYSTEM_CURSOR_IBEAM
    CURSOR_LOADING = pygame.SYSTEM_CURSOR_WAIT
    CURSOR_CROSSHAIR = pygame.SYSTEM_CURSOR_CROSSHAIR
    CURSOR_SMALL_LOADING = pygame.SYSTEM_CURSOR_WAITARROW
    CURSOR_SIZENWSE = pygame.SYSTEM_CURSOR_SIZENWSE
    CURSOR_SIZENESW = pygame.SYSTEM_CURSOR_SIZENESW
    CURSOR_SIZEWE = pygame.SYSTEM_CURSOR_SIZEWE
    CURSOR_SIZENS = pygame.SYSTEM_CURSOR_SIZENS
    CURSOR_SIZEALL = pygame.SYSTEM_CURSOR_SIZEALL
    CUSROR_BLOCK = pygame.SYSTEM_CURSOR_NO
    CURSOR_CLICK = pygame.SYSTEM_CURSOR_HAND

    KEYS = {
    "A": pygame.K_a,
    "B": pygame.K_b,
    "C": pygame.K_c,
    "D": pygame.K_d,
    "E": pygame.K_e,
    "F": pygame.K_f,
    "G": pygame.K_g,
    "H": pygame.K_h,
    "I": pygame.K_i,
    "J": pygame.K_j,
    "K": pygame.K_k,
    "L": pygame.K_l,
    "M": pygame.K_m,
    "N": pygame.K_n,
    "O": pygame.K_o,
    "P": pygame.K_p,
    "Q": pygame.K_q,
    "R": pygame.K_r,
    "S": pygame.K_s,
    "T": pygame.K_t,
    "U": pygame.K_u,
    "V": pygame.K_v,
    "W": pygame.K_w,
    "X": pygame.K_x,
    "Y": pygame.K_y,
    "Z": pygame.K_z,
    "0": pygame.K_0,
    "1": pygame.K_1,
    "2": pygame.K_2,
    "3": pygame.K_3,
    "4": pygame.K_4,
    "5": pygame.K_5,
    "6": pygame.K_6,
    "7": pygame.K_7,
    "8": pygame.K_8,
    "9": pygame.K_9,
    "UP": pygame.K_UP,
    "DOWN": pygame.K_DOWN,
    "LEFT": pygame.K_LEFT,
    "RIGHT": pygame.K_RIGHT,
    "SPACE": pygame.K_SPACE,
    "RETURN": pygame.K_RETURN,
    "ESCAPE": pygame.K_ESCAPE,
    "BACKSPACE": pygame.K_BACKSPACE,
    "TAB": pygame.K_TAB,
    "LSHIFT": pygame.K_LSHIFT,
    "RSHIFT": pygame.K_RSHIFT,
    "LCTRL": pygame.K_LCTRL,
    "RCTRL": pygame.K_RCTRL,
    "LALT": pygame.K_LALT,
    "RALT": pygame.K_RALT,
    "F1": pygame.K_F1,
    "F2": pygame.K_F2,
    "F3": pygame.K_F3,
    "F4": pygame.K_F4,
    "F5": pygame.K_F5,
    "F6": pygame.K_F6,
    "F7": pygame.K_F7,
    "F8": pygame.K_F8,
    "F9": pygame.K_F9,
    "F10": pygame.K_F10,
    "F11": pygame.K_F11,
    "F12": pygame.K_F12,
    "INSERT": pygame.K_INSERT,
    "DELETE": pygame.K_DELETE,
    "HOME": pygame.K_HOME,
    "END": pygame.K_END,
    "PAGEUP": pygame.K_PAGEUP,
    "PAGEDOWN": pygame.K_PAGEDOWN,
    "NUMLOCK": pygame.K_NUMLOCK,
    "CAPSLOCK": pygame.K_CAPSLOCK,
    "SCROLLLOCK": pygame.K_SCROLLLOCK
    }

    FULLSCREEN = pygame.FULLSCREEN
    RESIZABLE = pygame.RESIZABLE
    NOFRAME = pygame.NOFRAME
    OPENGL = pygame.OPENGL
    SCALED = pygame.SCALED
    SHOWN = pygame.SHOWN
    HIDDEN = pygame.HIDDEN
    ALLOW_HIGHDPI = pygame.HWSURFACE

    current_scene = None

    def __init__(self, width=800, height=600, title="Endium Engine", fps=60):
        pygame.init()
        self.screen = pygame.display.set_mode((width, height))
        pygame.display.set_caption(title)
        self.clock = pygame.time.Clock()
        self.fps = fps
        self.running = True
        self.window = self.Window(width, height, title)
        EndiumEngine.EventManager = self.EventManager()
        EndiumEngine.KeyBoardManager = self.KeyBoardManager()
        EndiumEngine.Cursor = self.Cursor()
        base64_string = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAr0lEQVQ4EaVSsQ2AMAwrnMElHMEdzJzBHzzCyMYBDGxs3AByJEcmqgCpkcCpEzuholqv4UoFUUM776dZAP/kqjEDJcxJXjQUylPUary6cTKSSI5nInkgwzdgE5ENemauWG19Kr9ETvvC5UgJj4Z/gpJveds8q24QnXPTohhWbpAr5rjnfDGIhS8xN/YNosHbmWL0/DZQEbbjhmaQuzAVYBIFyDV8A22IYhXEvPhPvAHZYFk5u6mgHQAAAABJRU5ErkJggg=="
        image_data = base64.b64decode(base64_string)
        image_io = io.BytesIO(image_data)
        image_final = pygame.image.load(image_io)
        pygame.display.set_icon(image_final)

    def run(self, update_callback, render_callback):
        while self.running:
            dt = self.clock.tick(self.fps) / 1000
            EndiumEngine.EventManager.clear_events()

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                self.EventManager.handle_event(event)
                self.KeyBoardManager.handle_event(event)

            if EndiumEngine.EventManager.get_events():
                update_callback(dt)

            render_callback(self.screen)

            pygame.display.flip()

        pygame.quit()
    class UI:
        class Button:
            def __init__(self, image, x, y, width, height):
                self.image = pygame.transform.scale(pygame.image.load(image), (width, height))
                self.rect = self.image.get_rect(topleft=(x, y))

            def is_hover(self):
                mouse_pos = pygame.mouse.get_pos()
                return self.rect.collidepoint(mouse_pos)

            def is_pressed(self, click_type):
                if click_type in [0, 1, 2]:
                    return self.is_hover() and pygame.mouse.get_pressed()[click_type]

            def set_texture(self, image):
                self.image = pygame.transform.scale(pygame.image.load(image), (self.rect.width, self.rect.height))

            def set_size(self, width, height):
                self.image = pygame.transform.scale(self.image, (width, height))
                self.rect.size = (width, height)

            def draw(self, surface):
                surface.blit(self.image, self.rect.topleft)
        class Texture:
            def __init__(self, image, x, y, width, height):
                self.image = pygame.transform.scale(pygame.image.load(image), (width, height))
                self.rect = self.image.get_rect(topleft=(x, y))

            def set_texture(self, image):
                self.image = pygame.transform.scale(pygame.image.load(image), (self.rect.width, self.rect.height))

            def set_pos(self, x, y):
                self.rect.topleft = (x, y)

            def set_size(self, width, height):
                self.image = pygame.transform.scale(self.image, (width, height))
                self.rect.size = (width, height)

            def get_pos(self):
                return self.rect.topleft

            def get_size(self):
                return self.rect.size

            def draw(self, surface):
                surface.blit(self.image, self.rect.topleft)

            def collides_with(self, other):
                if isinstance(other, Texture):
                    return self.rect.colliderect(other.rect)
                return False
        class Text:
            def __init__(self, text, x, y, font_size, font, color):
                pygame.font.init()
                self.text = text
                self.x = x
                self.y = y
                self.font_size = font_size
                self.color = color
                self.font = pygame.font.Font(font, font_size)
                self.rendered_text = self.font.render(self.text, True, self.color)
                self.rect = self.rendered_text.get_rect(topleft=(x, y))

            def set_text(self, text):
                self.text = text
                self._update_render()

            def set_pos(self, x, y):
                self.x = x
                self.y = y
                self.rect.topleft = (x, y)

            def set_font_size(self, font_size):
                self.font_size = font_size
                self.font = pygame.font.Font(None, font_size)
                self._update_render()

            def set_color(self, color):
                self.color = color
                self._update_render()

            def get_text(self):
                return self.text

            def get_pos(self):
                return self.rect.topleft

            def _update_render(self):
                self.rendered_text = self.font.render(self.text, True, self.color)
                self.rect = self.rendered_text.get_rect(topleft=(self.x, self.y))

            def draw(self, surface):
                surface.blit(self.rendered_text, self.rect.topleft)
    class SoundManager:
        def __init__(self):
            pygame.mixer.init()

        def play_sound(self, file_path, volume=1.0):
            sound = pygame.mixer.Sound(file_path)
            sound.set_volume(volume)
            sound.play()
    class Window:
        def __init__(self, width, height, title):
            self.width = width
            self.height = height
            self.title = title
            self.flags = 0
            self.screen = pygame.display.set_mode((width, height), self.flags)
            pygame.display.set_caption(title)

        def set_size(self, width, height):
            self.width = width
            self.height = height
            self.apply_arguments()

        def set_title(self, title):
            self.title = title
            pygame.display.set_caption(title)

        def get_size(self):
            return self.width, self.height

        def get_title(self):
            return self.title

        def get_surface(self):
            return self.screen

        def set_icon(image):
            pygame.display.set_icon(pygame.image.load(image))

        def add_argument(self, flag):
            self.flags |= flag

        def remove_argument(self, flag):
            self.flags &= ~flag

        def apply_arguments(self):
            self.screen = pygame.display.set_mode((self.width, self.height), self.flags)

    class SceneManager:
        def set_scene(scene_name):
            EndiumEngine.current_scene = scene_name

        def get_scene():
            return EndiumEngine.current_scene
    class EventManager:
        _events = []

        def handle_event(self, event):
            self._events.append(event)

        def get_event_type(cls):
            return [event.type for event in cls._events]

        def get_events(cls):
            return cls._events

        def clear_events(cls):
            cls._events.clear()
    class KeyBoardManager:
        def __init__(self):
            self._pressed_keys = set()

        def handle_event(self, event):
            if event.type == pygame.KEYDOWN:
                self._pressed_keys.add(event.key)
            elif event.type == pygame.KEYUP:
                self._pressed_keys.discard(event.key)

        def is_key_pressed(self, key):
            return key in self._pressed_keys

        def get_pressed_keys(self):
            return [pygame.key.name(key) for key in self._pressed_keys]
    class Cursor:
        def __init__(self):
            self.visible = True

        def set_visible(self, visible):
            self.visible = visible
            pygame.mouse.set_visible(visible)

        def set_cursor(self, cursor_type):
            pygame.mouse.set_cursor(cursor_type)

        def set_position(self, x, y):
            pygame.mouse.set_pos([x, y])

        def get_visible(self):
            return pygame.mouse.get_visible()

        def get_position(self):
            return pygame.mouse.get_pos()

        def is_clicked(self, click_type):
            if click_type in [0, 1, 2]:
                return pygame.mouse.get_pressed()[click_type]
    class logger:
        def info(msg):
            named_tuple = time.localtime()
            time_string = time.strftime("%d/%m/%Y %H:%M:%S", named_tuple)
            print("[" + time_string + "]" + "[INFO]" + " " + msg)
        def warn(msg):
            named_tuple = time.localtime()
            time_string = time.strftime("%d/%m/%Y %H:%M:%S", named_tuple)
            print("[" + time_string + "]" + "[WARN]" + " " + msg)
        def error(msg):
            named_tuple = time.localtime()
            time_string = time.strftime("%d/%m/%Y %H:%M:%S", named_tuple)
            print("[" + time_string + "]" + "[ERROR]" + " " + msg)
    class script:
        def exec_line(line):
            exec(line)
        def exec_file(file_path):
            runpy.run_path(file_path)

if __name__ == "__main__":
    ee = EndiumEngine()
    def update(dt):
        pass
    def render(screen):
        pass
    ee.run(update, render)