Add terminal Game of Life with classic patterns (glider, pulsar, gosper gun)

new file mode 100644

Binary files /dev/null and b/__pycache__/life.cpython-314.pyc differ

new file mode 100644

@@ -0,0 +1,156 @@

#!/usr/bin/env python3

"""

Conway's Game of Life - Terminal Implementation

Run cellular automata with classic or custom rules.

Usage: python life.py [pattern] [generations] [delay_ms]

Patterns: random, glider, blinker, beacon, pulsar, gosper

"""

import os

import sys

import time

import random

# Classic patterns

PATTERNS = {

    'glider': [(0, 1), (1, 2), (2, 0), (2, 1), (2, 2)],

    'blinker': [(1, 0), (1, 1), (1, 2)],

    'beacon': [(0, 0), (0, 1), (1, 0), (2, 3), (3, 2), (3, 3)],

    'toad': [(1, 0), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3)],

    'block': [(0, 0), (0, 1), (1, 0), (1, 1)],

    'pulsar': [

        (0, 2), (0, 3), (0, 4), (0, 8), (0, 9), (0, 10),

        (2, 0), (3, 0), (4, 0), (2, 5), (3, 5), (4, 5),

        (2, 7), (3, 7), (4, 7), (2, 12), (3, 12), (4, 12),

        (5, 2), (5, 3), (5, 4), (5, 8), (5, 9), (5, 10),

        (7, 2), (7, 3), (7, 4), (7, 8), (7, 9), (7, 10),

        (8, 0), (9, 0), (10, 0), (8, 5), (9, 5), (10, 5),

        (8, 7), (9, 7), (10, 7), (8, 12), (9, 12), (10, 12),

        (12, 2), (12, 3), (12, 4), (12, 8), (12, 9), (12, 10),

    ],

    'gosper': [  # Gosper Glider Gun

        (0, 24), (1, 22), (1, 24), (2, 12), (2, 13), (2, 20), (2, 21), (2, 34), (2, 35),

        (3, 11), (3, 15), (3, 20), (3, 21), (3, 34), (3, 35), (4, 0), (4, 1), (4, 10),

        (4, 16), (4, 20), (4, 21), (5, 0), (5, 1), (5, 10), (5, 14), (5, 16), (5, 17),

        (5, 22), (5, 24), (6, 10), (6, 16), (6, 24), (7, 11), (7, 15), (8, 12), (8, 13),

    ],

}

class GameOfLife:

    """Conway's Game of Life simulation."""

    def __init__(self, width: int = 40, height: int = 20):

        self.width = width

        self.height = height

        self.cells: set[tuple[int, int]] = set()

    def set_pattern(self, pattern: str, offset_y: int = 5, offset_x: int = 5) -> None:

        """Load a named pattern or random cells."""

        self.cells.clear()

        if pattern == 'random':

            for y in range(self.height):

                for x in range(self.width):

                    if random.random() < 0.3:

                        self.cells.add((y, x))

        elif pattern in PATTERNS:

            for y, x in PATTERNS[pattern]:

                self.cells.add((y + offset_y, x + offset_x))

        else:

            print(f"Unknown pattern: {pattern}")

            print(f"Available: {', '.join(PATTERNS.keys())}, random")

            sys.exit(1)

    def count_neighbors(self, y: int, x: int) -> int:

        """Count live neighbors for a cell."""

        count = 0

        for dy in [-1, 0, 1]:

            for dx in [-1, 0, 1]:

                if dy == 0 and dx == 0:

                    continue

                ny, nx = y + dy, x + dx

                if (ny, nx) in self.cells:

                    count += 1

        return count

    def step(self) -> None:

        """Advance one generation."""

        new_cells: set[tuple[int, int]] = set()

        # Check all cells and their neighbors

        candidates: set[tuple[int, int]] = set()

        for y, x in self.cells:

            for dy in [-1, 0, 1]:

                for dx in [-1, 0, 1]:

                    candidates.add((y + dy, x + dx))

        for y, x in candidates:

            neighbors = self.count_neighbors(y, x)

            if (y, x) in self.cells:

                # Survive with 2-3 neighbors

                if neighbors in (2, 3):

                    new_cells.add((y, x))

            else:

                # Birth with exactly 3 neighbors

                if neighbors == 3:

                    new_cells.add((y, x))

        self.cells = new_cells

    def render(self) -> str:

        """Render current state as ASCII."""

        lines = []

        border = '+' + '-' * self.width + '+'

        lines.append(border)

        for y in range(self.height):

            row = '|'

            for x in range(self.width):

                row += '█' if (y, x) in self.cells else ' '

            row += '|'

            lines.append(row)

        lines.append(border)

        return '\n'.join(lines)

    def run(self, generations: int = 100, delay_ms: int = 100) -> None:

        """Run simulation with terminal animation."""

        for gen in range(generations):

            # Clear screen and move cursor to top

            print('\033[H\033[J', end='')

            print(f"Generation {gen + 1}/{generations} | Cells: {len(self.cells)}")

            print(self.render())

            if len(self.cells) == 0:

                print("All cells died. Simulation ended.")

                break

            time.sleep(delay_ms / 1000)

            self.step()

def main():

    pattern = sys.argv[1] if len(sys.argv) > 1 else 'glider'

    generations = int(sys.argv[2]) if len(sys.argv) > 2 else 50

    delay_ms = int(sys.argv[3]) if len(sys.argv) > 3 else 150

    # Adjust size for larger patterns

    width, height = 40, 20

    if pattern == 'gosper':

        width, height = 50, 25

    elif pattern == 'pulsar':

        width, height = 30, 20

    game = GameOfLife(width, height)

    game.set_pattern(pattern)

    print(f"Starting Conway's Game of Life")

    print(f"Pattern: {pattern} | Generations: {generations} | Delay: {delay_ms}ms")

    time.sleep(1)

    game.run(generations, delay_ms)

    print("\nSimulation complete. Press Ctrl+C to exit.")

if __name__ == '__main__':

    main()