git-sync on dita

4 files changed, 172 insertions, 22 deletions

diff --git a/pygame/gamechest b/pygame/gamechest
new file mode 120000
index 0000000..c2e0730
--- /dev/null
+++ b/pygame/gamechest
@@ -0,0 +1 @@
+../gamechestcli/gamechest
\ No newline at end of file
diff --git a/pygame/main.py b/pygame/main.py
index 948b95a..ba61077 100755
--- a/pygame/main.py
+++ b/pygame/main.py
@@ -7,6 +7,11 @@ from pathlib import Path
 import pygame
 import yaml
 
+from profiledb import ProfileDB
+
+from gamechest.cliactions import run
+from gamechest.gamedb import GameDB
+
 
 #WINDOW_RESOLUTION = (1280, 720)
 WINDOW_RESOLUTION = (800, 600)
@@ -24,19 +29,32 @@ class AppState:
     menu_selected_index: int = 0
 
 
+class Parameters:
+    key_delay = 330
+    key_interval = 1000//25
+
+
+
+
 class GuiApp:
 
     def __init__(self):
         pygame.init()
+        pygame.key.set_repeat(Parameters.key_delay, Parameters.key_interval)
         #print(pygame.display.list_modes())
         self.window = pygame.display.set_mode(WINDOW_RESOLUTION)
         self.clock = pygame.time.Clock()
+        self.cycles_per_second = 60
+        #self.render_factor_div = 2 # 60/2 => 30fps
+        #self.input_factor_div = 6 # 60/6 => 10 input repeat per second
         self.menu_font = pygame.font.Font(pygame.font.get_default_font(), 32)
         self.font_antialias = True
         #self.font_antialias = False
         self.menu_color = (0, 0, 200)
+        self.render_timer = 0
+        self.render_timeout = 1000//30 # 30 fps
 
-    def process_input(self, event=None):
+    def process_input(self, last_frame_time, event=None):
         if event is None:
             event = pygame.event.poll()
         if event.type == pygame.KEYDOWN:
@@ -46,10 +64,15 @@ class GuiApp:
         if event.type == pygame.QUIT:
             raise QuitEvent()
 
-    def update(self):
+    def update(self, last_frame_time):
         pass
 
-    def render(self):
+    def render(self, last_frame_time):
+        self.render_timer += last_frame_time
+        if self.render_timer < self.render_timeout:
+            return
+        self.render_timer = 0
+
         self.window.fill((0, 0, 0))
 
         # Initial y
@@ -98,13 +121,26 @@ class GuiApp:
 
 
     def loop(self):
-
+        #current_render_div = self.render_factor_div
+        #current_input_div = self.input_factor_div
+        last_frame_time = 1 # equivalent to 0 but avoid div0
+        last_render_time = 1
         try:
             while 1:
-                self.process_input()
-                self.update()
-                self.render()
-                self.clock.tick(30) # 30 fps
+                #current_render_div -= 1
+                #current_input_div -= 1
+                self.process_input(last_frame_time)
+                #self.update(current_input_div)
+                self.update(last_frame_time)
+                self.render(last_frame_time)
+                #if current_render_div <= 0:
+                #    self.render(last_render_time)
+                #    current_render_div = self.render_factor_div
+                #    last_render_time = 0
+                #if current_input_div <= 0:
+                #    current_input_div = self.input_factor_div
+                last_frame_time = self.clock.tick(self.cycles_per_second)
+                #last_render_time += last_frame_time
         except QuitEvent:
             pass
 
@@ -112,23 +148,107 @@ class GuiApp:
         pygame.quit()
 
 
