byke

type Added ¶

type Added[C IsComponent[C]] = query.Added[C]

Added is a query filter that constraints the entities matched to include only entities that have added a component of type C since the last tick that the system owning the Query ran.

type AnyPtr ¶

type AnyPtr = any

type AnySystem ¶

type AnySystem any

AnySystem can be anything that can be coerced into a system.

func InState[S comparable](expectedState S) AnySystem

app.AddSystems(Update, System(doSomething).RunIf(InState(MenuStateTitle)))

func NotInState[S comparable](stateValue S) AnySystem

app.AddSystems(Update, System(doSomething).RunIf(NotInState(MenuStateTitle)))

func TimerJustFinished(timer Timer) AnySystem

type App ¶

type App struct {
	// contains filtered or unexported fields
}

App provides an entry point to your application.

func (a *App) AddEvent(newEvent eventType)

func (a *App) AddPlugin(plugin Plugin)

func (a *App) AddSystems(scheduleId ScheduleId, system AnySystem, systems ...AnySystem)

func (a *App) ConfigureSystemSets(scheduleId ScheduleId, sets ...*SystemSet)

func (a *App) InitState(newState stateType)

func (a *App) InsertResource(res any)

func (a *App) MustRun()

func (a *App) Run() error

func (a *App) RunWorld(run Runner)

func (a *App) World() *World

type Changed ¶

type Changed[C spoke.IsSupportsChangeDetectionComponent[C]] = query.Changed[C]

Changed is a query filter that constraints the entities matched to include only entities that have a changed Component value of type C since the last tick that the system owning the Query ran.

Change detection currently works by hashing the component value. As such, matching for changed component values is not 100% foolproof in case of hash collisions.

type ChildOf ¶

type ChildOf struct {
	ImmutableComponent[ChildOf]
	Relationship[Children]
	Parent EntityId
}

func (c ChildOf) RelationshipEntityId() EntityId

type Children ¶

type Children struct {
	ImmutableComponent[Children]
	RelationshipTarget[ChildOf]
}

type Command ¶

type Command interface {
	Apply(world *World)
}

type CommandFn ¶

type CommandFn func(world *World)

func (c CommandFn) Apply(world *World)

type Commands ¶

type Commands struct {
	// contains filtered or unexported fields
}

Commands is a SystemParam that allows you to send commands to a world. It allows you to spawn and despawn entities and to add and remove components. It must be injected as a pointer into a system.

func (c *Commands) Entity(entityId EntityId) EntityCommands

func (c *Commands) InsertResource(resource any) *Commands

func (c *Commands) Queue(command Command) *Commands

func (c *Commands) RunSystem(system AnySystem) *Commands

func (c *Commands) RunSystemWith(system AnySystem, inValue any) *Commands

func (c *Commands) Spawn(components ...ErasedComponent) EntityCommands

func (c *Commands) Trigger(eventValue any) *Commands

type ComparableComponent ¶

type ComparableComponent[T IsComparableComponent[T]] = spoke.ComparableComponent[T]

ComparableComponent is a zero sized type that may be embedded into a struct to turn that struct into a comparable component (see IsComponent).

type Component ¶

type Component[T IsComponent[T]] = spoke.Component[T]

Component is a zero sized type that may be embedded into a struct to turn that struct into a component (see IsComponent).

type EntityCommand ¶

type EntityCommand interface {
	Apply(world *World, entityId EntityId)
}

func InsertComponent[C IsComponent[C]](optionalValue ...C) EntityCommand

func RemoveComponent[C IsComponent[C]]() EntityCommand

type EntityCommands ¶

type EntityCommands struct {
	// contains filtered or unexported fields
}

func (e EntityCommands) Despawn()

func (e EntityCommands) Id() EntityId

func (e EntityCommands) Insert(components ...ErasedComponent) EntityCommands

func (e EntityCommands) Observe(system AnySystem) EntityCommands

func (e EntityCommands) Trigger(eventValue any) EntityCommands

func (e EntityCommands) Update(commands ...EntityCommand) EntityCommands

type EntityId ¶

type EntityId = spoke.EntityId

EntityId uniquely identifies an entity in a World.

type ErasedComponent ¶

type ErasedComponent = spoke.ErasedComponent

ErasedComponent indicates a type erased Component value.

Values given to the consumer of byke of this type are usually pointers, even though the interface is actually implemented directly on the component type.

