cetragm 0.1.3__py3-none-any.whl

cetragm/__init__.py

@@ -0,0 +1,16 @@
+# Structure:
+# main.py
+# |- audio.py    - sfx, music
+# |- controls.py - das, arr
+# |- draw.py     - ui, stdout, terminal
+# |- srs.py      - wallkicks and rotation
+# |
+# |- game.py     - scoring, logic, hold, etc
+# |- pieces.py   - define tetrominoes
+# |- config.py   - rebind controls, gravity, etc
+# |
+# \- /assets     - for audio.py (simpleaudio)
+#    |- /sfx
+#    \- /music
+
+pass

cetragm/audio.py

@@ -0,0 +1 @@
+# Module for sound effects and persistent audio

cetragm/bag.py

@@ -0,0 +1,24 @@
+# 7-bag randomizer
+
+import random
+from cetragm.tables import pieces
+
+PIECE_BAG = list(pieces.keys())
+
+class Bag:
+    def __init__(self, preview_size: int = 5):
+        self.preview_size = preview_size
+        self.current_bag = random.sample(PIECE_BAG, len(PIECE_BAG))
+        self.next_bag = random.sample(PIECE_BAG, len(PIECE_BAG))
+    
+    def get_piece(self):
+        piece = self.current_bag.pop(0)
+        if not self.current_bag:
+            self.current_bag = self.next_bag
+            self.next_bag = random.sample(PIECE_BAG, len(PIECE_BAG))
+        return piece
+    
+    def get_preview(self):
+        upcoming = self.current_bag + self.next_bag
+        return upcoming[:self.preview_size]
+    

cetragm/config.py

@@ -0,0 +1,18 @@
+# Module for configuration the user probably wouldn't see, keymaps and gravity etc
+
+MAX_LOCK_RESETS = 15
+ARE_FRAMES = 20
+LINE_CLEAR_FRAMES = 20
+LOCK_DELAY_FRAMES = 30
+
+controls = {
+    "move_left":  ["a", "j", "\x1b[D"], # left arrow
+    "move_right": ["d", "l", "\x1b[C"], # right
+    "soft_drop":  ["s", "k", "\x1b[B"], # down
+    "hard_drop":  ["w", "i"],
+    "rotate_cw":  ["c", " ", "\x1b[A", "/"], # up
+    "rotate_ccw": ["z", "q", ","],
+    "rotate_180": ["\t", "x", "."], # tab
+    "hold":       ["e", "v"],
+    "pause":      ["\x1b", "p"],
+}

cetragm/controls.py

@@ -0,0 +1,102 @@
+# Module for binding and rebinding controls as well as taking input (threaded)
+# DAS/ARR logic
+
+from cetragm.config import controls
+import termios
+import tty
+import os
+import threading
+import queue
+import select
+import sys
+
+class InputHandler:
+    def __init__(self):
+        self.queue = queue.Queue()
+        self.stop_flag = threading.Event()
+        self.is_windows = os.name == "nt"
+        self.fd = None
+        self.old_settings = None
+            
+    def start(self):
+        self.thread = threading.Thread(target=self._poll_loop, daemon=True)
+        self.thread.start()
+    
+    def stop(self):
+        self.stop_flag.set()
+        if self.is_windows:
+            return
+        if self.fd is not None and self.old_settings is not None:
+            try:
+                termios.tcsetattr(self.fd, termios.TCSADRAIN, self.old_settings)
+            except termios.error:
+                pass
+    
+    def _poll_loop(self):
+        if self.is_windows:
+            self._poll_windows()
+        else:
+            self._poll_linux()
+    
+    def _poll_windows(self):
+        import msvcrt
+        while not self.stop_flag.is_set():
+            if msvcrt.kbhit():
+                ch = msvcrt.getwch()
+                self._process_key(ch)
+            else:
+                threading.Event().wait(0.01)
+    
+    def _poll_linux(self):
+        try:
+            self.fd = os.open("/dev/tty", os.O_RDONLY)
+        except OSError:
+            self.fd = sys.stdin.fileno()
+            
+        if not os.isatty(self.fd):
+            print("not a tty!! failing out", file=sys.stderr)
+            return
+        
+        self.old_settings = termios.tcgetattr(self.fd)
+        tty.setcbreak(self.fd)
+        
+        try:
+            while not self.stop_flag.is_set():
+                r, _, _ = select.select([self.fd], [], [], 0.02)
+                if not r:
+                    continue
+                
+                try:
+                    ch = os.read(self.fd, 1).decode(errors="ignore")
+                except OSError as e:
+                    print("OSerror:", e, file=sys.stderr)
+                    break
+                
+                if not ch:
+                    continue
+                
+                if ch == "\x1b":
+                    seq = ch
+                    while select.select([self.fd], [], [], 0.001)[0]:
+                        seq += os.read(self.fd, 1).decode(errors="ignore")
+                    key = seq
+                else:
+                    key = ch
+                self._process_key(key)
+        finally:
+            if self.old_settings is not None and os.isatty(self.fd):
+                try:
+                    termios.tcsetattr(self.fd, termios.TCSADRAIN, self.old_settings)
+                except termios.error:
+                    pass
+            if self.fd not in (None, sys.stdin.fileno()):
+                try:
+                    os.close(self.fd)
+                except OSError as e:
+                    print(e, file=sys.stderr)
+          
+    def _process_key(self, key):
+        for action, binds in controls.items():
+            if key in binds:
+                self.queue.put(action)
+                break

