corebitengine 0.1.0__tar.gz → 0.1.1__tar.gz

corebitengine-0.1.1/CoreBitEngine/CameraSystem.py

@@ -0,0 +1,29 @@
+class Camera2D:
+
+    def __init__(self):
+
+        self.x = 0
+        self.y = 0
+
+        self.target = None
+
+        self.screen_width = 1920
+        self.screen_height = 1080
+
+    def follow(self, target):
+        self.target = target
+
+    def update(self):
+
+        if self.target is None:
+            return
+
+        self.x = self.target.transform.position.x
+        self.y = self.target.transform.position.y
+
+    def world_to_screen(self, x, y):
+
+        screen_x = x - self.x + self.screen_width // 2
+        screen_y = y - self.y + self.screen_height // 2
+
+        return screen_x, screen_y

corebitengine-0.1.1/CoreBitEngine/ColliderSystem.py

@@ -0,0 +1,63 @@
+class BoxCollider2D:
+    def __init__(self, width=None, height=None, is_trigger=False):
+
+        self.game_object = None
+        self.engine = None
+
+        self.istrigger = is_trigger
+        self.enabled = True
+
+        # Eğer manuel verilmezse GameObject size'ını kullan
+        self.width = width
+        self.height = height
+
+    def get_size(self):
+
+        go = self.game_object
+
+        if self.width is None:
+            self.width = go.transform.size.width
+
+        if self.height is None:
+            self.height = go.transform.size.height
+
+        return self.width, self.height
+
+    def check_bound(self):
+
+        go = self.game_object
+        w, h = self.get_size()
+
+        x = go.transform.position.x
+        y = go.transform.position.y
+
+        return {
+            "left": x,
+            "right": x + w,
+            "top": y,
+            "bottom": y + h
+        }
+
+    def check_collisions(self, other):
+
+        a = self.check_bound()
+        b = other.check_bound()
+
+        return (
+            a["left"] < b["right"] and
+            a["right"] > b["left"] and
+            a["top"] < b["bottom"] and
+            a["bottom"] > b["top"]
+        )
+
+    def get_overlap(self, other):
+
+        a = self.check_bound()
+        b = other.check_bound()
+
+        left = a["right"] - b["left"]
+        right = b["right"] - a["left"]
+        top = a["bottom"] - b["top"]
+        bottom = b["bottom"] - a["top"]
+
+        return left, right, top, bottom

corebitengine-0.1.1/CoreBitEngine/Engine.py

