redis rewriting - teacher version before deriving a student version

Author: parmentelat

notebooks/tps/redis/.teacher/README-redis-corrige-nb.md

@@ -162,16 +162,27 @@ lance le jeu en lui indiquant sur quel ordinateur se trouve le serveur redis
 ### trouver son addresse IP
 
 selon les systèmes, lancez dans un terminal la commande suivante
+
 * Windows `ipconfig`
 * MacOS `ifconfig`
 * LInux `ip address show`
 
-et cherchez une adresse parmi les intervalles réservés aux adresses privées
+et cherchez une adresse parmi les intervalles réservés aux adresses privées:
 
 +++
 
-```{image} media/private-ranges.png
-:align: center
+| plage | taille |
+|-:|:-|
+| `192.168.0.0/16` | $2^{16} = 65,536$ adresses
+| `172.16.0.0/12` | $2^{20} = 1,048,576$ adresses
+| `10.0.0.0/8` | $2^{24} = 16,777,216$ adresses
+
++++
+
+```{admonition} plus de détails
+plus de détails ici
+* <https://ipstack.com/classes-of-private-ip-address>
+* le RFC: <https://datatracker.ietf.org/doc/html/rfc1918>
 ```
 
 +++
@@ -182,7 +193,7 @@ dans notre configuration, si Pierre est sur l'adresse disons `192.168.200.20`,
 il suffit aux autres joueurs qui veulent le rejoindre de lancer par exemple
 
 ```
-game.py --server 192.168.200.20 Jacques
+python game.py --server 192.168.200.20 Jacques
 ```
 
 +++

notebooks/tps/redis/README-redis-nb.md

@@ -162,16 +162,27 @@ lance le jeu en lui indiquant sur quel ordinateur se trouve le serveur redis
 ### trouver son addresse IP
 
 selon les systèmes, lancez dans un terminal la commande suivante
+
 * Windows `ipconfig`
 * MacOS `ifconfig`
 * LInux `ip address show`
 
-et cherchez une adresse parmi les intervalles réservés aux adresses privées
+et cherchez une adresse parmi les intervalles réservés aux adresses privées:
 
 +++
 
-```{image} media/private-ranges.png
-:align: center
+| plage | taille |
+|-:|:-|
+| `192.168.0.0/16` | $2^{16} = 65,536$ adresses
+| `172.16.0.0/12` | $2^{20} = 1,048,576$ adresses
+| `10.0.0.0/8` | $2^{24} = 16,777,216$ adresses
+
++++
+
+```{admonition} plus de détails
+plus de détails ici
+* <https://ipstack.com/classes-of-private-ip-address>
+* le RFC: <https://datatracker.ietf.org/doc/html/rfc1918>
 ```
 
 +++
@@ -182,7 +193,7 @@ dans notre configuration, si Pierre est sur l'adresse disons `192.168.200.20`,
 il suffit aux autres joueurs qui veulent le rejoindre de lancer par exemple
 
 ```
-game.py --server 192.168.200.20 Jacques
+python game.py --server 192.168.200.20 Jacques
 ```
 
 +++

notebooks/tps/redis/game.py

@@ -1,24 +1,39 @@
 #!/usr/bin/env python
+
 from argparse import ArgumentParser
 
 import pygame as pg
 from pygame.locals import QUIT
 
-import redis
+from redis import Redis
 
 from screen import Screen
 from player import Player
 from others import Others
 
+# 2 differents speeds
+#
+# if we do too few frames per second,
+# after another player moves, we may see it very late
+# (worst case: if FRAME_RATE is 4, then the delay may reach 250ms)
+#
+# so, we set our frame rate higher; BUT on the other hand
+# this also results in the player moving too fast
+# so FRAMES_PER_MOVE is defined so we move our player only once every n frames
+
+# how often we redisplay the screen
+FRAME_RATE = 10
+# we move our player that many times slower
+FRAMES_PER_MOVE = 3
 
-# xxx need to separate player speed and frame rate
-FRAME_RATE = 4
 
 def main():
 
     parser = ArgumentParser()
     parser.add_argument("-s", "--server", default=None,
                         help="IP adddress for the redis server")
+    parser.add_argument("-a", "--auto-move", action="store_true",
+                        help="auto move")
     parser.add_argument("name")
     args = parser.parse_args()
 
