CursedTomorrow README

The project's README from github.com/AhmadHassan-BTed/CursedTomorrow. As one markdown file: README.md.

Cursed Tomorrow

A platforming descent into the atmospheric unknown.

CI License: MIT Version C++ Raylib

Cursed Tomorrow is not just a game; it is a manifestation of tension and the human struggle against an encroaching, atmospheric darkness. Designed and engineered by Ahmad Hassan (B-Ted), this project serves as a technical showcase of modular C++ game design and atmospheric storytelling through interaction.

Overview • Showcase • Architecture • Systems • Resources • Development

Overview

The core of Cursed Tomorrow lies in its simplicity and the weight of its atmosphere. Every movement, jump, and collision is tuned to resonate with the player's experience of navigating a world that feels both fragile and hostile.

Core Pillars

Visual Showcase

The World of Tomorrow Main Menu The gateway into the descent.


Gameplay Level Selection
Gameplay Level Select
Navigating the void. Choosing the path.
Atmosphere Death
Warning You Died
Signs of what's to come. The inevitable end.

Architecture Documentation

The project architecture prioritizes decoupling and clear ownership. It is built to scale from a simple prototype to a complex production-grade game.

High-Level System Flow

graph TD
    subgraph "Engine Loop"
        Main[main.cpp] --> |Initialize| Game[Core::Game]
        Game --> |Frame Start| Input[HandleInput]
        Input --> |Update| Logic[UpdateLevelLogic]
        Logic --> |Physics| Phys[Entities::Character]
        Phys --> |Render| Draw[Draw]
        Draw --> |Frame End| Game
    end

    subgraph "Asset Management"
        Game -.-> |Request| RM[ResourceManager]
        RM --> |Cache/Load| Disk[(Disk Assets)]
    end

Module Relationship

The interaction between modules is strictly managed through the CursedTomorrow namespace.

Module Responsibility Internal Coupling
Core Window lifecycle, state machine, and main loop orchestration. High (Orchestrator)
Entities Individual game actors, physics, and local state. Low (Independent)
Resources Centralized asset caching and memory safety. Zero (Utility)
Config Global constants and engine parameters. Static Only

Internal Systems

Request & Data Flow

The data flow follows a strict unidirectional pattern during the update phase to ensure deterministic behavior.

sequenceDiagram
    participant P as Player
    participant G as Game
    participant C as Character
    participant RM as ResourceManager

    G->>G: HandleInput()
    G->>C: Update()
    C->>C: Move() & Jump()
    C->>C: ApplyGravity()
    G->>G: UpdateLevelLogic()
    G->>C: Draw()
    C->>RM: LoadTextureResource()
    RM-->>C: Texture Data
    C->>G: Render Complete

Repository Structure

.
├── .github/              # CI/CD Workflows & Templates
├── assets/               # Game Resources (Audio, Textures)
│   ├── audio/            # Atmospheric soundscapes
│   └── mainScreen/       # Visual interface components
├── docs/                 # Detailed Technical Documentation
├── include/              # Header Files
│   └── CursedTomorrow/   # Project Namespace
│       ├── Core/         # Engine & State Logic
│       └── Entities/     # Actor definitions
├── src/                  # Implementation Files
├── scripts/              # Automation and build helpers
└── CMakeLists.txt        # Build System Configuration

Development Workflow

The development process is designed to be contributor-friendly while maintaining high engineering standards.

1. Environment Setup

Ensure a C++17 compiler and CMake (3.15+) are installed. Raylib is the primary dependency and can be automatically fetched during the build process.

2. Build Pipeline 
# Configure with external Raylib fetch
cmake -B build -D FETCH_RAYLIB=ON

# Build the project
cmake --build build --config Release

# Run Unit Tests
ctest --test-dir build

Technical Pipeline

graph LR
    Code[Code Change] --> Lint[Linting Check]
    Lint --> CMake[CMake Config]
    CMake --> Build[Binary Build]
    Build --> Test[Unit Testing]
    Test --> Deploy[Release Artifact]

Academic Resources

This project is supported by extensive documentation and presentation materials detailing its design and theoretical foundations.

Resource Description Format
SRS Document Software Requirements Specification and Data Structures (DSA) concepts. PDF
DSA Presentation Technical walkthrough of the concepts implemented in Cursed Tomorrow. PPTX

Credits & Vision

This project is a solo endeavor by Ahmad Hassan (B-Ted). It represents a commitment to clean code, intentional design, and the pursuit of digital atmosphere.

New people are welcomed to explore, contribute, and fork. The goal is to build a community around intentional game engineering.

"Tomorrow is coming, but it might be cursed."

CursedTomorrow (AhmadHassan-BTed/CursedTomorrow)

software-engineering
Searching Database…

1.2K ·GitHub
CursedTomorrow
What is this?Cursed Tomorrow is a 2D horror-survival and escape platformer built from scratch in C++, created as a solo technical showcase of a custom modular game engine and atmospheric storytelling.
Is this a game or a reusable engine/library?It is a standalone game with its own custom C++ game core (Core, Entities, Resources, Config modules), not a general-purpose engine meant to be imported into other projects.
How do I build and run it?Install a C++17 compiler and CMake 3.15+, then run the build pipeline; Raylib is fetched automatically during the build process.
Do I need to install Raylib myself first?No, Raylib is the primary rendering dependency but it is fetched automatically as part of the CMake build process, so manual installation isn't required.
Is there a Docker option if I don't want to set up a C++ toolchain locally?The project lists Docker among its topics, suggesting a containerized build/run path exists alongside the native CMake build, though the README doesn't detail the exact Docker commands.
Who is this aimed at besides players?It targets both players wanting an atmospheric horror platformer and developers/students interested in studying a documented, modular C++ game architecture.
What architecture does the game use internally?The game is organized into decoupled modules under a CursedTomorrow namespace: Core (window/state machine/main loop orchestration), Entities (actors and physics, independent), Resources (centralized asset caching, zero coupling), and Config (static global constants).
Are there extra learning materials beyond the code?Yes, the project includes an SRS (Software Requirements Specification) document covering data structures/DSA concepts and a DSA presentation walking through the implemented concepts.
What are similar projects?OpenRCT2, openage, luanti, bgfx, TheSimpsonsGameRecomp, cocos2d-x, WoWee, GDevelop
Which topics is it in?2d-game, oop, software-engineering, game-engine, cmake, game-development, game, gaming, cpp, c++, developers, education
Creator
AhmadHassan-BTed
Size
34.6 MB
Stars
1.2K
Updated
CommitJun 30
Age
3y
Commits · 90 Days