@@ -0,0 +1,217 @@
+import pygame
+import time
+from Lib.CameraSystem import Camera2D
+from Lib.ColliderSystem import BoxCollider2D
+from Lib.rigidbody2D import Rigidbody2D
+
+
+class GameLoop():
+    def __init__(self):
+        self.game_objects = []
+        self.camera = Camera2D()
+        self.isrun = False
+
+        # 🔥 collision tracking (Unity OnEnter/Exit için)
+        self.active_collisions = set()
+
+    # -------------------------
+    # ADD OBJECT
+    # -------------------------
+    def add_obj(self, obj):
+        obj.engine = self
+
+        for c in obj.components:
+            c.game_object = obj
+            c.engine = self
+
+        self.game_objects.append(obj)
+
+    # -------------------------
+    # EVENT CALLER
+    # -------------------------
+    def call(self, obj, func, other):
+        for c in obj.components:
+            if hasattr(c, func):
+                getattr(c, func)(other)
+
+    # -------------------------
+    # COLLISION SYSTEM
+    # -------------------------
+    def check_collisions(self):
+
+        objects = self.game_objects
+        new_collisions = set()
+
+        for i in range(len(objects)):
+            for j in range(i + 1, len(objects)):
+
+                a = objects[i]
+                b = objects[j]
+
+                colA = a.get_component(BoxCollider2D)
+                colB = b.get_component(BoxCollider2D)
+
+                if not colA or not colB:
+                    continue
+
+                if not colA.check_collisions(colB):
+                    continue
+
+                if not colA.enabled or not colB.enabled:
+                    continue
+
+                pair = (id(a), id(b))
+                new_collisions.add(pair)
+
+                rb = a.get_component(Rigidbody2D)
+
+                overlap_left, overlap_right, overlap_top, overlap_bottom = \
+                    colA.get_overlap(colB)
+
+                min_x = min(overlap_left, overlap_right)
+                min_y = min(overlap_top, overlap_bottom)
+
+                # -------------------------
+                # HORIZONTAL COLLISION
+                # -------------------------
+                if min_x < min_y:
+
+                    if overlap_left < overlap_right:
+                        a.transform.position.x -= overlap_left
+                    else:
+                        a.transform.position.x += overlap_right
+
+                    if rb:
+                        rb.velocity.x = 0
+
+                # -------------------------
+                # VERTICAL COLLISION
+                # -------------------------
+                else:
+
+                    # TOP (ground landing)
+                    if overlap_top < overlap_bottom:
+
+                        a.transform.position.y -= overlap_top
+
+                        if rb:
+                            if rb.velocity.y > 0:
+                                rb.velocity.y = 0
+
+                   
+                    else:
+
+                        a.transform.position.y += overlap_bottom
+
+                        if rb:
+                            if rb.velocity.y < 0:
+                                rb.velocity.y = 0
+
+                # -------------------------
+                # TRIGGERS
+                # -------------------------
+                if colA.istrigger or colB.istrigger:
+                    self.call(a, "OnTriggerEnter", b)
+                    self.call(b, "OnTriggerEnter", a)
+                    self.call(a, "OnTriggerStay", b)
+                    self.call(b, "OnTriggerStay", a)
+                    continue
+
+                # -------------------------
+                # COLLISION EVENTS
+                # -------------------------
+                if pair not in self.active_collisions:
+                    self.call(a, "OnCollisionEnter", b)
+                    self.call(b, "OnCollisionEnter", a)
+
+                self.call(a, "OnCollisionStay", b)
+                self.call(b, "OnCollisionStay", a)
+
+        # -------------------------
+        # EXIT EVENTS
+        # -------------------------
+        for pair in self.active_collisions:
+            if pair not in new_collisions:
+
+                a_id, b_id = pair
+                a = next((o for o in objects if id(o) == a_id), None)
+                b = next((o for o in objects if id(o) == b_id), None)
+
+                if a and b:
+                    self.call(a, "OnCollisionExit", b)
+                    self.call(b, "OnCollisionExit", a)
+
+        self.active_collisions = new_collisions
+
+    # -------------------------
+    # MAIN LOOP
+    # -------------------------
+    def run(self, debug=False):
+
+        pygame.init()
+        self.isrun = True
+
+        last_time = time.time()
+
+        screen = pygame.display.set_mode((1920, 1080)) if debug else pygame.display.set_mode((0, 0), pygame.NOFRAME)
+
+        for obj in self.game_objects:
+            obj.start()
+
+        while self.isrun:
+
+            now_time = time.time()
+            dt = now_time - last_time
+            last_time = now_time
+
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    self.isrun = False
+
+            keys = pygame.key.get_pressed()
+
+            if keys[pygame.K_ESCAPE]:
+                self.isrun = False
+
+            # -------------------------
+            # SAVE LAST POSITION
+            # -------------------------
+            for obj in self.game_objects:
+                obj.last_position = (
+                    obj.transform.position.x,
+                    obj.transform.position.y
+                )
+
+            # -------------------------
+            # UPDATE
+            # -------------------------
+            for obj in self.game_objects:
+                obj.update(dt)
+
+            # -------------------------
+            # COLLISION
+            # -------------------------
+            self.check_collisions()
+
+            # -------------------------
+            # DRAW
+            # -------------------------
+            screen.fill((0, 0, 0))
+
+            for obj in self.game_objects:
+                obj.draw(screen, self.camera)
+
+            pygame.display.flip()
+
+            self.camera.update()
+
+        pygame.quit()
+
+    # -------------------------
+    # FIND SYSTEM
+    # -------------------------
+    def find(self, name):
+        for obj in self.game_objects:
+            if obj.name == name:
+                return obj
+        return None

corebitengine-0.1.1/CoreBitEngine/GameObjectSystem.py

