funcade 0.1.0__tar.gz

funcade-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dursun
+
+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.

funcade-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: funcade
+Version: 0.1.0
+Summary: Functional console game engine
+Author-email: Dursun <dursunhasanov06@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# funcade 🎮
+
+A lightweight, functional console game engine for Python. Build retro 2D grid-based terminal games with ease!
+
+`funcade` takes care of console rendering, keyboard input handling, ANSI colors, and game loop stabilization, leaving you to focus purely on your game logic. It also features a built-in project generator called **Golem**.
+
+---
+
+## 🚀 Key Features
+
+*   **Pure Functional Approach**: Separate your game into `state` (data), `update` (pure logic), and `render` (visuals).
+*   **Zero Dependencies**: Uses standard Python libraries and terminal ANSI escape sequences.
+*   **Window Management**: Automatically runs games in a dedicated, perfectly sized Windows console window.
+*   **Built-in Time Machine**: Built-in state history features (`undo_state`) to easily implement "rewind time" mechanics.
+*   **Golem CLI**: Jumpstart new game projects in seconds.
+
+---
+
+## 🛠 Installation
+
+You can install `funcade` directly from PyPI:
+
+```bash
+pip install funcade

funcade-0.1.0/README.md

@@ -0,0 +1,24 @@
+# funcade 🎮
+
+A lightweight, functional console game engine for Python. Build retro 2D grid-based terminal games with ease!
+
+`funcade` takes care of console rendering, keyboard input handling, ANSI colors, and game loop stabilization, leaving you to focus purely on your game logic. It also features a built-in project generator called **Golem**.
+
+---
+
+## 🚀 Key Features
+
+*   **Pure Functional Approach**: Separate your game into `state` (data), `update` (pure logic), and `render` (visuals).
+*   **Zero Dependencies**: Uses standard Python libraries and terminal ANSI escape sequences.
+*   **Window Management**: Automatically runs games in a dedicated, perfectly sized Windows console window.
+*   **Built-in Time Machine**: Built-in state history features (`undo_state`) to easily implement "rewind time" mechanics.
+*   **Golem CLI**: Jumpstart new game projects in seconds.
+
+---
+
+## 🛠 Installation
+
+You can install `funcade` directly from PyPI:
+
+```bash
+pip install funcade

funcade-0.1.0/funcade/__init__.py

@@ -0,0 +1,4 @@
+from .core import create_engine
+from .screen import create_buffer, draw_char, draw_string, clear_buffer, render_buffer
+from .storage import create_history, record_state, undo_state
+from . import colors

funcade-0.1.0/funcade/__main__.py

@@ -0,0 +1,85 @@
+import sys
+import os
+
+TEMPLATE_STATE = """def init_game():
+    return {
+        "score": 0,
+        "game_over": False
+    }
+"""
+
+TEMPLATE_UPDATE = """def update_game(state, action, dt):
+    if action == 'ESCAPE':
+        state["game_over"] = True
+    return state
+"""
+
+TEMPLATE_RENDER = """from funcade.screen import draw_string
+from funcade import colors
+
+def render_game(state, buffer):
+    draw_string(buffer, 15, 7, "CONSTRUCTOR IS READY!", colors.GREEN + colors.BOLD)
+    draw_string(buffer, 13, 9, "Write your game here...", colors.WHITE)
+"""
+
+TEMPLATE_MAIN = """import sys
+import os
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from funcade import create_engine
+from state import init_game
+from update import update_game
+from render import render_game
+
+def main():
+    run_game = create_engine(
+        init_fn=init_game,
+        update_fn=update_game,
+        render_fn=render_game,
+        width=50,
+        height=15,
+        fps=20
+    )
+    
+    run_game()
+
+if __name__ == "__main__":
+    main()
+"""
+
+def create_project(project_name):
+    if os.path.exists(project_name):
+        print(f"Error: Path '{project_name}' already exists!")
+        sys.exit(1)
+        
+    print(f"Building Golem to activate '{project_name}'...")
+    os.makedirs(project_name, exist_ok=True)
+    
+    files = {
+        "state.py": TEMPLATE_STATE,
+        "update.py": TEMPLATE_UPDATE,
+        "render.py": TEMPLATE_RENDER,
+        "main.py": TEMPLATE_MAIN
+    }
+    
+    for filename, content in files.items():
+        filepath = os.path.join(project_name, filename)
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(content)
+        print(f"  [+] Created {filepath}")
+        
+    print(f"\\nGolem successfully awoken! Play your new game by running:")
+    print(f"  cd {project_name}")
+    print(f"  python main.py")
+
+def main():
+    if len(sys.argv) < 3 or sys.argv[1] != 'golem':
+        print("Usage: python -m funcade golem <project_name>")
+        sys.exit(1)
+        
+    project_name = sys.argv[2]
+    create_project(project_name)
+
+if __name__ == "__main__":
+    main()