-class GuiAppSub1(GuiApp):
+class ProfileDataObserver:
+
+    def event_current_profile_changed(self, new_profile):
+        pass
+
+
+class ObservedSubject:
+    def __init__(self):
+        self.observers = []
+
+    def add_observer(self, observer):
+        self.observers.append(observer)
+
+    def del_observer(self, observer):
+        self.observers.remove(observer)
+
+    def notify_event(self, event_name, *args, **kws):
+        for observer in self.observers:
+            getattr(observer, event_name)(*args, **kws)
+
+
+class ProfileData(ObservedSubject):
 
     def __init__(self):
         super().__init__()
+        self.profiledb = ProfileDB()
+        self.profiles_len = len(self.profiledb.get_profiles())
+        self.current_profile_index = 0
+
+    def change_active_profile(self, new_index):
+        if new_index < 0:
+            new_index = 0
+        elif new_index >= self.profiles_len:
+            new_index = self.profiles_len-1
+        if self.current_profile_index != new_index:
+            print('new index', self.current_profile_index, '->', new_index)
+            self.current_profile_index = new_index
+            print(id(self), 'new index', self.current_profile_index)
+            self.notify_event('event_current_profile_changed',
+                              self.get_current_profile())
+
+    def change_profile_increase(self):
+        self.change_active_profile(self.current_profile_index +1)
+
+    def change_profile_decrease(self):
+        self.change_active_profile(self.current_profile_index -1)
+
+    def get_current_profile(self):
+        return self.profiledb.get_profiles()[self.current_profile_index]['name']
+
+    def get_current_display(self):
+        return self.profiledb.get_profiles()[self.current_profile_index]['display']
+
+
+class ProfileRenderer(ProfileDataObserver):
+
+    def __init__(self, profiledata):
+        self.profiledata = profiledata
+        self.surface_to_render = None
+        profiledata.add_observer(self)
+        self.font_filename = pygame.font.match_font('bitstreamverasans')
+        print('ProfileRenderer font:', self.font_filename)
+        self.font = pygame.font.Font(self.font_filename, 24)
+        self.font_antialias = True
+        self.font_fg_color = (0, 200, 200)
+
+    def event_current_profile_changed(self, new_profile):
+        self.surface_to_render = None
+        print('changing rendering profile to', new_profile)
+
+    def render(self, surface):
+        if self.surface_to_render is None:
+            profile_name = self.profiledata.get_current_profile()
+            new_surface = self.font.render(self.profiledata.get_current_display(), self.font_antialias, self.font_fg_color)
+            self.surface_to_render = new_surface
+        surface.blit(self.surface_to_render, (50, 50))
+
+
+class GuiAppSub1(GuiApp):
 
+    def __init__(self):
+        super().__init__()
+        self.input_timer = 0
+        self.input_timeout = 1000//10
         self.state = AppState()
         self.base_window_fill_color = (0, 0, 0)
         self.user_move_vector = (0, 0)
-        with Path('~/games/.saves/gamedata.yaml').expanduser().open() as fp:
-            self.gamedb = yaml.safe_load(fp)
-        self.menu_items = [x['title'] for x in self.gamedb['games']]
+        #with Path('~/games/.saves/gamedata.yaml').expanduser().open() as fp:
+        #    self.gamedb = yaml.safe_load(fp)
+        self.game_db = GameDB()
+        #self.menu_items = [x['title'] for x in self.gamedb['games']]
+        self.menu_items = list(self.game_db.get_ids())
         self.menu_font_cache = ({}, [])
         self.menu_font_cache_max = 40
-        self.image_right_arrow = pygame.image.load('arrow-right.png')
+        self.image_right_arrow = pygame.image.load('arrow-right.png').convert()
         #self.last_movement_update_time = self.clock.
         self.joysticks = {}
         self.joysticks_axis_threshold = 0
+        self.profile_data = ProfileData()
+        self.profile_renderer = ProfileRenderer(self.profile_data)
+
 
     def menu_font_render(self, text):
         cached_surface = self.menu_font_cache[0].get(text, None)
@@ -153,7 +273,8 @@ class GuiAppSub1(GuiApp):
 
         return new_surface
 
