cetragm 0.1.2__py3-none-any.whl → 0.1.6__py3-none-any.whl

cetragm/bag.py

@@ -1,7 +1,7 @@
 # 7-bag randomizer
 
 import random
-from cgm.tables import pieces
+from cetragm.tables import pieces
 
 PIECE_BAG = list(pieces.keys())
 

cetragm/controls.py

@@ -1,7 +1,7 @@
 # Module for binding and rebinding controls as well as taking input (threaded)
 # DAS/ARR logic
 
-from cgm.config import controls
+from cetragm.config import controls
 import termios
 import tty
 import os

cetragm/draw.py

@@ -2,8 +2,8 @@
 # Module for drawing to the screen (stdout tomfuckery time!!!)
 import sys
 import shutil
-from cgm.tables import pieces, grades
-from cgm.game import collides
+from cetragm.tables import pieces, grades
+from cetragm.game import collides
 
 BLOCK = "██"
 SHADOW = "▒▒"

cetragm/game.py

@@ -1,5 +1,5 @@
 # core logic like lock, gravity, and scoring
-from cgm.tables import pieces, ROT_180, ROT_CCW, ROT_CW
+from cetragm.tables import pieces, ROT_180, ROT_CCW, ROT_CW
 import math
 
 def get_cells(piece): # {"name": "i", "pos": (0, 0), "rotation": "0"}
@@ -12,7 +12,6 @@ def get_cells(piece): # {"name": "i", "pos": (0, 0), "rotation": "0"}
     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
@@ -33,6 +32,9 @@ def lock_piece(piece, board, player):
     board_empty = all(cell[0] for row in board for cell in row)
     soft = player.soft # TODO: ADD SOFT, OR SOFT DROP CALC
     
+    if board_empty:
+        player.score += 2500
+    
     score_gain, player.combo = get_score(player.level, cleared, player.combo, board_empty, soft)
     player.score += score_gain
     

cetragm/main.py

@@ -6,11 +6,13 @@ import threading
 import signal
 import queue
 
-from cgm.draw import draw_board
-from cgm.game import lock_piece, collides, rotate
-from cgm.player import Player
-from cgm.bag import Bag
-from cgm.controls import InputHandler
+from cetragm.draw import draw_board
+from cetragm.game import lock_piece, collides
+from cetragm.player import Player
+from cetragm.bag import Bag
+from cetragm.controls import InputHandler
+from cetragm.srs import rotate_srs
+from cetragm.tables import pieces
 
 def sigint_handler(sig, frame):
     sigint.set()
@@ -19,7 +21,6 @@ def sigint_handler(sig, frame):
 sigint = threading.Event()
 lose = threading.Event()
 board_lock = threading.Lock()
-ROT_SEQ = ["0", "r", "2", "l"]
 
 signal.signal(signal.SIGINT, sigint_handler)
 
@@ -27,6 +28,27 @@ def setup_board(rows, cols):
     board = [[[0] for _ in range(cols)] for _ in range(rows)]
     return board
 
+def is_grounded(active_piece, board):
+    if not active_piece or "pos" not in active_piece:
+        return False
+    temp_pos = active_piece["pos"][:]
+    temp_pos[1] += 1
+    return collides({"name": active_piece["name"], "rotation": active_piece["rotation"], "pos": temp_pos}, board)
+
+def get_minos(active_piece):
+    if not active_piece or "name" not in active_piece:
+        return set()
+    try:
+        rot_matrix = pieces[active_piece["name"].lower()]["rotations"][active_piece["rotation"]]
+    except KeyError:
+        return set()
+    minos = set()
+    for dy, row in enumerate(rot_matrix):
+        for dx, cell in enumerate(row):
+            if cell:
+                minos.add((active_piece["pos"][0] + dx, active_piece["pos"][1] + dy))
+    return minos
+    
 def lock_and_are(player, board, shared):
     board, cleared, loss = lock_piece(player.active_piece, board, player)
     shared["board"] = board
@@ -39,6 +61,7 @@ def lock_and_are(player, board, shared):
     player.fall_progress = 0.0
     player.hold_lock = False
     player.soft = 0
+    player.lock_resets = 0
     
     if cleared:
         return "line_clear", 0.0
@@ -57,16 +80,16 @@ def lock_now(player, board, shared, bag):
     if loss:
         lose.set()
         return "loss"
