update 0.1.2.1

Author: SkyNeon22

core/game/__init__.py

@@ -0,0 +1,11 @@
+from core.game.behaviors import *
+from core.game.enemy import *
+from core.game.projectile import *
+from core.game.stage import *
+from core.game.player import *
+from core.game.pickups import *
+from core.game.registries import *
+from core.game.menusystem import *
+from core.game.triggers import *
+from core.game.dialogue import *
+from core.game.colliders import *

core/game/behaviors.py

@@ -0,0 +1,53 @@
+import pygame as pg 
+
+# A basic skeleton
+class Behavior:
+    def __init__(self, game, target):
+        self.game = game
+        self.target = target
+        self.stop = False
+
+    def tick(self):
+        pass
+
+    def update(self):
+        if not self.stop:
+            self.tick()
+
+class MoveInDirection(Behavior):
+    def __init__(self, game, target, args=[[0, 0]]):
+        super().__init__(game, target)
+        self.direction = [args[0], args[1]] 
+        self.vel = [args[0], args[1]]
+    
+    def tick(self):
+        self.target.pos[0] += self.vel[0]
+        self.target.pos[1] += self.vel[1]
+
+class MoveByPoints(Behavior):
+    def __init__(self, game, target, args=()):
+        super().__init__(game, target)
+        self.waypoints = args
+        self.curwaypoint = 0
+
+    def tick(self):
+        try:
+            if self.target.pos != self.waypoints[self.curwaypoint]:
+                if self.target.pos[0] < self.waypoints[self.curwaypoint][0]:
+                    self.target.pos[0] += self.target.speed
+                elif self.target.pos[0] > self.waypoints[self.curwaypoint][0]:
+                    self.target.pos[0] -= self.target.speed
+                else:
+                    self.target.pos[0] += 0
+                if self.target.pos[1] < self.waypoints[self.curwaypoint][1]:
+                    self.target.pos[1] += self.target.speed
+                elif self.target.pos[1] > self.waypoints[self.curwaypoint][1]:
+                    self.target.pos[1] -= self.target.speed
+                else:
+                    self.target.pos[0] += 0
+            else:
+                self.curwaypoint += 1
+        except IndexError:
+            self.stop = True
+            
+    

core/game/bulletpatterns.py

@@ -0,0 +1,28 @@
+import pygame as pg
+import math
+import random
+
+def circlepattern(game, speed=1, pos=(0, 0), proj_type="big_ball_white", bullet_count=10):
+    for i in range(bullet_count):
+        game.projregistry.shoot(proj_type, pos, 360 - (360 / i), speed)
+
+
+# don't use
+class BulletPattern:
+    def __init__(self, game):
+        self.game = game
+
+    def shoot(self):
+        pass
+
+class CirclePattern(BulletPattern):
+    def __init__(self, game, speed=1, pos=(0, 0), proj_type="big_ball_white", bullet_count=10):
+        super().__init__(game)
+        self.speed = speed
+        self.pos = pos
+        self.proj_type = proj_type
+        self.bullet_count = bullet_count
+    
+    def shoot(self):
+        for i in range(self.bullet_count):
+            self.game.projregistry.shoot(self.proj_type, self.pos, 360 - (360 / i), self.speed)

core/game/colliders/__init__.py

@@ -0,0 +1,2 @@
+from core.game.colliders.colliders import *
+from core.game.colliders.colutils import *

core/game/colliders/colliders.py

@@ -0,0 +1,43 @@
+import math
+
+def dist(a, b):
+    return math.dist(a, b)
+
+class Collider:
+    def __init__(self):
+        pass
+
+class CircleCollider:
+    def __init__(self, radius=4 , pos=(0, 0)):
+        self.radius = radius
+        self.x = pos[0]
+        self.y = pos[1]
+        self.position = pos
+    
+    def colliderect(self, rect):
+        '''DISCLAIMER:\n
+        DO NOT USE IF NOT REQUIRED TO,\n
+        BECAUSE IT ONLY CHECKS FOR THE RECT'S CENTER'''
+
+        if dist(rect.center, self.position) <= self.radius:
+            return True
+        else:
+            return False
+
+    def collidecircle(self, circle):
+        if dist(self.position, circle.position) <= self.radius + circle.radius - 1:
+            return True
+        else:
+            return False
+
+    def collidepoint(self, point):
+        if dist(self.position, point) <= self.radius:
+            return True
+        else:
+            return False
+    
+    def update(self, pos=(0, 0)):
+        setattr(self, "position", pos)
+        setattr(self, "x", pos[0])
+        setattr(self, "y", pos[1])
+    