@@ -0,0 +1,240 @@
+import pygame
+
+# =========================
+# TRANSFORM
+# =========================
+
+class Position:
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+
+
+class Size:
+    def __init__(self):
+        self.width = 100
+        self.height = 100
+
+
+class Rotation:
+    def __init__(self):
+        self.rotation = 0
+
+
+class Transform:
+    def __init__(self):
+        self.position = Position()
+        self.size = Size()
+        self.rotation = Rotation()
+
+
+# =========================
+# GAME OBJECT
+# =========================
+
+class GameObject:
+
+    def __init__(self, name):
+        self.name = name
+        self.visible = True
+        self.engine = None 
+
+        self.transform = Transform()
+        self.components = []
+
+    def add_component(self, component):
+        component.game_object = self
+        self.components.append(component)
+
+        if self.engine:
+            component.engine = self.engine
+    
+    def get_component(self, component_type):
+
+        for c in self.components:
+
+            if isinstance(c, component_type):
+                return c
+
+        return None
+
+    def start(self):
+        for c in self.components:
+            if hasattr(c, "start"):
+                c.start()
+
+    def update(self, dt):
+        for c in self.components:
+            if hasattr(c, "update"):
+                c.update(dt)
+
+    def draw(self, screen, camera):
+
+        if not self.visible:
+            return
+
+        for c in self.components:
+            if hasattr(c, "draw"):
+                c.draw(screen, camera)
+    
+    def get_component(self, component_type):
+
+        for c in self.components:
+
+            if isinstance(c, component_type):
+                return c
+
+        return None
+
+
+# =========================
+# SPRITE RENDERER
+# =========================
+
+class SpriteRenderer2D:
+
+    def __init__(self, image):
+
+        self.image_path = image
+        self.image = None
+
+    def start(self):
+
+        self.image = pygame.image.load(
+            self.image_path
+        ).convert_alpha()
+
+    def draw(self, screen, camera):
+
+        if not hasattr(self, "game_object"):
+            return
+
+        if self.image is None:
+            return
+
+        go = self.game_object
+
+        # CAMERA OFFSET
+        x, y = camera.world_to_screen(
+            go.transform.position.x,
+            go.transform.position.y
+        )
+
+        scaled_image = pygame.transform.scale(
+            self.image,
+            (
+                int(go.transform.size.width),
+                int(go.transform.size.height)
+            )
+        )
+
+        screen.blit(
+            scaled_image,
+            (x, y)
+        )
+
+
+# =========================
+# RECT RENDERER
+# =========================
+
+class RectRenderer2D:
+
+    def __init__(self, width=100, height=100, color=(255,0,0)):
+
+        self.width = width
+        self.height = height
+        self.color = color
+
+    def draw(self, screen, camera):
+
+        go = self.game_object
+
+        # CAMERA OFFSET
+        x, y = camera.world_to_screen(
+            go.transform.position.x,
+            go.transform.position.y
+        )
+
+        pygame.draw.rect(
+            screen,
+            self.color,
+            (
+                x,
+                y,
+                self.width,
+                self.height
+            )
+        )
+
+
+# =========================
+# CIRCLE RENDERER
+# =========================
+
+class CircleRenderer2D:
+
+    def __init__(self, radius=50, color=(0,255,0)):
+
+        self.radius = radius
+        self.color = color
+
+    def draw(self, screen, camera):
+
+        go = self.game_object
+
+        # CAMERA OFFSET
+        x, y = camera.world_to_screen(
+            go.transform.position.x,
+            go.transform.position.y
+        )
+
+        pygame.draw.circle(
+            screen,
+            self.color,
+            (
+                int(x),
+                int(y)
+            ),
+            self.radius
+        )
+
+
+# =========================
+# LINE RENDERER
+# =========================
+
+class LineRenderer2D:
+
+    def __init__(self, x2, y2, color=(255,255,255), width=2):
+
+        self.x2 = x2
+        self.y2 = y2
+        self.color = color
+        self.width = width
+
+    def draw(self, screen, camera):
+
+        go = self.game_object
+
+        # START POSITION
+        x1, y1 = camera.world_to_screen(
+            go.transform.position.x,
+            go.transform.position.y
+        )
+
+        # END POSITION
+        x2, y2 = camera.world_to_screen(
+            self.x2,
+            self.y2
+        )
+
+        pygame.draw.line(
+            screen,
+            self.color,
+            (x1, y1),
+            (x2, y2),
+            self.width
+        )
+
+########Coliders############

corebitengine-0.1.1/CoreBitEngine/TempLine.py