-    elif cleared:
-        player.active_piece = {}
-        player.fall_progress = 0.0
-        player.soft = 0
+    
+    player.active_piece = {}
+    player.fall_progress = 0.0
+    player.soft = 0
+    player.hold_lock = False
+    player.lock_resets = 0
+    if cleared:
         return "line_clear"
     else:
         player.active_piece = {"name": bag.get_piece(), "pos": [3, 0], "rotation": "0"}
-        player.fall_progress = 0.0
-        player.soft = 0
-        player.hold_lock = False
         return "active"
 
 def input_handler(player, board, action, bag, shared, LOCK_DELAY, FRAME):
@@ -108,24 +131,18 @@ def input_handler(player, board, action, bag, shared, LOCK_DELAY, FRAME):
         return lock_now(player, board, shared, bag)
     
     elif action == "rotate_cw":
-        old_rot = piece["rotation"]
-        piece["rotation"] = rotate(old_rot, +1)
-        if collides(piece, board):
-            piece["rotation"] = old_rot
+        rotate_srs(player.active_piece, +1, board, 
+            lambda n,r,p: collides({"name": n, "rotation": r, "pos": [p[0], p[1]]}, board))
         return None
             
     elif action == "rotate_ccw":
-        old_rot = piece["rotation"]
-        piece["rotation"] = rotate(old_rot, -1)
-        if collides(piece, board):
-            piece["rotation"] = old_rot
+        rotate_srs(player.active_piece, -1, board, 
+            lambda n,r,p: collides({"name": n, "rotation": r, "pos": [p[0], p[1]]}, board))
         return None
             
     elif action == "rotate_180":
-        old_rot = piece["rotation"]
-        piece["rotation"] = rotate(old_rot, 2)
-        if collides(piece, board):
-            piece["rotation"] = old_rot
+        rotate_srs(player.active_piece, 2, board, 
+            lambda n,r,p: collides({"name": n, "rotation": r, "pos": [p[0], p[1]]}, board))
         return None
             
     elif action == "hold":
@@ -135,11 +152,12 @@ def input_handler(player, board, action, bag, shared, LOCK_DELAY, FRAME):
         player.hold_piece = player.active_piece["name"]
         if not old:
             player.active_piece = {"name": bag.get_piece(), "pos": [3, 0], "rotation": "0"}
-            player.fall_progress = 0.0
         else:
             player.active_piece = {"name": old, "pos": [3, 0], "rotation": "0"}
-            player.fall_progress = 0.0
+            
+        player.fall_progress = 0.0
         player.hold_lock = True
+        player.lock_resets = 0
         return None
     
     return None
@@ -174,7 +192,7 @@ def render_loop(shared, player, bag, fps):
             print("\x1b[H\x1b[31mRunning below 60fps!! Performance will be degraded\x1b[0m")
 
 def game_loop(shared, player, bag, inputs, fps):
-    from cgm.config import ARE_FRAMES, LINE_CLEAR_FRAMES, LOCK_DELAY_FRAMES
+    from cetragm.config import ARE_FRAMES, LINE_CLEAR_FRAMES, LOCK_DELAY_FRAMES
     FRAME = 1.0 / fps
     
     LOCK_DELAY = LOCK_DELAY_FRAMES * FRAME
@@ -190,6 +208,9 @@ def game_loop(shared, player, bag, inputs, fps):
     if not hasattr(player, "fall_progress"):
         player.fall_progress = 0.0
     
+    if not hasattr(player, "lock_resets"):
+        player.lock_resets = 0
+    
     while not sigint.is_set():
         now = time.perf_counter()
         dt = now - last_time
@@ -205,6 +226,9 @@ def game_loop(shared, player, bag, inputs, fps):
                 except queue.Empty:
                     break
                 
+                was_grounded = is_grounded(player.active_piece, board)
+                old_minos = get_minos(player.active_piece)
+                
                 new_state = input_handler(player, board, action, bag, shared, LOCK_DELAY, FRAME)
                 
                 if new_state == "ground":
@@ -216,13 +240,23 @@ def game_loop(shared, player, bag, inputs, fps):
                         phase_timer = 0.0
                     continue
                 
-                if new_state in ("line_clear", "are", "loss"):
+                if new_state in ("line_clear", "are", "loss", "active"):
                     state = new_state
                     phase_timer = 0.0
                     player.hold_lock = False
                     if state == "active":
