libascii 0.1.0__py3-none-any.whl

libascii/__init__.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, overload
+
+if TYPE_CHECKING:
+    from .chars import CharLib
+    from .color import Color
+    from .game import Game
+    from .grid import Grid
+    from .shapes.ellipse import Ellipse
+    from .shapes.line import Line
+    from .shapes.rectangle import Rectangle
+    from .shapes.shape import Shape
+    from .shapes.triangle import Triangle
+    from .sound import Sound
+
+
+@overload
+def __getattr__(name: Literal["Color"]) -> type[Color]: ...
+
+
+@overload
+def __getattr__(name: Literal["Grid"]) -> type[Grid]: ...
+
+
+@overload
+def __getattr__(name: Literal["CharLib"]) -> CharLib: ...
+
+
+@overload
+def __getattr__(name: Literal["Game"]) -> type[Game]: ...
+
+
+@overload
+def __getattr__(name: Literal["Shape"]) -> type[Shape]: ...
+
+
+@overload
+def __getattr__(name: Literal["Rectangle"]) -> type[Rectangle]: ...
+
+
+@overload
+def __getattr__(name: Literal["Ellipse"]) -> type[Ellipse]: ...
+
+
+@overload
+def __getattr__(name: Literal["Triangle"]) -> type[Triangle]: ...
+
+
+@overload
+def __getattr__(name: Literal["Line"]) -> type[Line]: ...
+
+
+@overload
+def __getattr__(name: Literal["Sound"]) -> type[Sound]: ...
+
+
+@overload
+def __getattr__(name: str) -> object: ...
+
+
+def __getattr__(name: str) -> object:
+    match name:
+        case "Color":
+            from .color import Color
+
+            return Color
+        case "Grid":
+            from .grid import Grid
+
+            return Grid
+        case "CharLib":
+            from .chars import CharLib
+
+            return CharLib
+        case "Game":
+            from .game import Game
+
+            return Game
+        case "Shape":
+            from .shapes.shape import Shape
+
+            return Shape
+        case "Rectangle":
+            from .shapes.rectangle import Rectangle
+
+            return Rectangle
+        case "Ellipse":
+            from .shapes.ellipse import Ellipse
+
+            return Ellipse
+        case "Triangle":
+            from .shapes.triangle import Triangle
+
+            return Triangle
+        case "Line":
+            from .shapes.line import Line
+
+            return Line
+        case "Sound":
+            from .sound import Sound
+
+            return Sound
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

libascii/_utils/keymapping.py

@@ -0,0 +1,60 @@
+MODIFIER_MAP = {
+    "ctrl": "Control",
+    "shift": "Shift",
+    "alt": "Alt",
+    "meta": "Meta",
+}
+
+MODIFIER_ORDER = ("ctrl", "shift", "alt", "meta")
+
+
+def expand_keybinding(keybinding: str) -> list[tuple[frozenset[str], str]]:
+    combinations: list[tuple[frozenset[str], str]] = []
+    for pattern in keybinding.split(" or "):
+        pattern_combos: list[tuple[frozenset[str], str | None]] = [
+            (frozenset(), None)
+        ]
+
+        for token in [token.strip() for token in pattern.split("+")]:
+            if token.startswith("[") and token.endswith("]"):
+                modifier = token[1:-1]
+                expanded: list[tuple[frozenset[str], str | None]] = []
+
+                for modifiers, key in pattern_combos:
+                    expanded.append((modifiers, key))
+                    expanded.append((modifiers | {modifier}, key))
+                pattern_combos = expanded
+            elif token.startswith("{") and token.endswith("}"):
+                choices = [choice.strip() for choice in token[1:-1].split(",")]
+                expanded = []
+                for modifiers, key in pattern_combos:
+                    for choice in choices:
+                        expanded.append((modifiers | {choice}, key))
+                pattern_combos = expanded
+            elif token in MODIFIER_MAP:
+                pattern_combos = [
+                    (modifiers | {token}, key)
+                    for modifiers, key in pattern_combos
+                ]
+            else:
+                pattern_combos = [
+                    (modifiers, token) for modifiers, _ in pattern_combos
+                ]
+
+        for modifiers, key in pattern_combos:
+            if key is not None:
+                combinations.append((modifiers, key))
+    return combinations
+
+
+def keybinding_to_events(keybinding: str, event_type: str) -> list[str]:
+    events: list[str] = []
+    for modifiers, key in expand_keybinding(keybinding):
+        ordered = [
+            MODIFIER_MAP[modifier]
+            for modifier in MODIFIER_ORDER
+            if modifier in modifiers
+        ]
+        parts = [*ordered, event_type, key]
+        events.append(f"<{'-'.join(parts)}>")
+    return events