funcade-0.1.0/funcade/colors.py

@@ -0,0 +1,23 @@
+# ANSI escape sequences for coloring console output
+RESET = "\033[0m"
+BOLD = "\033[1m"
+
+# Foregrounds
+BLACK = "\033[30m"
+RED = "\033[31m"
+GREEN = "\033[32m"
+YELLOW = "\033[33m"
+BLUE = "\033[34m"
+MAGENTA = "\033[35m"
+CYAN = "\033[36m"
+WHITE = "\033[37m"
+
+# Backgrounds
+BG_BLACK = "\033[40m"
+BG_RED = "\033[41m"
+BG_GREEN = "\033[42m"
+BG_YELLOW = "\033[43m"
+BG_BLUE = "\033[44m"
+BG_MAGENTA = "\033[45m"
+BG_CYAN = "\033[46m"
+BG_WHITE = "\033[47m"

funcade-0.1.0/funcade/core.py

@@ -0,0 +1,41 @@
+import sys
+import time
+from .input import get_key
+from .screen import create_buffer, clear_buffer, render_buffer
+
+def create_engine(init_fn, update_fn, render_fn, width=50, height=15, fps=20):
+    def start():
+        sys.stdout.write("\033[2J\033[H\033[?25l")
+        sys.stdout.flush()
+        
+        state = init_fn()
+        buffer = create_buffer(width, height)
+        dt = 1 / fps
+        
+        try:
+            while True:
+                start_time = time.time()
+                
+                key = get_key()
+                if key == 'ESCAPE':
+                    break
+                
+                next_state = update_fn(state, key, dt)
+                if next_state is None:
+                    break
+                state = next_state
+                
+                clear_buffer(buffer)
+                render_fn(state, buffer)
+                
+                render_buffer(buffer)
+                
+                elapsed = time.time() - start_time
+                sleep_time = dt - elapsed
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+        finally:
+            sys.stdout.write("\033[2J\033[H\033[?25h")
+            sys.stdout.flush()
+            
+    return start

funcade-0.1.0/funcade/input.py

@@ -0,0 +1,49 @@
+import sys
+import os
+
+if os.name == 'nt':
+    import msvcrt
+    def get_key():
+        if msvcrt.kbhit():
+            ch = msvcrt.getch()
+            if ch in (b'\x00', b'\xe0'):
+                if msvcrt.kbhit():
+                    ch2 = msvcrt.getch()
+                    mapping = {b'H': 'UP', b'P': 'DOWN', b'K': 'LEFT', b'M': 'RIGHT'}
+                    return mapping.get(ch2, None)
+            try:
+                key = ch.decode('utf-8').upper()
+                if key == '\r': return 'ENTER'
+                if key == '\x1b': return 'ESCAPE'
+                if key == ' ': return 'SPACE'
+                return key
+            except:
+                return None
+        return None
+else:
+    import termios
+    import tty
+    import select
+    def get_key():
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(sys.stdin.fileno())
+            rlist, _, _ = select.select([sys.stdin], [], [], 0.0)
+            if rlist:
+                ch = sys.stdin.read(1)
+                if ch == '\x1b':
+                    rlist2, _, _ = select.select([sys.stdin], [], [], 0.05)
+                    if rlist2:
+                        ch2 = sys.stdin.read(2)
+                        if ch2 == '[A': return 'UP'
+                        if ch2 == '[B': return 'DOWN'
+                        if ch2 == '[C': return 'RIGHT'
+                        if ch2 == '[D': return 'LEFT'
+                    return 'ESCAPE'
+                if ch in ('\n', '\r'): return 'ENTER'
+                if ch == ' ': return 'SPACE'
+                return ch.upper()
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        return None