@@ -0,0 +1,170 @@
+import pygame
+import sys
+from Lib.GameObjectSystem import GameObject
+
+class Template:
+    def start(self):pass
+        
+
+
+    def update(self,dt):pass
+       
+
+    def __init__(self,):pass
+       
+
+
+class Input:
+    # =========================
+    # LETTER KEYS
+    # =========================
+    K_a = pygame.K_a
+    K_b = pygame.K_b
+    K_c = pygame.K_c
+    K_d = pygame.K_d
+    K_e = pygame.K_e
+    K_f = pygame.K_f
+    K_g = pygame.K_g
+    K_h = pygame.K_h
+    K_i = pygame.K_i
+    K_j = pygame.K_j
+    K_k = pygame.K_k
+    K_l = pygame.K_l
+    K_m = pygame.K_m
+    K_n = pygame.K_n
+    K_o = pygame.K_o
+    K_p = pygame.K_p
+    K_q = pygame.K_q
+    K_r = pygame.K_r
+    K_s = pygame.K_s
+    K_t = pygame.K_t
+    K_u = pygame.K_u
+    K_v = pygame.K_v
+    K_w = pygame.K_w
+    K_x = pygame.K_x
+    K_y = pygame.K_y
+    K_z = pygame.K_z
+
+    # =========================
+    # NUMBER KEYS
+    # =========================
+    K_0 = pygame.K_0
+    K_1 = pygame.K_1
+    K_2 = pygame.K_2
+    K_3 = pygame.K_3
+    K_4 = pygame.K_4
+    K_5 = pygame.K_5
+    K_6 = pygame.K_6
+    K_7 = pygame.K_7
+    K_8 = pygame.K_8
+    K_9 = pygame.K_9
+
+    # =========================
+    # FUNCTION KEYS
+    # =========================
+    K_F1  = pygame.K_F1
+    K_F2  = pygame.K_F2
+    K_F3  = pygame.K_F3
+    K_F4  = pygame.K_F4
+    K_F5  = pygame.K_F5
+    K_F6  = pygame.K_F6
+    K_F7  = pygame.K_F7
+    K_F8  = pygame.K_F8
+    K_F9  = pygame.K_F9
+    K_F10 = pygame.K_F10
+    K_F11 = pygame.K_F11
+    K_F12 = pygame.K_F12
+
+    # =========================
+    # ARROW KEYS
+    # =========================
+    K_UP    = pygame.K_UP
+    K_DOWN  = pygame.K_DOWN
+    K_LEFT  = pygame.K_LEFT
+    K_RIGHT = pygame.K_RIGHT
+
+    # =========================
+    # SPECIAL KEYS
+    # =========================
+    K_SPACE      = pygame.K_SPACE
+    K_ESCAPE     = pygame.K_ESCAPE
+    K_RETURN     = pygame.K_RETURN
+    K_BACKSPACE  = pygame.K_BACKSPACE
+    K_TAB        = pygame.K_TAB
+    K_LSHIFT     = pygame.K_LSHIFT
+    K_RSHIFT     = pygame.K_RSHIFT
+    K_LCTRL      = pygame.K_LCTRL
+    K_RCTRL      = pygame.K_RCTRL
+    K_LALT       = pygame.K_LALT
+    K_RALT       = pygame.K_RALT
+    K_CAPSLOCK   = pygame.K_CAPSLOCK
+
+    # =========================
+    # SYMBOL KEYS
+    # =========================
+    K_MINUS        = pygame.K_MINUS
+    K_EQUALS       = pygame.K_EQUALS
+    K_LEFTBRACKET  = pygame.K_LEFTBRACKET
+    K_RIGHTBRACKET = pygame.K_RIGHTBRACKET
+    K_SEMICOLON    = pygame.K_SEMICOLON
+    K_QUOTE        = pygame.K_QUOTE
+    K_COMMA        = pygame.K_COMMA
+    K_PERIOD       = pygame.K_PERIOD
+    K_SLASH        = pygame.K_SLASH
+    K_BACKSLASH    = pygame.K_BACKSLASH
+
+    # =========================
+    # MOUSE BUTTONS
+    # =========================
+    MOUSE_LEFT   = 0
+    MOUSE_MIDDLE = 1
+    MOUSE_RIGHT  = 2
+
+    
+   
+    def GetAxıs(self, axis, delta_time):
+
+        keys = pygame.key.get_pressed()
+
+        if not hasattr(self, "game_object"):
+            return
+
+        go = self.game_object
+
+        if axis == "Horizontal":
+
+            if keys[pygame.K_a]:
+                go.transform.position.x -= self.speed * delta_time
+
+            if keys[pygame.K_d]:
+                go.transform.position.x += self.speed * delta_time
+
+        if axis == "Vertical":
+
+            if keys[pygame.K_w]:
+                go.transform.position.y -= self.speed * delta_time
+
+            if keys[pygame.K_s]:
+                go.transform.position.y += self.speed * delta_time
+    
+    @staticmethod
+    def GetMouse(button):
+        mouse = pygame.mouse.get_pressed()
+        return mouse[button]
+
+    @staticmethod
+    def MousePosition():
+        return pygame.mouse.get_pos()
+
+    #Input  Already Command
+    @staticmethod
+    def GetKey(key):
+        keys = pygame.key.get_pressed()
+        return keys[key]
+            
+    def Exit_Game(self,exit_comman = pygame.K_ESCAPE):
+        keys = pygame.key.get_pressed()
+        if keys[exit_comman]:
+            pygame.quit()
+            sys.exit()
+