-                        player.fall_progess = 0.0
+                        player.fall_progress = 0.0
                     break
+                
+                new_minos = get_minos(player.active_piece)
+                if new_minos != old_minos and was_grounded:
+                    now_grounded = is_grounded(player.active_piece, board)
+                    if now_grounded:
+                        player.lock_resets += 1
+                        if player.lock_resets <= 15:
+                            lock_timer = 0.0
+                    else:
+                        player.lock_resets = 0
             
             player.check_grade()
             
@@ -251,17 +285,18 @@ def game_loop(shared, player, bag, inputs, fps):
                             break
                     else:
                         lock_timer = 0.0
-                
-                piece = player.active_piece
-                temp_pos = piece["pos"].copy()
-                temp_pos[1] += 1
-                if collides({"name": piece["name"], "pos": temp_pos, "rotation": piece["rotation"]}, board):
-                    lock_timer += dt
-                if lock_timer >= LOCK_DELAY:
-                    state, lock_timer = lock_and_are(player, board, shared)
-                    if state == "loss":
-                        return
-                    phase_timer = 0.0
+                        
+                if state == "active":
+                    piece = player.active_piece
+                    temp_pos = piece["pos"].copy()
+                    temp_pos[1] += 1
+                    if collides({"name": piece["name"], "pos": temp_pos, "rotation": piece["rotation"]}, board):
+                        lock_timer += dt
+                        if lock_timer >= LOCK_DELAY:
+                            state, lock_timer = lock_and_are(player, board, shared)
+                            if state == "loss":
+                                return
+                            phase_timer = 0.0
             
             # pause after line clear
             elif state == "line_clear":
@@ -277,6 +312,7 @@ def game_loop(shared, player, bag, inputs, fps):
                     player.active_piece = {"name": bag.get_piece(), "pos": [3, 0], "rotation": "0"}
                     player.fall_progress = 0.0
                     lock_timer = 0.0
+                    player.lock_resets = 0
                     state = "active"
             
             # first piece
@@ -284,6 +320,7 @@ def game_loop(shared, player, bag, inputs, fps):
                 player.active_piece = {"name": bag.get_piece(), "pos": [3, 0], "rotation": "0"} # and again
                 player.fall_progress = 0.0
                 lock_timer = 0.0
+                player.lock_resets = 0
                 state = "active"
         
         elapsed_loop = time.perf_counter() - now

cetragm/player.py

@@ -1,7 +1,7 @@
 # module containing the Player class and its functions
 
 import time
-from cgm.tables import thresholds, gravity
+from cetragm.tables import thresholds, gravity
 
 class Player:
     def __init__(self):
@@ -23,6 +23,7 @@ class Player:
         self.combo = 0
         self.soft = 0
         self.hold_lock = False
+        self.lock_resets = 0
         self.fall_progress = 0.0
     
     def upd_time(self):

cetragm/srs.py

