PixelDot2D Core Framework

PixelDot2D Core Framework

• A Performance-First 2D Foundation Built to Grow With Your Game.
• Simple to integrate. Powerful to extend. No hidden editor magic.

PixelDot2D is a code-first 2D framework for Unity built around decoupled systems, ScriptableObject-driven workflows, and lightweight C# orchestration.

The architecture is advanced, but using it doesn't have to be.

You can integrate the framework through small, straightforward API contracts and immediately start building with the included systems. When your project eventually needs something the framework doesn't provide, you can extend it without rewriting the systems that already work.

- - - - - - - What Is PixelDot2D? - - - - - - -

Many Unity frameworks become increasingly difficult to modify as projects grow. Behaviors become tied to specific prefabs, controllers accumulate responsibilities, and adding a new feature can require modifying existing architecture.

PixelDot2D takes a different approach.

Core systems are separated into lightweight C# classes and interfaces, while ScriptableObjects provide reusable data and behavior configurations.

• Your MonoBehaviours remain thin.
• Your GameObjects remain clean.
• Your gameplay logic stays inside systems designed to be composed, replaced, and extended.

- - - - - - - Build Without Fighting the Framework - - - - - - -

A character can be initialized with a blueprint and then simply updated by its host:

_controller = new();

_controller.Init(this, _characterBluePrint);

void Update()

{

_controller.Update(Time.deltaTime);

}

void FixedUpdate()

{

_controller.FixedUpdate(Time.deltaTime);

}

The controller handles the underlying state orchestration, transitions, passives, animation, movement, and lifecycle management all without a rigid inheritance chain, cleanly separated by a light weight interface.

You don't need to manage those systems manually.

The same philosophy applies throughout the framework.

- - - - - - - Modular Combat - - - - - - -

Weapons are assembled from independent ScriptableObject modules rather than hardcoded weapon classes.

A weapon can combine:

• Aiming
• Virtual Transform
• Execution Gates
• HitBox or HitScan execution
• Projectiles
• Custom visual behavior

The Weapon Manager only needs a small integration layer with a light weight interface:

_weaponManager = new();

_weaponManager.Init(this, _firePoint);

_weaponManager.CreateWeapons(weaponBlueprint);

void FixedUpdate()

{

_weaponManager.FixedUpdate(Time.deltaTime, attackPressed);

}

New combinations can be created entirely through the Unity Inspector without creating a new weapon implementation for every variation.

- - - - - - - ScriptableObjects as Virtual Prefabs - - - - - - -

PixelDot2D uses ScriptableObjects as reusable gameplay blueprints.

• Instead of creating increasingly specialized prefabs, you can compose behaviors through data.
• A character blueprint can define its states, stats, animations, movement behaviors, and other systems.
• A weapon blueprint can define its aiming behavior, execution strategy, cooldowns, hitbox configuration, projectile behavior, and visuals.
• This makes it possible to create large numbers of gameplay variations while keeping the underlying GameObject structure extremely small.

- - - - - - - Advanced Architecture Without Forced Complexity - - - - - - -

PixelDot2D is designed so that developers can use as much or as little of the architecture as they need.

You do not need to understand every internal system before using the framework.

At the same time, the framework does not hide its architecture from you.

When you need deeper control, the systems are built to be extended.

- - - - - - - Creating New Character States - - - - - - -

The ModularCharacter system follows a simple three-tier structure:

ScriptableObject → Data → Runtime State

A new movement state can be created as its own isolated class without modifying the central ModularCharacterController.

• The Factory/Flyweight architecture automatically handles runtime creation and reuse of the new state.
• This means extending the framework does not require turning the central controller into a registry of every possible gameplay behavior.

For example, a movement state can contain only the logic it actually needs:

protected override void OnFixedUpdate(float deltaTime, float timeScale)

{

ApplyGravity(timeScale);

MoveHorizontallyOnlyWithInput

(

GetCurrentStat(Enum_ModularCharacterStat.Move_Speed),

timeScale

);

UpdateFacingDirectionBasedOffInput();

}

The framework handles the surrounding lifecycle.

Your state handles its behavior.