corebitengine-0.1.1/CoreBitEngine/rigidbody2D.py

@@ -0,0 +1,26 @@
+class Vector2:
+    def __init__(self,x=0,y=0):
+        self.x = x
+        self.y = y
+
+
+
+
+class Rigidbody2D:
+    def __init__(self):
+        self.velocity = Vector2()
+        self.gravity = 900
+        self.usegravity = True
+
+    def update(self,dt):
+
+        if not hasattr(self, "game_object"):
+            return
+        
+        go =self.game_object
+
+        if self.usegravity:
+            self.velocity.y += self.gravity * dt
+
+        go.transform.position.x += self.velocity.x *dt
+        go.transform.position.y += self.velocity.y *dt

{corebitengine-0.1.0/CoreBitEngine/corebitengine.egg-info → corebitengine-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corebitengine
-Version: 0.1.0
+Version: 0.1.1
 Summary: Kendi oyun motoru sistemlerim için kütüphane
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown

{corebitengine-0.1.0 → corebitengine-0.1.1/corebitengine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corebitengine
-Version: 0.1.0
+Version: 0.1.1
 Summary: Kendi oyun motoru sistemlerim için kütüphane
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown

corebitengine-0.1.1/corebitengine.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+CoreBitEngine/CameraSystem.py
+CoreBitEngine/ColliderSystem.py
+CoreBitEngine/Engine.py
+CoreBitEngine/GameObjectSystem.py
+CoreBitEngine/TempLine.py
+CoreBitEngine/rigidbody2D.py
+corebitengine.egg-info/PKG-INFO
+corebitengine.egg-info/SOURCES.txt
+corebitengine.egg-info/dependency_links.txt
+corebitengine.egg-info/requires.txt
+corebitengine.egg-info/top_level.txt

corebitengine-0.1.1/corebitengine.egg-info/top_level.txt

@@ -0,0 +1 @@
+CoreBitEngine

{corebitengine-0.1.0 → corebitengine-0.1.1}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "corebitengine"
-version = "0.1.0"
+version = "0.1.1" # Versiyonu 0.1.1 yapıyoruz ki güncelleme algılansın
 description = "Kendi oyun motoru sistemlerim için kütüphane"
-readme = "README.md" # İsteğe bağlı: Proje açıklaması için bir markdown dosyası
+readme = "README.md"
 requires-python = ">=3.7"
 dependencies = [
     "pygame"
 ]
 
-[tool.setuptools.packages.find]
-where = ["CoreBitEngine"]  # Kodların hangi klasörde aranacağını belirtir
+# En temiz ve hatasız paket bulma yöntemi budur:
+[tool.setuptools]
+packages = ["CoreBitEngine"]

corebitengine-0.1.0/CoreBitEngine/corebitengine.egg-info/SOURCES.txt

@@ -1,6 +0,0 @@
-pyproject.toml
-CoreBitEngine/corebitengine.egg-info/PKG-INFO
-CoreBitEngine/corebitengine.egg-info/SOURCES.txt
-CoreBitEngine/corebitengine.egg-info/dependency_links.txt
-CoreBitEngine/corebitengine.egg-info/requires.txt
-CoreBitEngine/corebitengine.egg-info/top_level.txt

corebitengine-0.1.0/CoreBitEngine/corebitengine.egg-info/top_level.txt

@@ -1 +0,0 @@
-