@@ -1 +1,161 @@
-# Definitions of the tomfuckery that is Super Rotation System (rotation and wallkicks)
+# Definitions of the tomfuckery that is Super Rotation System (rotation and wallkicks)
+
+from typing import Tuple, Callable, List, Dict
+
+Pos = Tuple[int, int]
+CollidesFn = Callable[[str, str, Pos], bool]
+
+ROT_SEQ = ["0", "r", "2", "l"]
+ROT_CW =  {"0": "r", "r": "2", "2": "l", "l": "0"}
+ROT_CCW = {"0": "l", "l": "2", "2": "r", "r": "0"}
+ROT_180 = {"0": "2", "2": "0", "r": "l", "l": "r"}
+JLSTZ_OFFSETS = {"0": (0,0), "r": (0,0), "2": (0,0), "l": (0,0)}
+
+I_OFFSETS = {
+    "0": (0, 0),
+    "r": (0, 0),
+    "2": (0, 0),
+    "l": (0, 0),
+}
+
+# These kick tables are not my values, they're from the Super Rotation System (or Tetris Guideline)
+# Also they were originally inverted until the commit that added this comment so i made an LLM invert them because im too lazy
+JLSTZ_KICKS = { 
+    ("0", "r"): [(0,0), (-1,0), (-1,-1), (0,2), (-1,2)],
+    ("r", "0"): [(0,0), (1,0), (1,1), (0,-2), (1,-2)],
+    
+    ("r", "2"): [(0,0), (1,0), (1,1), (0,-2), (1,-2)],
+    ("2", "r"): [(0,0), (-1,0), (-1,-1), (0,2), (-1,2)],
+    
+    ("2", "l"): [(0,0), (1,0), (1,-1), (0,2), (1,2)],
+    ("l", "2"): [(0,0), (-1,0), (-1,1), (0,-2), (-1,-2)],
+    
+    ("l", "0"): [(0,0), (-1,0), (-1,1), (0,-2), (-1,-2)],
+    ("0", "l"): [(0,0), (1,0), (1,-1), (0,2), (1,2)],
+}
+
+I_KICKS = {
+    ("0", "r"): [(0,0), (-2,0), (1,0), (-2,1), (1,-2)],
+    ("r", "0"): [(0,0), (2,0), (-1,0), (2,-1), (-1,2)],
+    
+    ("r", "2"): [(0,0), (-1,0), (2,0), (-1,-2), (2,1)],
+    ("2", "r"): [(0,0), (1,0), (-2,0), (1,2), (-2,-1)],
+    
+    ("2", "l"): [(0,0), (2,0), (-1,0), (2,-1), (-1,2)],
+    ("l", "2"): [(0,0), (-2,0), (1,0), (-2,1), (1,-2)],
+    
+    ("l", "0"): [(0,0), (1,0), (-2,0), (1,2), (-2,-1)],
+    ("0", "l"): [(0,0), (-1,0), (2,0), (-1,-2), (2,1)],
+}
+
+O_KICKS = {
+    ("0", "r"): [(0,0)],
+    ("r", "2"): [(0,0)],
+    
+    ("2", "l"): [(0,0)],
+    ("l", "0"): [(0,0)],
+    
+    ("r", "0"): [(0,0)],
+    ("2", "r"): [(0,0)],
+    
+    ("l", "2"): [(0,0)],
+    ("0", "l"): [(0,0)],
+}
+
+JLSTZ_KICKS_180 = {
+    ("0","2"): [(0,0), (0,-1), (0,-2), (1,0), (-1,0), (1,-1), (-1,-1)],
+    ("2","0"): [(0,0), (0,-1), (0,-2), (-1,0), (1,0), (-1,-1), (1,-1)],
+    ("r","l"): [(0,0), (0,-1), (0,-2), (1,0), (-1,0), (1,-1), (-1,-1)],
+    ("l","r"): [(0,0), (0,-1), (0,-2), (-1,0), (1,0), (-1,-1), (1,-1)],
+}
+
+I_KICKS_180 = {
+    ("0","2"): [(0,0), (0,1), (0,-1), (1,0), (-1,0), (2,0), (-2,0)],
+    ("2","0"): [(0,0), (0,1), (0,-1), (-1,0), (1,0), (-2,0), (2,0)],
+    ("r","l"): [(0,0), (0,1), (0,-1), (1,0), (-1,0)],
+    ("l","r"): [(0,0), (0,1), (0,-1), (-1,0), (1,0)],
+}
+
+def rotate_label(current: str, direction:int) -> str:
+    if direction == +1:
+        return ROT_CW[current]
+    if direction == -1:
+        return ROT_CCW[current]
+    if direction == 2:
+        return ROT_180[current]
+    return current
+
+def _offset_for(name: str, rot: str) -> Pos:
+    n = name.lower()
+    if n == "i":
+        return I_OFFSETS[rot]
+    return JLSTZ_OFFSETS[rot]
+
+def _kick_table(name: str):
+    n = name.lower()
+    if n == "i":
+        return I_KICKS
+    if n == "o":
+        return O_KICKS
+    return JLSTZ_KICKS
+
+def _kick_table_180(name: str):
+    n = name.lower()
+    if n == "i":
+        return I_KICKS_180
+    if n == "o":
+        return O_KICKS
+    return JLSTZ_KICKS_180
+
+def _get_kicks_for(name: str, fr: str, to: str, direction: int) -> List[Tuple[int,int]]:
+    table = _kick_table_180(name) if direction == 2 else _kick_table(name)
+    if (fr, to) in table:
+        return list(table[(fr,to)])
+    if (to, fr) in table:
+        return [(-dx, -dy) for dx, dy in table[(to, fr)]]
+    return [(0,0)]
+
+def try_rotate_srs(
+    name: str,
+    pos: Pos,
+    rot_label: str,
+    direction: int,
+    board,
+    collides_fn: CollidesFn,
+) -> Tuple[str, Pos, bool]: # false if no kick
+    name = name.lower()
+    if rot_label not in ROT_SEQ:
+        raise ValueError("invalid rotation")
+    if direction not in (1, -1, 2):
+        return rot_label, pos, False
+    
+    to_label = rotate_label(rot_label, direction)
+    
+    off_from = _offset_for(name, rot_label)
+    off_to = _offset_for(name, to_label)
+    delta_off = (off_from[0] - off_to[0], off_from[1] - off_to[1])
+    
+    kicks = _get_kicks_for(name, rot_label, to_label, direction)
+        
+    for dx, dy in kicks:
+        tx = pos[0] + dx + delta_off[0]
+        ty = pos[1] + dy + delta_off[1]
+        if not collides_fn(name, to_label, (tx, ty)):
+            return to_label, (tx, ty), True
+    return rot_label, pos, False
+    
+def rotate_srs(
+    piece: dict,
+    direction: int,
+    board,
+    collides_fn: CollidesFn,
+) -> bool:
+    name = piece["name"]
+    pos = tuple(piece["pos"])
+    rot = piece["rotation"]
+    new_rot, new_pos, ok = try_rotate_srs(name, pos, rot, direction, board, collides_fn)
+    if ok:
+        piece["rotation"] = new_rot
+        piece["pos"] = [int(new_pos[0]), int(new_pos[1])]
+        return True
+    return False