core/game/colliders/colutils.py

@@ -0,0 +1 @@
+# unused

core/game/dialogue.py

@@ -0,0 +1,104 @@
+import pygame as pg
+from core.visuals.ui import *
+from ursina import Entity
+
+class Dialogue:
+    '''Values:
+        is_skippable: bool
+        maxtime: int
+        text: str
+
+        Errors:
+            ...
+        '''
+    default_values = {
+        'maxshowtime': 400, 'is_skippable': True, 'text': "Test"
+    }
+    def __init__(self, game, dialoguemanager, **kwargs):
+        self.game = game
+        self.dialogmanage = dialoguemanager
+        self.text = "Test\nMultiline"
+        self.is_skippable = True
+        self.on_scr_time = 0
+        self.maxtime = 400
+        for key, value in kwargs.items():
+            setattr(self, key, value) 
+    
+    def todict(self): # method for saving an enemy object to a stage file
+        return {"game": None,
+                "text": self.text,
+                "is_skippable": self.is_skippable,
+                "maxshowtime": self.maxtime
+        }
+
+    @classmethod
+    def fromdict(cls, asset, game=None, dialogmanager=None): # method for loading an enemy object from a stage file
+        return cls(game, dialogmanager, text=asset["text"], is_skippable=asset["is_skippable"], maxtime=asset["maxshowtime"])
+    
+    def update(self):
+        self.on_scr_time += 1
+        if self.on_scr_time >= self.maxtime:
+            return True
+        else:
+            return False
+    
+    def skip(self):
+        self.on_scr_time = self.maxtime
+    
+class DialogueCollection:
+    def __init__(self, game, dialoguemanager, dialogue=[]):
+        self.game = game
+        self.active = True
+        self.dialog_index = 0
+        self.dialogmanager = dialoguemanager
+        self.dialogue = dialogue
+    
+    def todict(self): # method for saving an enemy object to a stage file
+        return {"game": None,
+                "dialogue": self.dialogue
+        }
+
+    @classmethod
+    def fromdict(cls, asset, game=None, dialogmanager=None): # method for loading an enemy object from a stage file
+        return cls(game, dialogmanager, dialogue=asset["dialogue"])
+
+    def update(self):
+        if self.active == False:
+            for dialog in self.dialogue:
+                dialog.on_scr_time = 0
+        if len(self.dialogue) >= 1:
+            try:
+                line_height = self.dialogmanager.font.get_linesize()
+                lines = self.dialogue[self.dialog_index].text.split('\n')
+                if self.dialogue[self.dialog_index].update() == True:
+                    self.dialog_index += 1
+                for line in lines: 
+                    text_surface = self.dialogmanager.font.render(line, True, (255, 255, 255))
+                    self.game.fight_area.blit(text_surface, (self.dialogmanager.dialoguerect.left, self.dialogmanager.dialoguerect.top + self.dialogmanager.y_offset))
+                    self.dialogmanager.y_offset += line_height
+                self.dialogmanager.y_offset = self.dialogmanager.default_offset
+            except IndexError:
+                self.active = False
+
+class DialogueSystem:
+    def __init__(self, game):
+        self.game = game
+        self.active = False
+        self.active_collection = 0
+        self.dialogue_collection_dict = {0 : DialogueCollection(self.game, self, [Dialogue(self.game, self, maxshowtime=400, is_skippable=True, text="Test\nMultiline"), Dialogue(self.game, self, maxshowtime=400, is_skippable=True, text="Test NAH")])}
+        self.skip_dialogue = False
+        self.dialoguerect = pg.Rect(16, 300, 354, 130)
+        self.font = pg.font.SysFont('Comic Sans MS', 18)
+
+        self.default_offset = 0
+        self.y_offset = 0
+    
+    def update(self):
+        if self.active:
+            if len(self.dialogue_collection_dict) >= 1 and self.dialogue_collection_dict[self.active_collection].active == True:
+                pg.draw.rect(self.game.fight_area, (40, 40, 40, 150), self.dialoguerect)
+                self.dialogue_collection_dict[self.active_collection].update()
+    
+    def skip(self):
+        if len(self.dialogue_collection_dict) >= 1 and self.dialogue_collection_dict[self.active_collection].active == True:
+            self.dialogue_collection_dict[self.active_collection].dialogue[self.dialogue_collection_dict[self.active_collection].dialog_index].skip()