libascii/chars.py

@@ -0,0 +1,134 @@
+CharLib: dict[str, dict[str | int, str]] = {
+    "MAIN": {
+        "BLANK": " ",
+        "LIGHT_SHADE": "░",
+        "MEDIUM_SHADE": "▒",
+        "DARK_SHADE": "▓",
+        "BLOCK": "█",
+        "SQUARE_BLACK": "■",
+        "SQUARE_WHITE": "□",
+        "CIRCLE_BLACK": "●",
+        "CIRCLE_WHITE": "○",
+        "DIAMOND_BLACK": "◆",
+        "DIAMOND_WHITE": "◇",
+        "TRIANGLE_UP_BLACK": "▲",
+        "TRIANGLE_UP_WHITE": "△",
+        "TRIANGLE_DOWN_BLACK": "▼",
+        "TRIANGLE_DOWN_WHITE": "▽",
+        "TRIANGLE_LEFT_BLACK": "◀",
+        "TRIANGLE_LEFT_WHITE": "◁",
+        "TRIANGLE_RIGHT_BLACK": "▶",
+        "TRIANGLE_RIGHT_WHITE": "▷",
+    },
+    "PIPE_ASCII": {
+        "HORIZONTAL": "-",
+        "VERTICAL": "|",
+        "TOP_LEFT": "/",
+        "TOP_RIGHT": "\\",
+        "CROSS": "+",
+    },
+    "PIPE_EXTENDED": {
+        "HORIZONTAL": "─",
+        "VERTICAL": "│",
+        "BOTTOM_LEFT_TURN": "┌",
+        "BOTTOM_RIGHT_TURN": "┐",
+        "TOP_LEFT_TURN": "└",
+        "TOP_RIGHT_TURN": "┘",
+        "T_UP": "┴",
+        "T_DOWN": "┬",
+        "T_LEFT": "┤",
+        "T_RIGHT": "├",
+        "CROSS": "┼",
+        "HEAVY_HORIZONTAL": "━",
+        "HEAVY_VERTICAL": "┃",
+        "HEAVY_BOTTOM_LEFT_TURN": "┏",
+        "HEAVY_BOTTOM_RIGHT_TURN": "┓",
+        "HEAVY_TOP_LEFT_TURN": "┗",
+        "HEAVY_TOP_RIGHT_TURN": "┛",
+        "HEAVY_T_UP": "┻",
+        "HEAVY_T_DOWN": "┳",
+        "HEAVY_T_LEFT": "┫",
+        "HEAVY_T_RIGHT": "┣",
+        "HEAVY_CROSS": "╋",
+        "DOUBLE_HORIZONTAL": "═",
+        "DOUBLE_VERTICAL": "║",
+        "DOUBLE_BOTTOM_LEFT_TURN": "╔",
+        "DOUBLE_BOTTOM_RIGHT_TURN": "╗",
+        "DOUBLE_TOP_LEFT_TURN": "╚",
+        "DOUBLE_TOP_RIGHT_TURN": "╝",
+        "DOUBLE_T_UP": "╩",
+        "DOUBLE_T_DOWN": "╦",
+        "DOUBLE_T_LEFT": "╣",
+        "DOUBLE_T_RIGHT": "╠",
+        "DOUBLE_CROSS": "╬",
+        "ROUNDED_BOTTOM_LEFT_TURN": "╭",
+        "ROUNDED_BOTTOM_RIGHT_TURN": "╮",
+        "ROUNDED_TOP_LEFT_TURN": "╰",
+        "ROUNDED_TOP_RIGHT_TURN": "╯",
+        "ROUNDED_T_UP": "┴",
+        "ROUNDED_T_DOWN": "┬",
+        "ROUNDED_T_LEFT": "┤",
+        "ROUNDED_T_RIGHT": "├",
+        "ROUNDED_CROSS": "┼",
+    },
+    "PIPE_BLOCKS": {
+        "FULL_BLOCK": "█",
+        "LOWER_HALF_BLOCK": "▄",
+        "UPPER_HALF_BLOCK": "▀",
+        "LEFT_HALF_BLOCK": "▌",
+        "RIGHT_HALF_BLOCK": "▐",
+        "LOWER_LEFT_QUARTER_BLOCK": "▖",
+        "LOWER_RIGHT_QUARTER_BLOCK": "▗",
+        "UPPER_LEFT_QUARTER_BLOCK": "▘",
+        "UPPER_RIGHT_QUARTER_BLOCK": "▝",
+        "LEFT_THREE_QUARTER_BLOCK": "▙",
+        "RIGHT_THREE_QUARTER_BLOCK": "▛",
+        "LOWER_THREE_QUARTER_BLOCK": "▟",
+        "UPPER_THREE_QUARTER_BLOCK": "▜",
+    },
+    "PIPE_EXTRAS": {
+        "X": "╳",
+        "HALF_LEFT_HORIZONTAL": "╴",
+        "HALF_TOP_VERTICAL": "╵",
+        "HALF_RIGHT_HORIZONTAL": "╶",
+        "HALF_BOTTOM_VERTICAL": "╷",
+        "END_LEFT": "╼",
+        "END_TOP": "╽",
+        "END_RIGHT": "╾",
+        "END_BOTTOM": "╿",
+    },
+    "DOTS": {
+        "ELLIPSE_MIDDLE": "⋯",
+        "ELLIPSE_VERTICAL": "⋮",
+        "ELLIPSE_DIAGONAL_RIGHT_TO_LEFT": "⋰",
+        "ELLIPSE_DIAGONAL_LEFT_TO_RIGHT": "⋱",
+        "MIDDOT": "·",
+        "BULLET": "•",
+    },
+    "ARROWS": {
+        "UP_ARROW": "↑",
+        "DOWN_ARROW": "↓",
+        "LEFT_ARROW": "←",
+        "RIGHT_ARROW": "→",
+        "UP_DOWN_ARROW": "↕",
+        "LEFT_RIGHT_ARROW": "↔",
+        "NORTH_WEST_ARROW": "↖",
+        "NORTH_EAST_ARROW": "↗",
+        "SOUTH_EAST_ARROW": "↘",
+        "SOUTH_WEST_ARROW": "↙",
+        "DOUBLE_UP_ARROW": "⇑",
+        "DOUBLE_DOWN_ARROW": "⇓",
+        "DOUBLE_LEFT_ARROW": "⇐",
+        "DOUBLE_RIGHT_ARROW": "⇒",
+        "DOUBLE_LEFT_RIGHT_ARROW": "⇔",
+        "DOUBLE_UP_DOWN_ARROW": "⇕",
+    },
+    "BRAILLE": {i: chr(0x2800 + i) for i in range(1, 256)},
+}
+
+if __name__ == "__main__":
+    for category, chars in CharLib.items():
+        print(f"Category: {category}")
+        for name, char in chars.items():
+            print(f"  {name}: {char}")
+        print()

