Beispiel #1
0
    def updateQuadTreeOnPosition(self, sender, old, new):
        from gameengine.managers.CollisionManager import CollisionManager

        CollisionManager().quadtree.remove(self,
                                           (*old, *(old + self._rect.size)))
        CollisionManager().quadtree.insert(self,
                                           (*new, *(new + self._rect.size)))
Beispiel #2
0
    def update(cls):
        from gameengine.core.GameObject import GameObject

        World._removeGameObjects()
        World._addGameObjects()

        GameObject._removeScripts()
        GameObject._addScripts()

        GameObject._removeComponents()
        GameObject._addComponents()

        for gameObject in cls.gameObjects:
            for script in gameObject.scripts:
                script.onPreUpdate()

        PhysicsManager().onUpdate()
        CollisionManager().onUpdate()
        InputManager().onUpdate()

        for gameObject in cls.gameObjects:
            for script in gameObject.scripts:
                script.onUpdate()

        updateTimers()
        updateInterpolations()
Beispiel #3
0
    def on_update(cls, dt: float):
        cls.dt = dt

        while not cls.callableQueue.empty():
            callable = cls.callableQueue.get()
            callable()

        for gameObject in cls.gameObjects:
            for script in gameObject.scripts:
                script.onUpdate()

        from gameengine.managers.CameraManager import CameraManager
        for camera in CameraManager().collection:
            for script in camera.scripts:
                script.onUpdate()

        from gameengine.managers.PhysicsManager import PhysicsManager
        PhysicsManager().onUpdate(dt)

        from gameengine.managers.CollisionManager import CollisionManager
        CollisionManager().onUpdate(dt)

        Timer.tick()

        for gameObject in cls.gameObjects.copy():
            for script in gameObject.scripts:
                script.onLateUpdate()

        from gameengine.managers.CameraManager import CameraManager
        for camera in CameraManager().collection:
            for script in camera.scripts:
                script.onLateUpdate()

        cls.frameCount += 1
Beispiel #4
0
    def init(self):
        self.updateRect()

        self._rect.topLeft.hasChanged += self.updateQuadTreeOnPosition
        self._rect.size.hasChanged += self.updateQuadTreeOnSize

        from gameengine.managers.CollisionManager import CollisionManager
        CollisionManager().add(self)
Beispiel #5
0
 def getCoinAbove(self):
     from gameengine.managers.CollisionManager import CollisionManager
     above: set = CollisionManager().quadtree.intersect(
         bbox=Rect(self.transform.position + (0, 20), 1, 1).bbox())
     if above:
         go = above.pop().gameObject
         if "Coin" in go.tags:
             from game.blocks.QuestionBlock import RotatingCoin
             World.instantiate(RotatingCoin, (go.transform.position))
             World.destroy(go)
Beispiel #6
0
        def updateQuadtreeOnSize(sender, oldSize, newSize):
            # print(self.worldRect, oldPosition)
            from gameengine.util.Rect import Rect
            old = Rect(
                *(self.position -
                  self.gameObject.transform.pivot.ratio.elementwise() *
                  oldSize), *oldSize)

            # print(old)

            try:
                # CollisionManager().quadtree.remove(self, old.tuple())
                CollisionManager().grid.remove(self, old)
                # print("da")
            except:
                # print("FAIL")
                pass

            # CollisionManager().quadtree.insert(self, self.worldRect.tuple())
            CollisionManager().grid.insert(self, self.worldRect)
Beispiel #7
0
    def __init__(self, gameObject):
        super().__init__(gameObject)
        CollisionManager().addObject(self)

        self.layers = []

        def updateQuadtreeOnPosition(sender, oldPosition, newPosition):
            # print(self.worldRect, oldPosition)
            from gameengine.util.Rect import Rect
            old = Rect(
                *(oldPosition -
                  self.gameObject.transform.pivot.ratio.elementwise() *
                  self.size), *self.size)

            # print(old)

            try:
                # CollisionManager().quadtree.remove(self, old.tuple())
                CollisionManager().grid.remove(self, old)
                # print("da")
            except:
                # print("FAIL")
                pass

            # CollisionManager().quadtree.insert(self, self.worldRect.tuple())
            CollisionManager().grid.insert(self, self.worldRect)

        def updateQuadtreeOnSize(sender, oldSize, newSize):
            # print(self.worldRect, oldPosition)
            from gameengine.util.Rect import Rect
            old = Rect(
                *(self.position -
                  self.gameObject.transform.pivot.ratio.elementwise() *
                  oldSize), *oldSize)

            # print(old)

            try:
                # CollisionManager().quadtree.remove(self, old.tuple())
                CollisionManager().grid.remove(self, old)
                # print("da")
            except:
                # print("FAIL")
                pass

            # CollisionManager().quadtree.insert(self, self.worldRect.tuple())
            CollisionManager().grid.insert(self, self.worldRect)
            # print(self.gameObject)

        self.position.hasChanged += updateQuadtreeOnPosition
        self.size.hasChanged += updateQuadtreeOnSize
Beispiel #8
0
	def step(self, dt):
		self.velocity += self.acceleration
		self.velocity *= self.drag
		self.acceleration *= 0

		if self.velocity.x == 0 and self.velocity.y == 0:
			return

		from gameengine.components.Collider import Collider
		collider = self.gameObject.getComponent(Collider)
		if collider is not None:
			from gameengine.managers.CollisionManager import CollisionManager
			CollisionManager().queueMovement(self.gameObject.getComponent(Collider), *(self.velocity * dt))

		else:
			self.gameObject.transform.position += (self.velocity * dt)
Beispiel #9
0
 def updateQuadTreeOnSize(self, sender, old, new):
     from gameengine.managers.CollisionManager import CollisionManager
     CollisionManager().quadtree.remove(
         self, (*self._rect.topLeft, *(self._rect.topLeft + old)))
     CollisionManager().quadtree.insert(
         self, (*self._rect.topLeft, *(self._rect.topLeft + new)))
Beispiel #10
0
    def _move(self, dx, dy):
        if not self.enabled:
            return

        if self.gameObject is not None:
            CollisionManager().queueMovement(self, dx, dy)