Skip to content

Overview

The MixelPixel codebase follows a modular plugin architecture built around a shared Core API.

Most functionality is implemented in separate plugins, while common systems are provided by the Core.

Typical components include:

  • Core API
  • Gameplay Plugins
  • Data Systems
  • Shared Utilities

Core Plugin

The Core plugin provides shared functionality used by all other plugins.

Typical responsibilities include:

  • player wrappers (BukkitPixelPlayer)
  • own command system
  • own event / listener system
  • own inventory system
  • shared managers
  • database connections
  • Redis communication
  • utility systems
  • shared APIs

Other plugins have to avoid re-implementing these systems and instead use the Core services.

Manager Pattern

Many systems are implemented using Managers.

Managers are responsible for handling specific subsystems.

Example:

KitManager\ PinataManager\ PlotManager\ PlayerDataManager

Managers usually:

  • hold runtime data
  • provide access to systems
  • coordinate services

Managers should not become god classes and should only handle a clearly defined subsystem.

Typical Plugin Structure

Most plugins follow this package structure:

command/

data/

event/

gui/

gui/bedrock/

listener/

manager/

redis/

util/

Example structure:

example_packages.png{width=340 height=552}

Dependency Usage

Plugins may depend on each other when exposing a clear API.

However, the Core API should always be preferred for shared systems and infrastructure.

Core systems such as:

  • database connections
  • redis communication
  • player wrappers
  • shared utilities
  • common managers

must always be used from the Core plugin and must not be reimplemented in other plugins.

For example, developers should never implement their own MySQL connectors or Redis clients inside a plugin. Instead, use the database and service systems provided by the Core API.

This ensures:

  • consistent infrastructure
  • easier maintenance
  • centralized configuration
  • fewer duplicated systems

Development Philosophy

The project follows a few simple architectural principles:

  • separation of concerns
  • modular plugin design
  • clear system responsibilities

When adding new systems, try to follow the same patterns used in the existing codebase.

Final Notes

You should now be able to write your first MixelPixel code and are familiar with the basic standards used in this project.

If you have questions about the Core API, take a look at the Core API Wiki ([[Core Overview|Core-API/Core-Overview]]) and browse through the available topics.

If something is missing or unclear, don’t hesitate to ask. This wiki is still a work in progress and far from complete.