Merge pull request #5 from LukasZahradnik/Project-basic-core

Implement basic app core

Author: davidoluwafemi

excellent-exorcists/requirements.txt

@@ -0,0 +1,9 @@
+certifi==2019.11.28
+chardet==3.0.4
+docutils==0.16
+idna==2.8
+Kivy==1.11.1
+Kivy-Garden==0.1.4
+Pygments==2.5.2
+requests==2.22.0
+urllib3==1.25.7

excellent-exorcists/src/__init__.py

@@ -0,0 +1,22 @@
+from kivy.app import App
+
+from src.core.game_loop import GameLoop
+from src.core.screen_manager import ScreenManager
+
+
+class Game(App):
+    def __init__(self, loop: GameLoop, screen_manager: ScreenManager, **kwargs):
+        super().__init__(**kwargs)
+
+        self.loop = loop
+        self.screen_manager = screen_manager
+
+        self.loop.set_callback(self.loop_callback)
+
+    def build(self):
+        return self.screen_manager
+
+    def loop_callback(self, delta):
+        if self.screen_manager.current is not None:
+            self.screen_manager.current.update(delta)
+            self.screen_manager.current.render_screen(delta)

excellent-exorcists/src/core/__init__.py

@@ -0,0 +1,20 @@
+from kivy.clock import Clock
+
+
+class GameLoop:
+    def __init__(self):
+        self.loop = None
+        self.callback_ = lambda _: _
+
+    def set_callback(self, callback):
+        self.callback_ = callback
+
+    def callback(self, delta):
+        self.callback_(delta)
+
+    def start(self, fps: int):
+        self.loop = Clock.schedule_interval(self.callback, 1.0 / float(fps))
+
+    def stop(self):
+        if self.loop is not None:
+            self.loop.cancel()

excellent-exorcists/src/core/game.py

@@ -0,0 +1,38 @@
+from kivy.graphics.instructions import RenderContext
+from kivy.uix.widget import Widget
+
+
+class Screen(Widget):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.render_context = RenderContext()
+
+    def render(self, delta):
+        """Override this method and render graphics"""
+
+    def update(self, delta):
+        """Override this method for updating state"""
+
+    def on_create(self):
+        """Called when initialized from screen manager"""
+
+    def on_destroy(self):
+        """Called when removed from screen manager"""
+
+    def on_open(self):
+        """Called when the screen is opened"""
+
+    def on_close(self):
+        """Called when the screen is closed"""
+
+    def on_resize(self, width: int, height: int):
+        """Called on window resize"""
+
+    def clear(self):
+        self.canvas.clear()
+
+    def render_screen(self, delta):
+        """Wrapper method for render, should not be overrided"""
+        with self.canvas:
+            self.render(delta)

excellent-exorcists/src/core/game_loop.py

@@ -0,0 +1,51 @@
+from kivy.uix.widget import Widget
+from kivy.core.window import Window
+
+
+class InvalidGameScreen(Exception):
+    def __init__(self, *args, **kwargs):
+        pass
+
+
+class ScreenManager(Widget):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.screens = {}
+        self.current = None
+
+        Window.bind(on_resize=self.on_window_resize)
+
+    def on_window_resize(self, _, width: int, height: int):
+        if self.current is not None:
+            self.current.width = width
+            self.current.height = height
+            self.current.on_resize(width, height)
+
+    def add_screen(self, screen_class):
+        if screen_class in self.screens:
+            raise InvalidGameScreen(f'Game screen already in screen manager {str(screen_class)}')
+
+        screen_instance = screen_class()
+        self.screens[screen_class] = screen_instance
+        screen_instance.on_create()
+
+    def remove_screen(self, screen_class):
+        if screen_class not in self.screens:
+            raise InvalidGameScreen(f'Game screen is not registered in screen manager {str(screen_class)}')
+
+        instance = self.screens[screen_class]
+        del self.screens[screen_class]
+
+        instance.on_destroy()
+
+    def set_current_screen(self, screen_class):
+        if screen_class not in self.screens:
+            raise InvalidGameScreen(f'Invalid game screen class {str(screen_class)}')
+
+        if self.current is not None:
+            self.remove_widget(self.current)
+            self.current.on_close()
+
+        self.current = self.screens[screen_class]
+        self.current.on_open()
+        self.add_widget(self.current)

excellent-exorcists/src/core/screen.py

@@ -1,10 +1,16 @@
-from kivy.app import App
+from src.core.game import Game
+from src.core.game_loop import GameLoop
+from src.core.screen_manager import ScreenManager
 
+from src.screens.game_screen import GameScreen
 
-class GameApp(App):
-	
-	def build(self):
-		root = self.root
-	
 if __name__ == '__main__':
-	GameApp().run()
+    loop = GameLoop()
+    screen_manager = ScreenManager()
+    screen_manager.add_screen(GameScreen)
+    screen_manager.set_current_screen(GameScreen)
+
+    loop.start(60)
+    game = Game(loop, screen_manager)
+
+    game.run()

excellent-exorcists/src/core/screen_manager.py

@@ -0,0 +1,35 @@
+from kivy.graphics.vertex_instructions import Rectangle
+from kivy.graphics import Color
+from kivy.uix.label import Label
+from src.core.screen import Screen
+
+import random
+
+
+class GameScreen(Screen):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.fps = 0
+        self.positions = [(random.randint(0, 600), random.randint(0, 300)) for _ in range(100)]
+
+    def on_resize(self, width: int, height: int):
+        pass
+
+    def render(self, delta: float):
+        self.clear()
+        Color(1., 1., 0)
+
+        for pos in self.positions:
+            Rectangle(pos=pos, size=(50, 50))
+
+        Color(0, 1, 0)
+        Label(text=f'FPS: {self.fps}')
+
+    def update(self, delta: float):
+        speed = 10
+        self.fps = round(1 / delta)
+
+        for i in range(len(self.positions)):
+            x, y = self.positions[i]
+            self.positions[i] = (x + speed * delta, y + speed * delta)