@@ -32,43 +47,46 @@ def main():
 
     clock = pg.time.Clock()
 
-    redis_server = redis.Redis(args.server)
+    redis_server = Redis(args.server, decode_responses=True)
 
     player = Player(local_player_name, H, W, redis_server)
     player.join()
 
     others = Others(redis_server)
 
     # ask the redis server where the other players are
-    players = others.all_players()
+    players = others.fetch_all_players()
     screen.display(players)
 
     # type 'a' to toggle auto move
-    auto_move = False
+    auto_move = args.auto_move
 
+    counter = 0
     while True:
+        # sync with the frame rate
         clock.tick(FRAME_RATE)
-        if auto_move:
-            player.random_move()
-        for event in pg.event.get():
-            if (event.type == QUIT or
-                (event.type == pg.KEYDOWN and event.key == pg.K_q)):
-                player.leave()
-                return
-            if event.type == pg.KEYDOWN:
-                if event.key == pg.K_UP:
-                    player.move(0, -1)
-                elif event.key == pg.K_DOWN:
-                    player.move(0, 1)
-                elif event.key == pg.K_RIGHT:
-                    player.move(1, 0)
-                elif event.key == pg.K_LEFT:
-                    player.move(-1, 0)
-                elif event.key == pg.K_a:
+        # get the position of other players
+        players = others.fetch_all_players()
+
+        # move the local player
+        # actually do all this only once every FRAMES_PER_MOVE frames
+        counter += 1
+        if counter % FRAMES_PER_MOVE == 0:
+            counter = 0
+            if auto_move:
+                player.random_move()
+
+            for event in pg.event.get():
+                if (event.type == QUIT or
+                    (event.type == pg.KEYDOWN and event.key == pg.K_q)):
+                    player.leave()
+                    return
+                elif event.type == pg.KEYDOWN and event.key == pg.K_a:
                     auto_move = not auto_move
-        # again, refresh the position of other players
-        players = others.all_players()
-        # and redisplay accordingly
+                else:
+                    player.handle_event(event)
+
+        # redisplay accordingly every frame
         screen.display(players)
 
 

notebooks/tps/redis/others.py

@@ -8,7 +8,7 @@ def __init__(self, redis_server):
         # a handle to the redis server
         self.redis_server = redis_server
 
-    def all_players(self):
+    def fetch_all_players(self):
         # xxx need to optimize these multiple round trips
         player_names = self.redis_server.keys()
         players = []

notebooks/tps/redis/player.py

@@ -1,6 +1,8 @@
 import random
 import json
 
+import pygame as pg
+
 def random_color():
     return [random.randint(0, 255) for _ in range(3)]
 
@@ -35,10 +37,11 @@ def join(self):
         add local name to database
         with a random color
         """
-        self.redis_server.hmset(
+        self.redis_server.hset(
             self.name,
-            {'color' : json.dumps(self.color),
-             'position': json.dumps(self.position),
+            mapping = {
+                'color' : json.dumps(self.color),
+                'position': json.dumps(self.position),
             })
 
 
@@ -59,3 +62,20 @@ def move(self, dx, dy):
         self.position[1] %= self.height
         self.redis_server.hset(self.name, 'position',
                                json.dumps(self.position))
+
+
+    def handle_event(self, event):
+        if event.type == pg.KEYDOWN:
+            match event.key:
+                case pg.K_UP:
+                    self.move(0, -1)
+                case pg.K_DOWN:
+                    self.move(0, 1)
+                case pg.K_RIGHT:
+                    self.move(1, 0)
+                case pg.K_LEFT:
+                    self.move(-1, 0)
+                case pg.K_c:
+                    self.color = random_color()
+                    self.redis_server.hset(self.name, 'color',
+                                           json.dumps(self.color))

notebooks/tps/redis/screen.py

@@ -40,11 +40,11 @@ def draw_cell(self, board_x, board_y, color=WHITE):
     def display(self, players):
         """
         players is an iterable of dictionaries
-        b'color' -> [r g b], b'position' -> [x, y]
+        'color' -> [r g b], 'position' -> [x, y]
         """
         self.screen.fill(BLACK)
         for player in players:
-            x, y = player[b'position']
-            color = player[b'color']
+            x, y = player['position']
+            color = player['color']
             self.draw_cell(x, y, color)
         pygame.display.update()