libascii/color.py

@@ -0,0 +1,32 @@
+class Color:
+    def __init__(self, value: str | tuple[int, int, int]) -> None:
+        if isinstance(value, tuple):
+            if len(value) != 3 or not all(
+                isinstance(c, int) and 0 <= c <= 255 for c in value
+            ):
+                msg = "RGB tuple must contain 3 integers in range 0-255"
+                raise ValueError(msg)
+            r, g, b = value
+            self.value = f"#{r:02x}{g:02x}{b:02x}"
+        elif value == "":
+            self.value = None
+        else:
+            self.value = value
+
+    @classmethod
+    def from_hex(cls, hex_str: str) -> "Color":
+        if not isinstance(hex_str, str) or not hex_str.startswith("#"):
+            msg = "hex string must be in format #RRGGBB"
+            raise ValueError(msg)
+        if len(hex_str) != 7:
+            msg = "hex string must be in format #RRGGBB"
+            raise ValueError(msg)
+        try:
+            int(hex_str[1:], 16)
+        except ValueError:
+            msg = f"invalid hex string: {hex_str!r}"
+            raise ValueError(msg) from None
+        return cls(hex_str)
+
+    def __str__(self) -> str:
+        return self.value if self.value is not None else ""

libascii/game.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import tkinter as tk
+from collections.abc import Callable
+
+from .color import Color
+from .grid import Grid
+from .shapes.shape import Shape
+from ._utils.keymapping import keybinding_to_events
+
+
+class Game:
+    @staticmethod
+    def _prevent_selection(event: tk.Event[tk.Misc]) -> str:
+        return "break"
+
+    def __init__(
+        self,
+        width: int = 80,
+        height: int = 24,
+        title: str = "asciilib game",
+        fg: Color | None = None,
+        bg: Color | None = None,
+        filler: str = " ",
+        fps: int = 60,
+    ) -> None:
+        self.width = width
+        self.height = height
+
+        self.default_bg = bg if bg is not None else Color("black")
+        self.default_fg = fg if fg is not None else Color("white")
+
+        self.filler = filler
+        self.title = title
+
+        self.grid = Grid(width, height, filler)
+
+        self._key_down_bindings: list[tuple[str, Callable]] = []
+        self._key_up_bindings: list[tuple[str, Callable]] = []
+
+        self._mouse_down_bindings: list[Callable[[tuple[int, int]], None]] = []
+        self._mouse_up_bindings: list[Callable[[tuple[int, int]], None]] = []
+
+        self._frame_bindings: list[Callable[[], None]] = []
+        self._fps = fps
+
+        self._running = False
+        self.root: tk.Tk | None = None
+        self.area: tk.Text | None = None
+
+    def on_key_down(
+        self,
+        keybinding: str,
+        callback: Callable[[tk.Event[tk.Misc]], None],
+    ) -> None:
+        self._key_down_bindings.append((keybinding, callback))
+
+    def on_key_up(
+        self,
+        keybinding: str,
+        callback: Callable[[tk.Event[tk.Misc]], None],
+    ) -> None:
+        self._key_up_bindings.append((keybinding, callback))
+
+    def on_mouse_down(
+        self,
+        callback: Callable[[tuple[int, int]], None],
+    ) -> None:
+        self._mouse_down_bindings.append(callback)
+
+    def on_mouse_up(
+        self,
+        callback: Callable[[tuple[int, int]], None],
+    ) -> None:
+        self._mouse_up_bindings.append(callback)
+
+    def on_frame(self, callback: Callable[[], None]) -> None:
+        self._frame_bindings.append(callback)
+
+    def draw(self, shape: Shape) -> None:
+        shape.draw(self.grid)
+
+    def set(
+        self,
+        x: int,
+        y: int,
+        char: str = "",
+        color: Color | None = None,
+    ) -> None:
+        self.grid.set(x, y, char, color)
+
+    def get(self, x: int, y: int) -> tuple[str, Color | None]:
+        return self.grid.get(x, y)
+
+    def clear(self) -> None:
+        self.grid.clear()
+
+    def text(
+        self,
+        x: int,
+        y: int,
+        string: str,
+        color: Color | None = None,
+    ) -> None:
+        for offset, char in enumerate(string):
+            self.grid.set(x + offset, y, char, color)
+
+    def refresh(self) -> None:
+        self._render()
+
+    @property
+    def fps(self) -> int:
+        return self._fps
+
+    @fps.setter
+    def fps(self, value: int) -> None:
+        self._fps = value
+
+    def stop(self) -> None:
+        if not self._running:
+            return
+        self._running = False
+        if self.root is not None:
+            self.root.quit()
+
+    def start(self) -> None:
+        root = tk.Tk()
+        root.title(self.title)
+        root.protocol("WM_DELETE_WINDOW", self.stop)
+        self.root = root
+
+        self.area = tk.Text(
+            self.root,
+            width=self.width,
+            height=self.height,
+            font=("Courier", 10),
+            bg=str(self.default_bg),
+            fg=str(self.default_fg),
+            padx=0,
+            pady=0,
+            borderwidth=0,
+            highlightthickness=0,
+        )
+        self.area.pack()
+
+        self.area.bind("<Button-1>", self._prevent_selection)
+        self.area.bind("<B1-Motion>", self._prevent_selection)
+
+        for keybinding, callback in self._key_down_bindings:
+            for event in keybinding_to_events(keybinding, "KeyPress"):
+                self.area.bind(event, callback)
+
+        for keybinding, callback in self._key_up_bindings:
+            for event in keybinding_to_events(keybinding, "KeyRelease"):
+                self.area.bind(event, callback)
+
+        def _make_mouse_handler(
+            bindings: list[Callable[[tuple[int, int]], None]],
+        ) -> Callable[[tk.Event[tk.Misc]], None]:
+            def handler(event: tk.Event[tk.Misc]) -> None:
+                line, col = self.area.index(f"@{event.x},{event.y}").split(".")
+                coord = (int(col), int(line) - 1)
+                for binding in bindings:
+                    binding(coord)
+
+            return handler
+
+        down_handler = _make_mouse_handler(self._mouse_down_bindings)
+        up_handler = _make_mouse_handler(self._mouse_up_bindings)
+        self.area.bind("<Button-1>", down_handler)
+        self.area.bind("<ButtonRelease-1>", up_handler)
+
+        self._running = True
+        self._render()
+
+        def _tick() -> None:
+            if not self._running:
+                return
+            for callback in self._frame_bindings:
+                callback()
+            self.root.after(round(1000 / self._fps), _tick)
+
+        self.root.after(round(1000 / self._fps), _tick)
+        self.root.mainloop()
+
+    def _render(self) -> None:
+        self.area.delete("1.0", tk.END)
+
+        for y, row in enumerate(self.grid.content):
+            self.area.insert(f"{y + 1}.0", "".join(row) + "\n")
+        for y, row in enumerate(self.grid.colors):
+            for x, color in enumerate(row):
+                if color is not None:
+                    color_str = str(color)
+
+                    if color_str:
+                        self.area.tag_add(
+                            color_str, f"{y + 1}.{x}", f"{y + 1}.{x + 1}"
+                        )
+                        self.area.tag_config(color_str, foreground=color_str)
+
+
+if __name__ == "__main__":
+    Game().start()