cetragm/draw.py

@@ -0,0 +1,154 @@
+# DRAW.PY
+# Module for drawing to the screen (stdout tomfuckery time!!!)
+import sys
+import shutil
+from cetragm.tables import pieces, grades
+from cetragm.game import collides
+
+BLOCK = "██"
+SHADOW = "▒▒"
+EMPTY = "\x1b[48;2;20;20;20m\x1b[38;2;40;40;40m[]\x1b[49m\x1b[39m"
+TOP_EMPTY = "  "
+
+termwidth = 0
+termheight = 0
+
+def validate_board(board): # check for dimensions in case game loop fucked me
+    if len(board) != 22:
+        raise ValueError(f"Board has {len(board)} rows")
+    widths = {len(r) for r in board}
+    if widths != {10}:
+        raise ValueError(f"Board has rows not 10 wide - {widths}")
+
+def format_time(ms: int) -> str: # for TGM style timer at the bottom
+    minutes = (ms // 1000) // 60 # Shame i can't make it obnoxiously big
+    seconds = (ms // 1000) % 60  # or can i...? *mice on venus*
+    hundredths = (ms % 1000) // 10
+    return f"{minutes:02}:{seconds:02}:{hundredths:02}"
+
+def color_block(piece_id: str | None): # in ["i", "z", "s", "l", "j", "t", "o"]
+    if (not piece_id) and (not piece_id.endswith("_sh")):
+        return EMPTY
+    if not piece_id.endswith("_sh"):
+        r, g, b = pieces[piece_id]["rgb"]
+        return f"\x1b[38;2;{r};{g};{b}m{BLOCK}\x1b[0m"
+    else:
+        return f"\x1b[38;2;130;130;130m{SHADOW}\x1b[0m"
+
+# public
+def draw_board(board,                              # from game.py. Board: 2d list. Entries: [0] or [1, "t"]. 
+               active_piece = None,                # {"name": "t", "pos": (0, 0), "rotation": "0"}
+               score: int = 0, grade: str = "9",   # score is used to calculate TGM grade (9 -> 1 -> S1 -> S9 -> Gm)
+               time_ms: int = 0,                   # BIG FLASHING TIMER
+               lines: int = 0, line_goal: int = 0, # for gravity level up with timer
+               hold: str | None = None,            # hold = "t"
+               next_queue: list[str] | None = None # list of 5 pieces like ["t", "i", "z", "s", "o"] (7-bag)
+               ):
+    validate_board(board)
+    height = len(board)
+    width = len(board[0])
+    
+    # display on top of static board then check collision in game.py so it doesn't lag render loop
+    overlay = [[cell[:] for cell in row] for row in board] # already the full board, needs to be colored
+    
+    # SHADOW PIECE
+    if active_piece:
+        pid = active_piece["name"]
+        shape = pieces[pid]["rotations"][active_piece["rotation"]]
+        px, py = active_piece["pos"]
+        
+        drop_y = py
+        while True:
+            drop_y += 1    
+            if collides({"name": pid, "rotation": active_piece["rotation"], "pos": [px, drop_y]}, board):
+                drop_y -= 1
+                break
+        
+        for y, row in enumerate(shape):
+            for x, val in enumerate(row):
+                if val:
+                    bx, by = px + x, drop_y + y
+                    if 0 <= bx < width and 0 <= by < height:
+                        overlay[by][bx] = [1, f"{pid}_sh"]
+    
+    # ACTUAL PIECE
+    if active_piece:
+        pid = active_piece["name"]
+        shape = pieces[pid]["rotations"][active_piece["rotation"]]
+        px, py = active_piece["pos"]
+        for y, row in enumerate(shape):
+            for x, val in enumerate(row):
+                if val:
+                    bx, by = px + x, py + y
+                    if 0 <= bx < width and 0 <= by < height:
+                        overlay[by][bx] = [1, pid]
+                        
+    left_lines = []
+    left_lines.append("│ HOLD ▼ │")
+    left_lines.append("╞════════╡")
+    if hold and hold in pieces:
+        for line in pieces[hold]["piece"]:
+            left_lines.append(f"│{line.center(8)}│") # should already be centered but why not do it again
+    else:
+        left_lines.extend(["│   ╲╱   │", "│   ╱╲   │"])
+    left_lines.append("╰────────┤")
+    for i in grades[grade]:
+        left_lines.append(i + "│")
+        
+    right_lines = []
+    right_lines.append("│ NEXT ▼ │")
+    right_lines.append("╞════════╡")
+    
+    if next_queue:
+        for num, name in enumerate(next_queue[:5]):
+            if name in pieces:
+                for line in pieces[name]["piece"]:
+                    right_lines.append(f"│{line.center(8)}│")
+            else:
+                right_lines.extend(["│   ╲╱   │", "│   ╱╲   │"])
+            right_lines.append("├────────┤" if num != 4 else "├────────╯")
+    else:
+        for i in range(5):
+            right_lines.extend(["│   ╲╱   │", "│   ╱╲   │", "├────────┤" if i != 4 else "├────────╯"])
+    right_lines.append( "│         ")
+    right_lines.append( "│ LEVEL:  ")
+    right_lines.append(f"│  \x1b[4m{str(lines):^3}\x1b[24m")
+    right_lines.append(f"│  {str(line_goal).ljust(9)}")
+    
+    frame_lines = []
+    
+    score = str(score) if len(str(score)) % 2 == 0 else ("0" + str(score))
+    wid = (width - (len(score) // 2)) - 1
+    frame_lines.append("╭────────┬"  + "─" * (wid) + f"╢{score}╟" + "─" * (wid) + "┬────────╮")
+    
+    for y in range(height):
+        row_buf = []
+        for x in range(width):
+            cell = overlay[y][x]
+            if y > 1:
+                row_buf.append(color_block(cell[1]) if cell[0] else EMPTY)
+            else:
+                row_buf.append(color_block(cell[1]) if cell[0] else TOP_EMPTY)
+                
+        right = right_lines[y] if y < len(right_lines) else "│         "
+        left = left_lines[y] if y < len(left_lines) else "         │"
+        frame_lines.append(left + "".join(row_buf) + right)
+    
+    frame_lines.append( "         ├" + "──" * width + "┤")
+    frame_lines.append(f"         │ ▶ {format_time(time_ms):^14}◀  │")
+    frame_lines.append( "         ╰" + "──" * width + "╯")
+    
+    term = shutil.get_terminal_size()
+    frame_width = len(frame_lines[0])
+    pad_x = max((term.columns - frame_width) // 2, 0)
+    pad_y = max((term.lines - len(frame_lines)) // 2, 0)
+    
+    global termwidth, termheight
+    if pad_x != termwidth or pad_y != termheight:
+        sys.stdout.write("\x1b[H\x1b[2J")
+        termwidth, termheight = pad_x, pad_y
+    
+    centered = ("\n" * pad_y) + "\n".join(" " * pad_x + ln for ln in frame_lines)
+    
+    sys.stdout.write("\x1b[H" + centered + "\n\n")
+    sys.stdout.flush()

cetragm/game.py

@@ -0,0 +1,101 @@
+# core logic like lock, gravity, and scoring
+from cetragm.tables import pieces, ROT_180, ROT_CCW, ROT_CW
+import math
+
+def get_cells(piece): # {"name": "i", "pos": (0, 0), "rotation": "0"}
+    # Gets the cells in a falling piece with its current rotation and coordinates on the board
+    shape = pieces[piece["name"]]["rotations"][piece["rotation"]]
+    px, py = piece["pos"]
+    cells = [(px + x, py + y)
+             for y, row in enumerate(shape)
+             for x, val in enumerate(row) if val]
+    return cells
+
+def collides(piece, board):
+    # Check if the piece is colliding (will want to write a new one for srs.py)
+    for (x, y) in get_cells(piece):
+        if x < 0 or x >= len(board[0]) or y >= len(board):
+            return True
+        if y >= 0 and board[y][x][0]:
+            return True
+    return False
+
+def lock_piece(piece, board, player):
+    if collides(piece, board):
+        if piece["pos"][1] == 0:
+            return board, 0, True
+        else:
+            raise ValueError("Tried to lock outside the board or lock piece over another piece (and it wasn't a loss)")
+    for i in get_cells(piece):
+        board[i[1]][i[0]] = [1, piece["name"]]
+        
+    board, cleared = clear_lines(board)
+    board_empty = all(cell[0] for row in board for cell in row)
+    soft = player.soft # TODO: ADD SOFT, OR SOFT DROP CALC
+    
+    score_gain, player.combo = get_score(player.level, cleared, player.combo, board_empty, soft)
+    player.score += score_gain
+    
+    update_level(player, cleared)
+
+    return board, cleared, False
+
+def clear_lines(board):
+    new_board = []
+    cleared = 0
+    
+    for row in board:
+        if all(cell[0] for cell in row):
+            cleared += 1
+        else:
+            new_board.append(row)
+            
+    for _ in range(cleared):
+        new_board.insert(0, [[0] for _ in range(len(board[0]))])
+    
+    return new_board, cleared
+
+def get_score(level, lines_cleared, combo, board_empty, soft):
+    if lines_cleared == 0:
+        return 0, 1 # 0 score, reset combo
+    
+    combo = combo + (2 * lines_cleared) - 2 if combo > 1 else (2 * lines_cleared) - 1
+    if combo <1:
+        combo = 1
+    bravo = 4 if board_empty else 1
+    
+    score = (math.ceil((level + lines_cleared) / 4) + soft) * lines_cleared * combo * bravo
+    return score, combo
+
+def update_level(player, cleared):
+    if player.level >= 999:
+        player.line_goal = 999
+        player.level = 999
+        return
+    
+    old_level = player.level
+    temp = old_level + 1 + int(cleared)
+    temp = 999 if temp > 999 else temp
+        
+    old_sect = old_level // 100
+    new_sect = temp // 100
+    
+    if new_sect > old_sect and cleared == 0:
+        temp = min(temp, (old_sect * 100 + 99))
+        
+    player.level = min(temp, 999)
+    
+    if player.level > 900:
+        player.line_goal = 999
+    else:
+        player.line_goal = ((player.level // 100) + 1) * 100
+        
+def rotate(current, direction):
+    if direction == +1:
+        return ROT_CW[current]
+    elif direction == -1:
+        return ROT_CCW[current]
+    elif direction == 2:
+        return ROT_180[current]
+    raise ValueError("direction should be -1, +1, or 2.")
+    return current