This approach lets PixelDot2D provide useful foundational systems while leaving room for developers to build their own movement, abilities, passives, weapons, and gameplay mechanics.

- - - - - - - Built for Extensibility - - - - - - -

PixelDot2D is not intended to predict every game mechanic you may ever need.

Instead, the framework provides architectural foundations that can be extended without rewriting the core.

You can:

• Add new character states.
• Create new movement behaviors.
• Add new weapon modules.
• Create custom execution systems.
• Implement custom visual proxies.
• Introduce new currencies and economic behaviors.
• Replace or extend existing data configurations.
• Build entirely new systems around the framework's interfaces.

The goal is not to make every game behave the same way.

The goal is to make the framework stay out of your way when your game needs to become something different.

- - - - - - - Lightweight API Design - - - - - - -

The same philosophy extends beyond the major systems.

Need input?

KeybindManager.IsKeybindBeingUsed

(

Enum_PlayerKeybinds.Attack,

Enum_InputState.Pressed

);

Need animation?

AnimationPlayer2D player = new();

player.Init(spriteRenderer);

player.Play(animation);

player.Update(Time.deltaTime);

The framework handles the underlying sequence tracking, state management, and lifecycle logic.

You interact with the small surface that you actually need.

- - - - - - - Production-Ready Foundation - - - - - - -

PixelDot2D is not an empty architectural shell.

The framework includes pre-configured ScriptableObject assets and example implementations designed to provide immediate starting points for development.

The Modular Character framework includes foundational character configurations for different gameplay styles.

The Combat framework includes a growing collection of modular weapon configurations, execution systems, projectiles, HitBoxes, HitScans, aiming modules, execution gates, and visual systems.

These assets are designed as starting points rather than rigid templates.

You can use them as-is, modify their configuration, combine them with other modules, or create your own implementations.

- - - - - - - Documentation Where You Need It - - - - - - -

PixelDot2D includes PDF documentation, but extensive documentation also lives directly inside the source code.

Core classes contain XML documentation covering:

• Architectural intent.
• Lifecycle requirements.
• Extension points.
• Design considerations.
• Usage examples.
• Implementation relationships.
• Cross-references between related systems.

The goal is to make the framework explain itself while you are working with it.

You can start with the Inspector and API surface, then dive into the source when you want to understand or extend the underlying architecture.

- - - - - - - Performance-Conscious by Design - - - - - - -

PixelDot2D is designed around allocation-conscious runtime systems, reusable state instances, lightweight orchestration, and decoupled C# logic.

The framework makes extensive use of:

• State reuse.
• Factory/Flyweight patterns.
• Data-driven ScriptableObjects.
• Cached lookups.
• Allocation-conscious collections.
• Plain C# runtime systems.
• Lightweight interface contracts.

Performance is treated as an architectural concern rather than something added later through optimization passes.

PixelDot2D is built around Unity's native systems and C#.

- - - - - - - Requirements - - - - - - -

• Unity 6.6+
• Unity New Input System

No external UI framework or third-party runtime dependency is required.

PixelDot2D is designed to integrate with standard Unity components while keeping gameplay architecture decoupled from the GameObject hierarchy.

- - - - - - - Built for Developers Who Want Control - - - - - - -

PixelDot2D gives you a simple starting point without putting a ceiling on what you can build.

Use the included systems.

• Compose behavior through ScriptableObjects.
• Extend the framework when you need something new.
• Or go deeper and build directly on the underlying architecture.

The framework handles the structure. You build the game.

- - - - - - - List of Features - - - - - - -

https://github.com/PixelDot2D/PixelDot2D-Core-Framework-Feature-List

- - - - - - - Powerful architecture. Simple implementation - - - - - - -

https://gist.github.com/PixelDot2D/ed1d2a77ea291462a30665268874ad14

- - - - - - - Code Quality Preview - - - - - - -

https://gist.github.com/PixelDot2D/c89bbeb4a152f954f291fc2ad8ad072b

- - - - - - - Patch Notes History - - - - - - -

https://github.com/PixelDot2D/PixelDot2D-Core-Framework-Patch-Notes-History-4.0-Plus