Pillars

Part one: what is Pillars

PILLARS

A Tabletop RPG for Players Who Want More

---

I've been playing D&D since 1977. Over the years, I've watched the hobby grow and change—sometimes in directions I love, sometimes not. Pillars is my answer to what I wish fantasy RPGs still were: a game where choices matter, characters grow through play, and the world feels real enough to get lost in.

The System: Simple mechanics that get out of your way when they should and tighten around decisions that count. (Mechanics based on The Fantasy Trip—Steve Jackson's elegant 1977 system that predates GURPS—with decades of house rules baked in including an extensive magic and skills systems.)

The World: A God King Emperor rules from a tower at the center of the greatest city ever built. Dragons remember things that never happened to them. A mysterious guild controls ancient stone pillars that transport you across continents—for a price no one fully understands. Ruins older than elven memory dot the landscape, and no one knows who built them. There are answers to the mysteries, if you dig deep enough. But digging has costs.

The Game: No predetermined plots—the world exists, and what you do in it is up to you. No character builds—your character becomes who they become through play. Magic with real consequences—push too hard, and something pushes back.

What I'm Looking For: Mature players comfortable with serious themes. People who enjoy roleplay and problem-solving as much as combat. Collaborative storytellers who can improvise. Anyone interested in helping playtest and refine the system—your feedback shapes the game.

To learn more checkout https://pillars.duckdns.org or just drop me a email: pillars@origamisoftware.com

---

Format: [In-person / Online / Hybrid] Schedule: TBD but sometime over the weekend either afternoons or afternoon/evenings Location: TBD Contact: pillars@origamisoftware.com Discord: https://discord.gg/CRBpuwQNSd

---

The world has secrets. Come find them.

Part two Technical

Quick Start

Using the helper scripts (recommended)

# First time setup
./setup.sh

# Run the development server
./run.sh

Open http://127.0.0.1:8000 in your browser.

Manual setup

cd webapp
source ../.venv/bin/activate
python manage.py runserver

Setup From Scratch

Using uv (recommended)

1. Install uv (if not already installed):

   curl -LsSf https://astral.sh/uv/install.sh | sh

2. Create virtual environment and install dependencies:

   uv venv
   uv pip install -r requirements.txt

3. Configure environment:

   cp .env.example .env
   # Edit .env with your settings (or use defaults for local dev)

4. Initialize database and run:

   cd webapp
   source ../.venv/bin/activate
   python manage.py migrate
   python manage.py create_default_users  # creates admin/dm users from .env
   python manage.py runserver

Using traditional Python venv

1. Create virtual environment and install dependencies:

   python -m venv .venv
   source .venv/bin/activate
   pip install -r requirements.txt

2. Configure environment:

   cp .env.example .env
   # Edit .env with your settings (or use defaults for local dev)

3. Initialize database and run:

   cd webapp
   python manage.py migrate
   python manage.py create_default_users  # creates admin/dm users from .env
   python manage.py runserver

Helper Scripts

• setup.sh - Complete setup: creates venv, installs dependencies, runs migrations, creates default users
• run.sh - Runs the development server (loads .env automatically, falls back to SQLite if PostgreSQL unavailable)
• dev.sh - Development workflow hub (run, test, lint, migrate, etc.)
• test.sh - Test runner for core library and Django tests
• e2e.sh - End-to-end (Selenium) browser tests
• lint.sh - Code quality checks and formatting
• db.sh - Database management (migrations, reset, etc.)
• act.sh - Run GitHub Actions workflows locally (requires Docker)

All scripts automatically handle environment variables and database selection.

Running Tests

Quick Test Commands

# Run all tests (core + webapp)
./test.sh all

# Run only core library tests
./test.sh core

# Run only Django webapp tests
./test.sh webapp

# Run with coverage
./test.sh all true

# Run E2E (browser) tests
./e2e.sh

# Or use the dev workflow
./dev.sh test
./dev.sh e2e

Test Coverage

# Generate coverage report for core library
./test.sh core true

# Generate coverage report for all tests
./test.sh all true

# View coverage report
open htmlcov/index.html  # macOS
# or
xdg-open htmlcov/index.html  # Linux

E2E Testing

E2E tests use Selenium to test the web UI in a real browser:

# Run all E2E tests (headless)
./e2e.sh

# Run specific test suite
./e2e.sh generator    # Generator UI tests
./e2e.sh role         # Role-based access tests
./e2e.sh session      # Session persistence tests
./e2e.sh login        # Login flow tests

# Run in visible browser (for debugging)
./e2e.sh all false

# Verbose output
./e2e.sh all true 2

Note: E2E tests require Chrome/Chromium to be installed.

Configuration

The app uses SQLite by default. See .env.example for all configuration options including:

• PostgreSQL database setup
• Production deployment settings (gunicorn, HTTPS)
• Default user credentials

CI/CD

The project includes GitHub Actions workflows that:

• Run tests on Python 3.11 and 3.12 (.github/workflows/ci.yml)
• Run core library tests, Django tests, and E2E tests
• Check code formatting and linting
• Generate coverage reports
• Test against PostgreSQL database

Tests run automatically on push and pull requests.

Running CI Locally

You can test the CI workflow locally using act:

# List available workflows
./act.sh list

# Run test job
./act.sh test

# Run lint job
./act.sh lint

# Simulate a push event (runs all jobs)
./act.sh push

# Run with verbose output
./act.sh push -v

See docs/GITHUB_ACTIONS_LOCAL.md for detailed instructions.

Project Structure

character_gen/
├── webapp/           # Django project
│   ├── webapp/       # Main app (settings, urls)
│   │   └── generator/  # Character generator app
│   └── manage.py
├── pillars/          # Core library
├── docs/             # Documentation
├── references/       # Reference materials
├── .github/          # GitHub configuration
│   ├── workflows/
│   │   ├── ci.yml       # CI/CD pipeline
│   │   └── codeql.yml   # CodeQL code scanning
│   └── dependabot.yml   # Dependabot configuration
├── .coveragerc       # Coverage configuration
└── requirements.txt