-    def process_input(self):
+    def process_input(self, last_frame_time):
+
         movement_up_keys = (
             pygame.K_UP,
             pygame.K_k,
@@ -168,22 +289,22 @@ class GuiAppSub1(GuiApp):
             x, y = self.user_move_vector
             if event.type == pygame.KEYDOWN:
                 if event.key in (*movement_up_keys, *movement_down_keys):
-                    y += 1 if event.key in movement_down_keys else -1
+                    y = 1 if event.key in movement_down_keys else -1
                     go_super = 0
                 elif event.key in (pygame.K_LEFT, pygame.K_RIGHT):
-                    x += 1 if event.key == pygame.K_LEFT else -1
+                    x = -1 if event.key == pygame.K_LEFT else 1
                     go_super = 0
             elif event.type == pygame.KEYUP:
                 x, y = self.user_move_vector
                 if event.key in (*movement_up_keys, *movement_down_keys):
-                    y -= 1 if event.key in movement_down_keys else -1
+                    y = 0
                     go_super = 0
                 elif event.key in (pygame.K_LEFT, pygame.K_RIGHT):
-                    x -= 1 if event.key == pygame.K_LEFT else -1
+                    x = 0
                     go_super = 0
             elif event.type in (pygame.JOYBUTTONDOWN, pygame.JOYBUTTONUP):
                 go_super = 0
-                factor = 1 if pygame.JOYBUTTONDOWN else -1
+                factor = 1 if pygame.JOYBUTTONDOWN else 0
                 joystick = self.joysticks[event.instance_id]
                 print('gamepad event', event)
                 #if event.button == 0:
@@ -226,9 +347,14 @@ class GuiAppSub1(GuiApp):
                     self.user_move_vector = (x, y)
                 print('new move vector:', self.user_move_vector)
             else:
-                super().process_input(event)
+                super().process_input(last_frame_time, event)
+
+    def update(self, last_frame_time):
+        #self.input_timer += last_frame_time
+        #if self.input_timer < self.input_timeout:
+        #    return
+        #self.input_timer = 0
 
-    def update(self):
         menu_new_index = self.state.menu_selected_index
         if self.user_move_vector[1] < 0:
             menu_new_index -= 1
@@ -240,7 +366,14 @@ class GuiAppSub1(GuiApp):
             menu_new_index = len(self.menu_items)-1
         self.state.menu_selected_index = menu_new_index
 
-    def render(self):
+        if self.user_move_vector[0] < 0:
+            self.profile_data.change_profile_decrease()
+        elif self.user_move_vector[0] > 0:
+            self.profile_data.change_profile_increase()
+
+        self.user_move_vector = (0, 0)
+
+    def render(self, last_frame_time):
         self.window.fill(self.base_window_fill_color)
 
         # Initial y
@@ -299,6 +432,7 @@ class GuiAppSub1(GuiApp):
         #pygame.draw.rect(self.window,
         #                (0,0,255),
         #                (120,120,400,240))
+        self.profile_renderer.render(self.window)
 
         pygame.display.update()
 
diff --git a/pygame/profiledb.py b/pygame/profiledb.py
new file mode 100644
index 0000000..190d401
--- /dev/null
+++ b/pygame/profiledb.py
@@ -0,0 +1,14 @@
+from pathlib import Path
+
+import yaml
+
+
+class ProfileDB:
+
+    def __init__(self):
+        with Path('~/games/.saves/profiles.yaml').expanduser().open() as fp:
+            self.profiledb = yaml.safe_load(fp)
+
+    def get_profiles(self):
+        # currently contains {name, display}
+        return self.profiledb['profiles']
diff --git a/pygame/requirements.txt b/pygame/requirements.txt
new file mode 100644
index 0000000..0cb7ff1
--- /dev/null
+++ b/pygame/requirements.txt
@@ -0,0 +1 @@
+pygame