libascii/grid.py

@@ -0,0 +1,45 @@
+from libascii.color import Color
+
+
+class Grid:
+    def __init__(self, width: int, height: int, filler: str = " ") -> None:
+        self.width = width
+        self.height = height
+        self.filler = filler
+        self.content: list[list[str]] = [
+            [filler for _ in range(width)] for _ in range(height)
+        ]
+        self.colors: list[list[Color | None]] = [
+            [None for _ in range(width)] for _ in range(height)
+        ]
+
+    def in_bounds(self, x: int, y: int) -> bool:
+        return 0 <= x < self.width and 0 <= y < self.height
+
+    def set(
+        self,
+        x: int,
+        y: int,
+        char: str = "",
+        color: Color | None = None,
+    ) -> None:
+        self.content[y][x] = char
+        self.colors[y][x] = color
+
+    def set_many(
+        self, cells: list[tuple[int, int, str, Color | None]]
+    ) -> None:
+        for x, y, char, color in cells:
+            self.set(x, y, char, color)
+
+    def get(self, x: int, y: int) -> tuple[str, Color | None]:
+        return self.content[y][x], self.colors[y][x]
+
+    def fill(self, char: str = "", color: Color | None = None) -> None:
+        for y in range(self.height):
+            for x in range(self.width):
+                self.content[y][x] = char
+                self.colors[y][x] = color
+
+    def clear(self) -> None:
+        self.fill(self.filler, None)