func BundleOf(components ...ErasedComponent) ErasedComponent

func SpawnChild(components ...ErasedComponent) ErasedComponent

type EventId ¶

type EventId int

type EventReader ¶

type EventReader[E any] struct {
	// contains filtered or unexported fields
}

func (r *EventReader[E]) Read() []E

type EventWithId ¶

type EventWithId[E any] struct {
	Id    EventId
	Event E
}

type EventWriter ¶

type EventWriter[E any] struct {
	// contains filtered or unexported fields
}

func (w *EventWriter[E]) Write(event E)

type Events ¶

type Events[E any] struct {
	// contains filtered or unexported fields
}

func (e *Events[E]) AppendTo(target []EventWithId[E]) []EventWithId[E]

func (e *Events[E]) Reader() *EventReader[E]

func (e *Events[E]) Send(event E)

func (e *Events[E]) Update()

func (e *Events[E]) Writer() *EventWriter[E]

type FixedTime ¶

type FixedTime struct {
	Elapsed   time.Duration
	Delta     time.Duration
	DeltaSecs float64

	StepInterval time.Duration
	// contains filtered or unexported fields
}

FixedTime should be used in fixed step systems to measure the progression of time.

FixedTime will be updated using the value delta provided by VirtualTime, which might be scaled. In this case, time might accumulate more slowly and FixedTime steps will also be executed less often. To counteract this, you can decrement the StepInterval to executed fixed time step systems more often.

The default value of StepInterval is taken from bevy and is 1/64s.

type Has ¶

type Has[C IsComponent[C]] = query.Has[C]

Has is a query parameter that does not fetch the actual Component value of type T, but rather just indicates if a component of such type exists on the type. Currently it does not provide a performance boost over using an Option.

type ImmutableComponent ¶

type ImmutableComponent[T spoke.IsImmutableComponent[T]] = spoke.ImmutableComponent[T]

ImmutableComponent is a zero sized type that may be embedded into a struct to turn that struct into an immutable component (see IsComponent).

type In ¶

type In[T any] struct {
	Value T
}

In describes an input parameter of a system. A system can only accept exactly one input parameter.

type IsComparableComponent ¶

type IsComparableComponent[T IsComponent[T]] = spoke.IsComparableComponent[T]

IsComparableComponent indicates that a component is comparable. Only comparable components and immutable components can be used with the Changed query filter. At the time of writing, comparable components have a performance overhead when queried by pointer.

To implement the IsComparableComponent interface for a type, you must embed the ComparableComponent type.

type IsComponent ¶

type IsComponent[T any] = spoke.IsComponent[T]

IsComponent can be used in a type parameter to ensure that type T is a Component type.

To implement the IsComponent interface for a type, you must embed the Component type.

type IsImmutableComponent ¶

type IsImmutableComponent[T IsComponent[T]] = spoke.IsImmutableComponent[T]

IsImmutableComponent indicates that a component is immutable and can not be queried using pointer access. Immutable components can be updated by inserting a new copy of the same component into an entity using Command.

To implement the IsImmutableComponent interface for a type, you must embed the ImmutableComponent type.

type IsRelationshipComponent ¶

type IsRelationshipComponent[T IsImmutableComponent[T]] interface {
	IsImmutableComponent[T]
	// contains filtered or unexported methods
}

type IsRelationshipTargetComponent ¶

type IsRelationshipTargetComponent[T IsImmutableComponent[T]] interface {
	IsImmutableComponent[T]
	// contains filtered or unexported methods
}

type Local ¶

type Local[T any] struct {
	Value T
	// contains filtered or unexported fields
}

Local is a SystemParam that provides a value local to a system. It must be injected as a pointer value.

A system can have multiple independent Local parameters even with the same type T.

type Name ¶

type Name struct {
	spoke.ImmutableComponent[Name]
	Name string
}

Name assigns a non unique name to an entity. Adding a name can be helpful for debugging.

func Named(name string) Name

func (n Name) String() string

type NextState ¶

type NextState[S comparable] struct {
	// contains filtered or unexported fields
}

func (n *NextState[S]) Clear()

func (n *NextState[S]) Set(nextState S)

type Observer ¶

type Observer struct {
	Component[Observer]
	// contains filtered or unexported fields
}

func NewObserver(fn any) Observer

func (o Observer) IsScoped() bool

func (o Observer) Observes(id EntityId) bool

func (o Observer) ObservesType(ty reflect.Type) bool

