readme

README.md

@@ -1,6 +1,6 @@
 # np-tetris
 
-`main.py`: tetris in `numpy`
+`main.py`: tetris in pure python + `numpy`
 `tetris.py`: tetris with `curses`
 `snake.py`: snake with `curses` and `numpy`
 

main.py

@@ -32,14 +32,13 @@ def attempt_rotate(piece, board, i, j):
     return piece
 
 
-def clear_rows(board, score):
+def clear_rows(board):
     clear_indices = np.where(np.all(board == 1, axis=1))[0]
     if clear_indices.size > 0:
         board = np.delete(board, clear_indices, axis=0)
         new_rows = np.zeros((len(clear_indices), board.shape[1]))
         board = np.vstack([new_rows, board])
-        score = update_score(score)
+    return board
-    return board, score
 
 
 def calculate_shadow(piece, board, i, j):
@@ -49,7 +48,7 @@ def calculate_shadow(piece, board, i, j):
     return i
 
 
-def display_board(board, piece, i, j, score):
+def display_board(board, piece, i, j):
     display = board.copy()
     shadow_i = calculate_shadow(piece, board, i, j)
     n, m = piece.shape
@@ -70,7 +69,7 @@ def display_board(board, piece, i, j, score):
             for row in display
         )
     )
-    print(f"Score: {score}\n")
+    print()
 
 
 def game_over(board):
@@ -80,12 +79,8 @@ def game_over(board):
         board
     )  # Clear the board and continue or call sys.exit() to end
 
-def update_score(score):
-    return score + 1
-
 
 def main():
-    score = 0
     board = np.zeros((20, 10), dtype=int)
     piece_types = list(PIECES.keys())
     current_piece = PIECES[np.random.choice(piece_types)]
@@ -94,7 +89,7 @@ def main():
     auto_gravity = True  # Auto-gravity enabled by default
 
     while True:
-        display_board(board, current_piece, i, j, score)
+        display_board(board, current_piece, i, j)
         if not check_placement(current_piece, board, *START_POS):
             board = game_over(board)
             continue
@@ -122,13 +117,13 @@ def main():
                 i += 1
             else:
                 board = place_piece(current_piece, board, i, j)
-                board, score = clear_rows(board, score)
+                board = clear_rows(board)
                 current_piece = PIECES[np.random.choice(piece_types)]
                 i, j = 0, 4
         elif command == "S":
             i = calculate_shadow(current_piece, board, i, j)
             board = place_piece(current_piece, board, i, j)
-            board, score = clear_rows(board, score)
+            board = clear_rows(board)
             current_piece = PIECES[np.random.choice(piece_types)]
             i, j = START_POS
         elif command == "G":
@@ -139,7 +134,7 @@ def main():
                 i += 1
             else:
                 board = place_piece(current_piece, board, i, j)
-                board, score = clear_rows(board, score)
+                board = clear_rows(board)
                 current_piece = PIECES[np.random.choice(piece_types)]
                 i, j = START_POS
 

snake.py

@@ -1,50 +1,53 @@
-import curses
-import random
-
 import numpy as np
+import curses
+import time
+import random
 
 
 def main(stdscr):
-    curses.curs_set(0)  # Hide cursor
+    curses.curs_set(0)  # Hide the cursor for a cleaner look
-    stdscr.nodelay(True)  # Don't block I/O calls
+    stdscr.nodelay(True)  # Non-blocking input to keep the game flowing
-    stdscr.timeout(100)  # Refresh rate
+    h, w = 20, 40  # Dimensions of the game board
-
+    board = np.zeros((h, w), dtype=int)  # Game board initialization
-    # Initialize the board
+    snake = [(h // 2, w // 2)]  # Starting position of the snake
-    h, w = 40, 80  # Board dimensions
+    board[h // 2, w // 2] = 1  # Mark the snake's start on the board
-    board = np.zeros((h, w), dtype=int)
-    snake = [(h // 2, w // 2)]
-    board[h // 2, w // 2] = 1
     food = (random.randint(0, h - 1), random.randint(0, w - 1))
-    board[food] = 2  # Food position
+    board[food] = 2  # Place initial food
-    direction = (0, 1)  # Initial direction (right)
+    direction = (0, 1)  # Initial movement direction
+    last_update_time = time.time()
+    move_interval = 0.1  # Base move interval in seconds
+    vertical_adjustment = 2  # Vertical moves occur every this number of base intervals
 
     while True:
-        # Input handling
         key = stdscr.getch()
-        if key in [ord("q"), ord("Q")]:
+        if key in [ord("Q"), ord("q")]:
             break
-        elif key in [ord("a"), ord("A")] and direction != (0, 1):
+        if key in [ord("a"), ord("A")] and direction != (0, 1):
             direction = (0, -1)
-        elif key in [ord("d"), ord("D")] and direction != (0, -1):
+        if key in [ord("d"), ord("D")] and direction != (0, -1):
             direction = (0, 1)
-        elif key in [ord("w"), ord("W")] and direction != (1, 0):
+        if key in [ord("w"), ord("W")] and direction != (1, 0):
             direction = (-1, 0)
-        elif key in [ord("s"), ord("S")] and direction != (-1, 0):
+        if key in [ord("s"), ord("S")] and direction != (-1, 0):
             direction = (1, 0)
-        elif key == ord(" "):  # Pause
-            stdscr.nodelay(False)
-            stdscr.getch()
-            stdscr.nodelay(True)
 
-        # Update snake position
+        current_time = time.time()
-        head = (snake[0][0] + direction[0], snake[0][1] + direction[1])
+        time_elapsed = current_time - last_update_time
-        head = (head[0] % h, head[1] % w)  # Torus wrapping
 
-        if head in snake:  # Check self-collision
+        # Adjust move interval based on direction
-            break
+        current_interval = move_interval * (
+            vertical_adjustment if direction in [(-1, 0), (1, 0)] else 1
+        )
 
-        snake.insert(0, head)  # Move head
+        if time_elapsed >= current_interval:
-        if head == food:  # Check food collision
+            new_head = (snake[0][0] + direction[0], snake[0][1] + direction[1])
+            new_head = (new_head[0] % h, new_head[1] % w)  # Toroidal field logic
+
+            if new_head in snake:
+                break  # Collision detection
+
+            snake.insert(0, new_head)
+            if new_head == food:
                 food = (random.randint(0, h - 1), random.randint(0, w - 1))
                 while food in snake:
                     food = (random.randint(0, h - 1), random.randint(0, w - 1))
@@ -52,15 +55,21 @@ def main(stdscr):
                 tail = snake.pop()
                 board[tail] = 0
 
-        board[head] = 1
+            board[new_head] = 1
             board[food] = 2
+            last_update_time = current_time  # Reset the timer
 
-        # Draw the board
+            # Clear and redraw the board
             stdscr.clear()
             for i in range(h):
                 for j in range(w):
-                char = " " if board[i, j] == 0 else "*" if board[i, j] == 1 else "O"
+                    if board[i, j] == 1:
-                stdscr.addch(i, j, char)
+                        stdscr.addch(i, j, "X")
+                    elif board[i, j] == 2:
+                        stdscr.addch(i, j, "O")
+                    else:
+                        stdscr.addch(i, j, " ")
+
             stdscr.refresh()