libascii/shapes/__init__.py

@@ -0,0 +1,5 @@
+from .shape import Shape
+from .rectangle import Rectangle
+from .ellipse import Ellipse
+from .triangle import Triangle
+from .line import Line

libascii/shapes/ellipse.py

@@ -0,0 +1,70 @@
+from ..color import Color
+from ..grid import Grid
+from .shape import Shape
+
+
+class Ellipse(Shape):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        fill: str = "",
+        border: str = "",
+        fill_color: Color = Color(""),
+        border_color: Color = Color(""),
+        border_top: str = "",
+        border_left: str = "",
+        border_right: str = "",
+        border_bottom: str = "",
+    ) -> None:
+        self.width = width
+        self.height = height
+        self.fill = fill
+        self.border = border
+        self.fill_color = fill_color
+        self.border_color = border_color
+        self.border_top = border_top
+        self.border_left = border_left
+        self.border_right = border_right
+        self.border_bottom = border_bottom
+
+    def draw(self, grid: Grid) -> None:
+        if self.width == 0 or self.height == 0:
+            return
+        cx = (self.width - 1) / 2
+        cy = (self.height - 1) / 2
+        rx = max((self.width - 1) / 2, 1e-9)
+        ry = max((self.height - 1) / 2, 1e-9)
+
+        def inside(x: int, y: int) -> bool:
+            if x < 0 or x >= self.width or y < 0 or y >= self.height:
+                return False
+            dx = (x - cx) / rx
+            dy = (y - cy) / ry
+            return dx * dx + dy * dy <= 1
+
+        for y in range(self.height):
+            for x in range(self.width):
+                if not inside(x, y):
+                    continue
+                on_border = not (
+                    inside(x - 1, y)
+                    and inside(x + 1, y)
+                    and inside(x, y - 1)
+                    and inside(x, y + 1)
+                )
+                if on_border:
+                    grid.set(x, y, self._border_char(x, y), self.border_color)
+                else:
+                    grid.set(x, y, self.fill, self.fill_color)
+
+    def _border_char(self, x: int, y: int) -> str:
+        if y == 0 and self.border_top:
+            return self.border_top
+        if y == self.height - 1 and self.border_bottom:
+            return self.border_bottom
+        if x == 0 and self.border_left:
+            return self.border_left
+        if x == self.width - 1 and self.border_right:
+            return self.border_right
+        return self.border