func (o Observer) WatchEntity(entityId EntityId) Observer

type On ¶

type On[E any] struct {
	Target EntityId
	Event  E
}

type Option ¶

type Option[C IsComponent[C]] = query.Option[C]

Option is a query parameter that fetches a given Component of type T if it exists on an entity.

type OptionMut ¶

type OptionMut[C IsComponent[C]] = query.OptionMut[C]

OptionMut is a query parameter that fetches for a pointer to a Component of type T if it exists on an entity.

type Or ¶

type Or[A, B query.Filter] = query.Or[A, B]

Or is a query filter that allows you to combine two query filters with a local 'or'. Simply adding multiple filters to a query requires all filters to match. Using Or you can build a query, where just one of multiple filter need to match

type OrStruct ¶

type OrStruct[S any] = query.OrStruct[S]

OrStruct combines a struct of multiple filters with a logical Or. The type parameter S must be a struct type that contains only fields of type EmbeddableFilter named with an underscore.

type Plugin ¶

type Plugin func(app *App)

Plugin for an App. Call App.AddPlugin to add a Plugin to an App.

type Query ¶

type Query[T any] struct {
	// contains filtered or unexported fields
}

func (q *Query[T]) AppendTo(values []T) []T

func (q *Query[T]) Count() int

func (q *Query[T]) Get(entityId EntityId) (T, bool)

func (q *Query[T]) Items() iter.Seq[T]

func (q *Query[T]) MustFirst() T

func (q *Query[T]) Single() (T, bool)

type Relationship ¶

type Relationship[Parent IsImmutableComponent[Parent]] struct{}

Relationship must be embedded on the client side of a relationship

func (Relationship[Parent]) RelationshipTargetType() *spoke.ComponentType

type RelationshipTarget ¶

type RelationshipTarget[Child IsImmutableComponent[Child]] struct {
	// contains filtered or unexported fields
}

RelationshipTarget must be embedded on the parent side of a relationship

func (p *RelationshipTarget[Child]) Children() []EntityId

func (*RelationshipTarget[Child]) RelationshipType() *spoke.ComponentType

type RemovedComponents ¶

type RemovedComponents[C IsComponent[C]] struct {
	// contains filtered or unexported fields
}

func (c RemovedComponents[C]) Read() iter.Seq[EntityId]

type Res ¶

type Res[T any] struct {
	Value T
	// contains filtered or unexported fields
}

Res provides a SystemParam to inject a resource at runtime.

This is currently the same as just declaring the resource type directly as a parameter. In the future, the Res type may offer additional information, such as resource change tracking.

type ResOption ¶

type ResOption[T any] struct {
	Value *T
	// contains filtered or unexported fields
}

ResOption allows to inject a resource as a system param if it exists in the world. If the resource does not exist, the system will still run but a zero ResOption is injected.

type Runner ¶

type Runner func(world *World) error

type ScheduleId ¶

type ScheduleId interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

ScheduleId identifies a schedule. All implementing types must be comparable.

func MakeScheduleId(name string) ScheduleId

func OnEnter[S comparable](stateValue S) ScheduleId

func OnExit[S comparable](stateValue S) ScheduleId

func OnTransition[S comparable](previousStateValue, currentStateValue S) ScheduleId

type Single ¶

type Single[T any] struct {
	Value T
}

type State ¶

type State[S comparable] struct {
	// contains filtered or unexported fields
}

func (s State[S]) Current() S

type StateTransitionEvent ¶

type StateTransitionEvent[S comparable] struct {
	PreviousState S
	CurrentState  S
}

func (t *StateTransitionEvent[S]) IsIdentity() bool

type StateType ¶

type StateType[S comparable] struct {
	InitialValue S
}

type SystemId ¶

type SystemId unsafe.Pointer

SystemId uniquely identifies a system.

Implementation note: this currently uses the function pointer. A function pointer in go has two layers of indirection to be able to handle closures correctly. The function pointer points to a small memory region holding a pointer to the actual function, as well as all data closed over by a closure. The SystemId currently points to this outer region of memory, not to the function code itself.

type SystemParam ¶

type SystemParam interface {
	// contains filtered or unexported methods
}

SystemParam is an interface to give a type special behaviour when it is used as a parameter to a system.

While a system is being prepared, byke will check each parameter if it fulfills the SystemParam interface. If a parameter type does, a new instance will be allocate and the init method will be called.