funcade-0.1.0/funcade/screen.py

@@ -0,0 +1,45 @@
+import sys
+from .colors import RESET
+
+def create_buffer(width, height, default_char=' ', default_color=RESET):
+    return {
+        'width': width,
+        'height': height,
+        'grid': [[(default_char, default_color) for _ in range(width)] for _ in range(height)]
+    }
+
+def draw_char(buffer, x, y, char, color=RESET):
+    if 0 <= x < buffer['width'] and 0 <= y < buffer['height']:
+        buffer['grid'][y][x] = (char, color)
+    return buffer
+
+def draw_string(buffer, x, y, text, color=RESET):
+    for i, char in enumerate(text):
+        draw_char(buffer, x + i, y, char, color)
+    return buffer
+
+def clear_buffer(buffer, default_char=' ', default_color=RESET):
+    w, h = buffer['width'], buffer['height']
+    for y in range(h):
+        for x in range(w):
+            buffer['grid'][y][x] = (default_char, default_color)
+    return buffer
+
+def render_buffer(buffer):
+    sys.stdout.write('\033[H')
+    
+    lines = []
+    for y in range(buffer['height']):
+        row_str = []
+        last_color = None
+        for x in range(buffer['width']):
+            char, color = buffer['grid'][y][x]
+            if color != last_color:
+                row_str.append(color)
+                last_color = color
+            row_str.append(char)
+        row_str.append(RESET)
+        lines.append("".join(row_str))
+    
+    sys.stdout.write("\n".join(lines) + "\n")
+    sys.stdout.flush()

funcade-0.1.0/funcade/storage.py

@@ -0,0 +1,28 @@
+import copy
+
+def create_history(max_depth=50):
+    return {
+        'history': [],
+        'max_depth': max_depth
+    }
+
+def record_state(history_obj, state):
+    state_copy = copy.deepcopy(state)
+    new_history = list(history_obj['history'])
+    new_history.append(state_copy)
+    if len(new_history) > history_obj['max_depth']:
+        new_history.pop(0)
+    return {
+        **history_obj,
+        'history': new_history
+    }
+
+def undo_state(history_obj):
+    if len(history_obj['history']) > 1:
+        new_history = list(history_obj['history'])
+        new_history.pop()  
+        previous_state = new_history[-1]
+        return previous_state, {**history_obj, 'history': new_history}
+    elif len(history_obj['history']) == 1:
+        return history_obj['history'][0], history_obj
+    return None, history_obj

funcade-0.1.0/main.py

@@ -0,0 +1,31 @@
+import sys
+import os
+import subprocess
+
+if os.name == 'nt' and '--external' not in sys.argv:
+    cmd = 'start "Game Constructor" cmd /c "mode con: cols=54 lines=18 && python main.py --external"'
+    subprocess.Popen(cmd, shell=True, close_fds=True)
+    sys.exit()
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".")))
+
+from funcade import create_engine
+
+from state import init_game
+from update import update_game
+from render import render_game
+
+def main():
+    run_game = create_engine(
+        init_fn=init_game,      
+        update_fn=update_game,  
+        render_fn=render_game,  
+        width=50,              
+        height=15,              
+        fps=20                  
+    )
+    
+    run_game()
+
+if __name__ == "__main__":
+    main()

funcade-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "funcade"  
+version = "0.1.0" 
+authors = [
+    { name = "Dursun", email = "dursunhasanov06@gmail.com" }
+]
+description = "Functional console game engine"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+funcade = "funcade.__main__:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["funcade"]

funcade-0.1.0/render.py

@@ -0,0 +1,6 @@
+from funcade.screen import draw_string
+from funcade import colors
+
+def render_game(state, buffer):
+    draw_string(buffer, 15, 7, "CONSTRUCTOR IS READY!", colors.GREEN + colors.BOLD)
+    draw_string(buffer, 13, 9, "Write your game here...", colors.WHITE)

funcade-0.1.0/state.py

@@ -0,0 +1,5 @@
+def init_game():
+    return {
+        "score": 0,
+        "game_over": False
+    }

funcade-0.1.0/update.py

@@ -0,0 +1,6 @@
+def update_game(state, key, dt):
+    
+    if key == 'ESCAPE':
+        state["game_over"] = True
+        
+    return state