libascii/shapes/line.py

@@ -0,0 +1,42 @@
+from ..color import Color
+from ..grid import Grid
+from .shape import Shape
+
+
+class Line(Shape):
+    def __init__(
+        self,
+        x1: int,
+        y1: int,
+        x2: int,
+        y2: int,
+        char: str = "#",
+        color: Color = Color(""),
+    ) -> None:
+        self.x1 = x1
+        self.y1 = y1
+        self.x2 = x2
+        self.y2 = y2
+        self.char = char
+        self.color = color
+
+    def draw(self, grid: Grid) -> None:
+        x0, y0 = self.x1, self.y1
+        x1, y1 = self.x2, self.y2
+        dx = abs(x1 - x0)
+        dy = abs(y1 - y0)
+        sx = 1 if x0 < x1 else -1
+        sy = 1 if y0 < y1 else -1
+        err = dx - dy
+
+        while True:
+            grid.set(x0, y0, self.char, self.color)
+            if x0 == x1 and y0 == y1:
+                break
+            e2 = 2 * err
+            if e2 > -dy:
+                err -= dy
+                x0 += sx
+            if e2 < dx:
+                err += dx
+                y0 += sy

libascii/shapes/rectangle.py

@@ -0,0 +1,54 @@
+from ..color import Color
+from ..grid import Grid
+from .shape import Shape
+
+
+class Rectangle(Shape):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        fill: str = "",
+        border: str = "",
+        fill_color: Color = Color(""),
+        border_color: Color = Color(""),
+        border_top: str = "",
+        border_left: str = "",
+        border_right: str = "",
+        border_bottom: str = "",
+    ) -> None:
+        self.width = width
+        self.height = height
+        self.fill = fill
+        self.border = border
+        self.fill_color = fill_color
+        self.border_color = border_color
+        self.border_top = border_top
+        self.border_left = border_left
+        self.border_right = border_right
+        self.border_bottom = border_bottom
+
+    def draw(self, grid: Grid) -> None:
+        for y in range(self.height):
+            for x in range(self.width):
+                on_border = (
+                    x == 0
+                    or x == self.width - 1
+                    or y == 0
+                    or y == self.height - 1
+                )
+                if on_border:
+                    grid.set(x, y, self._border_char(x, y), self.border_color)
+                else:
+                    grid.set(x, y, self.fill, self.fill_color)
+
+    def _border_char(self, x: int, y: int) -> str:
+        if y == 0 and self.border_top:
+            return self.border_top
+        if y == self.height - 1 and self.border_bottom:
+            return self.border_bottom
+        if x == 0 and self.border_left:
+            return self.border_left
+        if x == self.width - 1 and self.border_right:
+            return self.border_right
+        return self.border

