Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/yetanotherclown/planck
An Agnostic Scheduler for ECS
https://github.com/yetanotherclown/planck
ecs luau scheduler
Last synced: 11 days ago
JSON representation
An Agnostic Scheduler for ECS
- Host: GitHub
- URL: https://github.com/yetanotherclown/planck
- Owner: YetAnotherClown
- License: mit
- Created: 2024-11-26T07:14:28.000Z (28 days ago)
- Default Branch: main
- Last Pushed: 2024-12-12T00:18:35.000Z (12 days ago)
- Last Synced: 2024-12-12T01:22:01.822Z (12 days ago)
- Topics: ecs, luau, scheduler
- Language: Luau
- Homepage: https://yetanotherclown.github.io/planck/
- Size: 1.44 MB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE.md
Awesome Lists containing this project
README
# Planck, an ECS Scheduler
[](https://yetanotherclown.github.io/planck)
[](https://wally.run/package/yetanotherclown/planck)
An Agnostic Scheduler, inspired by Bevy Schedules and Flecs Pipelines and Phases.
> [!IMPORTANT]
> The Planck Scheduler and it's plugins are currently in development!
> This means that they are not uploaded to Wally just yet.
>
> v0.1.0 of this library will release when Roblox TypeScript typings are
> added as well as a Plugin to support the Matter Debugger.
## Installation
You can install Planck with Wally
```toml
[dependencies]
Planck = "yetanotherclown/[email protected]"
```
## Basics
### Phases
A Phase is just a tag you can assign to your systems, it's a way to order systems as a group.
```luau
local myPhase = Phase.new("debugName")
scheduler
:insert(myPhase, RunService, "Heartbeat")
:addSystems(systemA, myPhase)
```
### Pipelines
A Pipeline is a group of ordered phases. Each phase will run in the fixed order to which each Phase was passed to it.
```luau
local myPipeline = Pipeline.new()
:insert(phaseA)
:insert(phaseB)
:insert(phaseC)
scheduler
:insert(myPipeline, RunService, "Heartbeat")
```
### Built-in Pipelines & Phases
#### Startup
Systems on these phases will run exactly once, before any other phase runs.
- PreStartup
- Startup
- PostStartup
```luau
local Planck = require("@packages/Planck")
local Phase = Planck.Phase
local PreStartup = Phase.PreStartup
local Startup = Phase.Startup
local PostStartup = Phase.PostStartup
```
#### Engine Events
These Phases are ran on Engine RunService Events,
events are ran in the order listed.
| Event | Phase |
| -------------- | -------------- |
| PreRender | PreRender |
| PreAnimation | PreAnimation |
| PreSimulation | PreSimulation |
| PostSimulation | PostSimulation |
| Heartbeat | Update |
```luau
local Planck = require("@packages/Planck")
local Phase = Planck.Phase
local PreRender = Phase.PreRender
local PreAnimation = Phase.PreAnimation
local PreSimulation = Phase.PreSimulation
local PostSimulation = Phase.PostSimulation
local Update = Phase.Update
```
#### Main
The Main Pipeline will run phases on the `RunService.Heartbeat` event.
- First
- PreUpdate
- Update
- PostUpdate
- Last
```luau
local Planck = require("@packages/Planck")
local Phase = Planck.Phase
local First = Phase.First
local PreUpdate = Phase.PreUpdate
local Update = Phase.Update
local PostUpdate = Phase.PostUpdate
local Last = Phase.Last
```
### Systems
A system is just a function, or it could be a system table.
```luau
local systemA = {
phase = myPhase,
system = function()
-- ...
end,
}
local function systemB()
-- ...
end
scheduler
:addSystems(systemA)
:addSystems(systemB, myPhase)
```
### The Scheduler
The Scheduler is where you initialize all your Pipelines, Phases, and Systems.
```luau
local Planck = require("@packages/Planck")
local Phase = Planck.Phase
local Pipeline = Planck.Pipeline
local Scheduler = Planck.Scheduler
local PreUpdate = Phase.new()
local Update = Phase.new()
local PostUpdate = Phase.new()
local UpdatePipeline = Pipeline.new()
:insert(PreUpdate)
:insert(Update)
:insert(PostUpdate)
local Render = Phase.new()
local scheduler = scheduler.new(world)
:insert(UpdatePipeline, RunService, "Heartbeat")
:insertAfter(Render, UpdatePipeline)
:addSystems(systems, Update)
scheduler:removeSystem(systemA)
scheduler:replaceSystem(systemA, systemB)
scheduler:editSystem(systemA, newPhase)
scheduler:editSystem(systemA)
scheduler:setRunCondition(systemA, function(world)
return someCondition and true or false
end)
```
### Plugins
The Planck Scheduler is pluggable, providing plugins to add
support for Jabby and the Matter Hooks runtime.
You can learn more in the [Plugin Docs](https://yetanotherclown.github.io/planck/docs/plugins/).