See Local, ResOption or Query for some implementations of SystemParam.

type SystemParamState ¶

type SystemParamState interface {
	// contains filtered or unexported methods
}

SystemParamState is the state produced by SystemParam. TODO i need to check this interface & the assumptions,

maybe it makes sense to merge it into SystemParam.

type SystemSet ¶

type SystemSet struct {
	// contains filtered or unexported fields
}

SystemSet groups multiple systems together within one ScheduleId. SystemSet instances can be ordered between each other

func (s *SystemSet) After(other *SystemSet) *SystemSet

func (s *SystemSet) Before(other *SystemSet) *SystemSet

func (s *SystemSet) RunIf(predicate AnySystem) *SystemSet

type Systems ¶

type Systems struct {
	// contains filtered or unexported fields
}

Systems wrap one or more systems. See System for more details.

func System(systems ...AnySystem) Systems

func (s Systems) After(other AnySystem) Systems

func (s Systems) Before(other AnySystem) Systems

func (s Systems) Chain() Systems

func (s Systems) InSet(systemSet *SystemSet) Systems

func (s Systems) RunIf(predicate AnySystem) Systems

type Timer ¶

type Timer struct {
	// contains filtered or unexported fields
}

Timer is either a one of or a repeating timer with a specific duration.

func NewTimer(duration time.Duration, mode TimerMode) Timer

func NewTimerWithFrequency(hz float64) Timer

func (t *Timer) Duration() time.Duration

func (t *Timer) Elapsed() time.Duration

func (t *Timer) Finished() bool

func (t *Timer) Fraction() float64

func (t *Timer) FractionRemaining() float64

func (t *Timer) JustFinished() bool

func (t *Timer) Remaining() time.Duration

func (t *Timer) Reset()

func (t *Timer) Tick(delta time.Duration) *Timer

func (t *Timer) TimesFinishedThisTick() int

type TimerMode ¶

type TimerMode uint8

const TimerModeOnce TimerMode = 0

const TimerModeRepeating TimerMode = 1

type TimingStats ¶

type TimingStats struct {
	Visible bool

	BySchedule    map[ScheduleId]Timings
	ScheduleOrder []ScheduleId

	BySystem map[*preparedSystem]Timings
}

func NewTimingStats() TimingStats

func (t *TimingStats) MeasureSchedule(scheduleId ScheduleId) TimingStopwatch

func (t *TimingStats) MeasureSystem(system *preparedSystem) TimingStopwatch

type TimingStopwatch ¶

type TimingStopwatch struct {
	Stop func()
}

type Timings ¶

type Timings struct {
	Count         int
	Latest        time.Duration
	MovingAverage time.Duration
	Min, Max      time.Duration
}

func (t Timings) Add(d time.Duration) Timings

type VirtualTime ¶

type VirtualTime struct {
	Elapsed   time.Duration
	Delta     time.Duration
	DeltaSecs float64

	Scale float64
}

VirtualTime tracks time.

The progression of time can be scaled by setting the Scale field. This will scale the Delta and DeltaSecs values starting at the next frame.

type With ¶

type With[C IsComponent[C]] = query.With[C]

With is a query filter that constraints the entities queried to include only entities that have a Component of type T.

type Without ¶

type Without[C IsComponent[C]] = query.Without[C]

Without is a query filter that constraints the entities queried to include only entities that do not have a Component of type T.

type World ¶

type World struct {
	// contains filtered or unexported fields
}

World holds all entities and resources, schedules, systems, etc. While an empty World can be created using NewWorld, it is normally created and configured by using the App api.

func NewWorld() *World

func (w *World) AddObserver(observer Observer) EntityId

func (w *World) AddSystems(scheduleId ScheduleId, firstSystem AnySystem, systems ...AnySystem)

func (w *World) ConfigureSystemSets(scheduleId ScheduleId, systemSets ...*SystemSet)

func (w *World) Despawn(entityId EntityId)

func (w *World) InsertResource(resource any)

func (w *World) RemoveResource(resourceType reflect.Type)

func (w *World) Resource(ty reflect.Type) (AnyPtr, bool)

func (w *World) RunSchedule(scheduleId ScheduleId)

func (w *World) RunSystem(system AnySystem)

func (w *World) RunSystemWithInValue(system AnySystem, inValue any)

func (w *World) Spawn(components []ErasedComponent) EntityId

func (w *World) TriggerObserver(targetId EntityId, eventValue any)