cetragm/tables.py

@@ -390,25 +390,29 @@ gravity = {
     90: 64,
     100: 80,
     120: 96,
-    140: 112,
-    160: 128,
-    170: 144,
+    140: 100,
+    160: 112,
+    170: 120,
     200: 4,
-    220: 32,
-    230: 64,
-    233: 96,
-    236: 128,
-    239: 160,
-    243: 192,
-    247: 224,
-    251: 256,
-    300: 512,
-    330: 768,
-    360: 1024,
-    400: 1280,
-    420: 1024,
-    450: 768,
-    500: 5120
+    220: 16,
+    230: 32,
+    233: 64,
+    236: 96,
+    239: 100,
+    243: 120,
+    247: 130,
+    251: 140,
+    300: 180,
+    330: 200,
+    360: 220,
+    400: 256, # 1g
+    420: 300,
+    450: 340,
+    500: 512,
+    600: 768,
+    700: 1024,
+    750: 1280,
+    800: 5120 # 20g
 }
 
 ROT_CW  = {"0": "r", "r": "2", "2": "l", "l": "0"}

{cetragm-0.1.2.dist-info → cetragm-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cetragm
-Version: 0.1.2
+Version: 0.1.6
 Summary: Cetra Grand Master | An oddly familiar block stacker in the command line!
 License-Expression: GPL-3.0-only
 License-File: LICENSE
@@ -29,22 +29,21 @@ Features:
 - Dynamic gravity (speed) as your level increases
 - Scoring system
 - Gameplay timer
-- 7-bag piece drawing and standard NEStris rotation system
+- 7-bag piece drawing
 - 5-piece next queue and level display
 - Persistent TLS (or shadow piece)
 - TGM's 20G gravity after level 500
 - Proper ARE, lock delay, and line clear delay
 - Real-time gravity (not tied to frame rates)
+- The standard Super Rotation System and all its janky kicks!
 
 Drawbacks:
 - Requires manual ARR/DAS and can't press two keys at once
-- Very sub-par rotation system
 - Scoring is slightly off
 - Lack of theming or menus at all, as well as a lose state
 - No sound (background or effect)
 
 To add by next week:
-- The Super Rotation System and standard wallkicks
 - T-spins and detection for them
 - IHS and IRS (Inital Hold/Rotation System)
 - Full menu with configuration

cetragm-0.1.6.dist-info/RECORD

@@ -0,0 +1,17 @@
+cetragm/__init__.py,sha256=okJMmUyau9oeoBfxhg6AYZn4nPvcTqLrAgzIDpUXMz8,382
+cetragm/audio.py,sha256=-w9omAYlvbUPRHuOe0IOBCSbBnjaOM9MjQy6oRU-hgA,47
+cetragm/bag.py,sha256=qPvDmKoduJPZuwz5DMhh9rp85MUEfUPuiFsqOfJNq2U,704
+cetragm/config.py,sha256=tJjbKxtwIWb3AMmIyBUosWkyHFO0OEzpYbqO5PHxz84,550
+cetragm/controls.py,sha256=iR-ZpudiE6J92FMZmOwZlZpcOUhxfc1bWvb18VR4Cbk,3165
+cetragm/draw.py,sha256=F4GZhNAXhxyPCksY0Pq4wjJQ904pgqCrCZ2ZDfgZHlU,6459
+cetragm/game.py,sha256=tfIEEbtZc6VxxARGdlJ7C_jBzw-rsJU2dM8I7gPqMLk,3164
+cetragm/main.py,sha256=G2ce_4AsKDHd6GU5oig5ScUfSqa2uaEVVoHn85C6fhw,11624
+cetragm/player.py,sha256=9KL5cNDYCp98OB7AiVdKISCbnmSqMn0StM2Ve3OHWGE,2469
+cetragm/srs.py,sha256=Fi4mOkaM_Qq716XUa1V4W1W2j4P7WsZmGnkOMbj7H2o,4865
+cetragm/tables.py,sha256=X3XBkTqQ7mX_jYDoDD5DfhW_cM8NOp-EU6tUY5PnoSE,12285
+cetragm/ui.txt,sha256=7wSQU8ht-5A2Fz5iFbuLTdzc1Cl6otcnqIRUw5_wZoM,2006
+cetragm-0.1.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+cetragm-0.1.6.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
+cetragm-0.1.6.dist-info/entry_points.txt,sha256=m6wjlRzXqvDPFceo250KJO4LDsEp_q2rBcCZa2lDcpo,73
+cetragm-0.1.6.dist-info/METADATA,sha256=Hi6l9TgKtRhRz6F2UZFLvBu7g-b7W3lKav0_pHCRcuE,3134
+cetragm-0.1.6.dist-info/RECORD,,

cetragm-0.1.6.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+cetragm = cetragm.main:entry
+cgm = cetragm.main:entry
+

cetragm-0.1.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-cetragm/__init__.py,sha256=okJMmUyau9oeoBfxhg6AYZn4nPvcTqLrAgzIDpUXMz8,382
-cetragm/audio.py,sha256=-w9omAYlvbUPRHuOe0IOBCSbBnjaOM9MjQy6oRU-hgA,47
-cetragm/bag.py,sha256=GOLle_p4uJIDAr81d6mT6ERK6g9N97tYTL53a5JExzA,700
-cetragm/config.py,sha256=tJjbKxtwIWb3AMmIyBUosWkyHFO0OEzpYbqO5PHxz84,550
-cetragm/controls.py,sha256=5KiPc2UlB-mdYik48F-qrhZPWwPjneGicoAcEWtcyrE,3161
-cetragm/draw.py,sha256=t_kRyYDo6miDCKzVFUBmjyBA3BYbzxN49p_85DYpwcU,6451
-cetragm/game.py,sha256=ko2ADM8q3AkXdEwQIwva4MFA2PCKOlaETjmp_Qbgwz0,3186
-cetragm/main.py,sha256=8TChVoLKkSr13nMhxPMIkNBV13_Iw-fnubJWnZzPUUQ,9971
-cetragm/player.py,sha256=BjmsyZ8XYMq8nn2T28Ze23Ey1GMv1LrzRw7OSFJYJb8,2436
-cetragm/srs.py,sha256=AV-JXtGqX6bc9mvSSlSngL5squr4P_qYz7tbBghZBB0,86
-cetragm/tables.py,sha256=MCLD4tz5fO0YJJwEqdqmXegR24kzjWkzvZP5Ev6fQEQ,12220
-cetragm/ui.txt,sha256=7wSQU8ht-5A2Fz5iFbuLTdzc1Cl6otcnqIRUw5_wZoM,2006
-cetragm-0.1.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-cetragm-0.1.2.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
-cetragm-0.1.2.dist-info/entry_points.txt,sha256=8jMkTAJSkUBD_f2FGMlk9_AdrWzhj9Ohv8TKfA1kSuk,71
-cetragm-0.1.2.dist-info/METADATA,sha256=ysMe2qfpxFpM96jXxsq3MomX6b77kIPe6Hk1zXtQFiU,3191
-cetragm-0.1.2.dist-info/RECORD,,

cetragm-0.1.2.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-cetragm = cetragm.main:main
-cgm = cetragm.main:main
-