libascii/shapes/shape.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from libascii.grid import Grid
+
+
+class Shape(ABC):
+    @abstractmethod
+    def draw(self, grid: Grid) -> None:
+        pass

libascii/shapes/triangle.py

@@ -0,0 +1,84 @@
+from ..color import Color
+from ..grid import Grid
+from .shape import Shape
+
+
+class Triangle(Shape):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        fill: str = "",
+        border: str = "",
+        fill_color: Color = Color(""),
+        border_color: Color = Color(""),
+        border_left: str = "",
+        border_right: str = "",
+        border_bottom: str = "",
+    ) -> None:
+        self.width = width
+        self.height = height
+        self.fill = fill
+        self.border = border
+        self.fill_color = fill_color
+        self.border_color = border_color
+        self.border_left = border_left
+        self.border_right = border_right
+        self.border_bottom = border_bottom
+
+    def draw(self, grid: Grid) -> None:
+        if self.height == 0 or self.width == 0:
+            return
+
+        top = (self.width // 2, 0)
+        bottom_left = (0, self.height - 1)
+        bottom_right = (self.width - 1, self.height - 1)
+
+        def edge_x(
+            a: tuple[int, int],
+            b: tuple[int, int],
+            y: int,
+        ) -> float | None:
+            (x0, y0), (x1, y1) = a, b
+            if y0 == y1 or y < min(y0, y1) or y > max(y0, y1):
+                return None
+            return x0 + (x1 - x0) * (y - y0) / (y1 - y0)
+
+        edges = (
+            (top, bottom_left),
+            (top, bottom_right),
+            (bottom_left, bottom_right),
+        )
+
+        for y in range(self.height):
+            xs = []
+            for a, b in edges:
+                x = edge_x(a, b, y)
+                if x is not None:
+                    xs.append(x)
+            if len(xs) < 2:
+                continue
+            left = int(round(min(xs)))
+            right = int(round(max(xs)))
+            for x in range(left, right + 1):
+                if x < 0 or x >= self.width:
+                    continue
+                on_border = x == left or x == right or y == self.height - 1
+                if on_border:
+                    grid.set(
+                        x,
+                        y,
+                        self._border_char(x, y, left, right),
+                        self.border_color,
+                    )
+                else:
+                    grid.set(x, y, self.fill, self.fill_color)
+
+    def _border_char(self, x: int, y: int, left: int, right: int) -> str:
+        if y == self.height - 1 and self.border_bottom:
+            return self.border_bottom
+        if x == left and self.border_left:
+            return self.border_left
+        if x == right and self.border_right:
+            return self.border_right
+        return self.border

libascii/sound.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+import simpleaudio as sa
+
+
+class Sound:
+    def __init__(self, path: str | Path) -> None:
+        self.wave_object = sa.WaveObject.from_wave_file(str(path))
+
+    @classmethod
+    def from_wav(cls, path: str | Path) -> "Sound":
+        return cls(path)
+
+    def play(self) -> sa.PlayObject:
+        return self.wave_object.play()
+
+    def stop(self, play_object: sa.PlayObject) -> None:
+        play_object.stop()
+
+    def is_playing(self, play_object: sa.PlayObject) -> bool:
+        return play_object.is_playing()
+
+    def wait_done(self, play_object: sa.PlayObject) -> None:
+        play_object.wait_done()

libascii-0.1.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: libascii
+Version: 0.1.0
+Summary: 
+Author: NNlk05
+License-Expression: MIT OR Zlib
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: 3.16
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Games/Entertainment :: Arcade
+Classifier: Topic :: Games/Entertainment :: Board Games
+Classifier: Topic :: Games/Entertainment :: Multi-User Dungeons (MUD)
+Classifier: Topic :: Games/Entertainment :: Puzzle Games
+Classifier: Typing :: Typed
+Requires-Dist: simpleaudio>=1.0.4
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+

libascii-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+libascii/__init__.py,sha256=MTormQASUYaytNh8YXveW0lGwc4rg3-cyMNKbvYACA8,2276
+libascii/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libascii/_utils/keymapping.py,sha256=HtUOTtiEIsqA5X-Tn2jKFFALEeYt3ls8oCcheNSo4-U,2196
+libascii/chars.py,sha256=vWS0higBty76cFiqPJjVw7mrJX_2ONiEKz6jL7QiLDY,4225
+libascii/color.py,sha256=Q0vFwz5xCFbJ4dv4758Qprppir1mCLIcOP-J4Gujnfk,1173
+libascii/game.py,sha256=EKIbBsccpELysKe7IukxMmoW3oam42i4M9VCv9x6nTk,5917
+libascii/grid.py,sha256=G6-RyGUNm4AYpG118BncwMsbiQeTzaT-mGmOJgyXqEg,1357
+libascii/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libascii/shapes/__init__.py,sha256=Q0F6Zv28ECoStbxqqTo_WsxX19q-v1yAiXAN5h-p7A8,141
+libascii/shapes/ellipse.py,sha256=EDozWxDcbutxsZhNc9tmeC15We__JU4oECEsxWWhYGM,2271
+libascii/shapes/line.py,sha256=Ch5oQVlTB02PwefWovoDLaJwkBCIisO3hZFRyDr-K4k,966
+libascii/shapes/rectangle.py,sha256=n_Tia3WYw--qvH4Kix9r-LbZHeC-Rj9lvVpWF327iZg,1711
+libascii/shapes/shape.py,sha256=5gjRUWYCChIc6c6oXdIRnPWp90O6WiigacfMWtr3BOg,160
+libascii/shapes/triangle.py,sha256=1bMBLZmCMwDjFCIAJxyreJTZ64arF2SnUdtesDGbC7I,2624
+libascii/sound.py,sha256=AEGKNLgTt8pHR2c-Ea-HgiB70RqV8kOfPlCqqHL7wYY,636
+libascii-0.1.0.dist-info/licenses/LICENSE,sha256=gvoF8ebg3xSObRCtcOGNXBpA91LQ-gysMpCisjyGlNs,1960
+libascii-0.1.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+libascii-0.1.0.dist-info/METADATA,sha256=ia1CfLFd6FO8sWUON4_AgFvupAWChGU3ri6lxFAD8X4,1039
+libascii-0.1.0.dist-info/RECORD,,

libascii-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.7
+Root-Is-Purelib: true
+Tag: py3-none-any

libascii-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+This project is dual-licensed under MIT or zlib.
+
+zlib license:
+Copyright (c) 2026 NNlk05
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+MIT license:
+Copyright (c) 2026 NNlk05
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.