pt

Documentation

Overview

Package pt 实体与组件原型，用于创建实体。

Index

• Variables
• func As[T any](entity ec.Entity) (*T, bool)
• func Cast[T any](entity ec.Entity) *T
• func For(provider EntityPTProvider, prototype string) ec.EntityPT
• func UnsafeEntityLib(entityLib EntityLib) _UnsafeEntityLib
• type ComponentAttribute
  • func ComponentWith(inst any, name string, nonRemovable bool, extra ...map[string]any) ComponentAttribute
• type ComponentLib
  • func DefaultComponentLib() ComponentLib
  • func NewComponentLib() ComponentLib
• type Composite
  • func Compose[T any](entity ec.Entity) *Composite[T]
  • func (c *Composite[T]) As() (*T, bool)
  • func (c *Composite[T]) Cast() *T
  • func (c *Composite[T]) Changed() bool
  • func (c *Composite[T]) Entity() ec.Entity
• type EntityAttribute
  • func EntityWith(prototype string, inst any, scope *ec.Scope, ...) EntityAttribute
• type EntityLib
  • func NewEntityLib(compLib ComponentLib) EntityLib
• type EntityPTProvider

Variables

var (
	ErrPt = fmt.Errorf("%w: pt", exception.ErrCore) // 原型错误
)

Functions

func As

func As[T any](entity ec.Entity) (*T, bool)

As 从实体中提取一些需要的组件，复合在一起直接使用。

示例：

type IA interface {
	MethodA()
}
...
type IB interface {
	MethodB()
}
...
type CompositeAB struct {
	IA `ec:"A"`			// 指定组件名
	IB `ec:",CompB"`	// 指定组件原型名
}
...
entity.AddComponent("A", compA)
entity.AddComponent("B", compB)
...
v, ok := As[CompositeAB](entity)
if ok {
	v.MethodA()
	v.MethodB()
}

注意：

1.类型参数必须为结构体类型，可以是匿名结构体。
2.内部逻辑有使用反射，为了提高性能，可以使用一次后存储转换结果重复使用。
3.实体更新组件后，需要重新提取。
4.需要使用tag标记组件名或组件原型名，若没有标记，将会尝试使用字段名作为组件名去查找。
5.提取失败会返回false。

func Cast

func Cast[T any](entity ec.Entity) *T

Cast 从实体中提取一些需要的组件，复合在一起直接使用，提取失败会panic。

示例：

type IA interface {
	MethodA()
}
...
type IB interface {
	MethodB()
}
...
type CompositeAB struct {
	IA `ec:"A"`			// 指定组件名
	IB `ec:",CompB"`	// 指定组件原型名
}
...
entity.AddComponent("A", compA)
entity.AddComponent("B", compB)
...
Cast[CompositeAB](entity).MethodA()
Cast[CompositeAB](entity).MethodB()

注意：

1.类型参数必须为结构体类型，可以是匿名结构体。
2.内部逻辑有使用反射，为了提高性能，可以使用一次后存储转换结果重复使用。
3.实体更新组件后，需要重新提取。
4.需要使用tag标记组件名或组件原型名，若没有标记，将会尝试使用字段名作为组件名去查找。
5.提取失败会panic。

func For

func For(provider EntityPTProvider, prototype string) ec.EntityPT

For 查询实体原型

func UnsafeEntityLib

func UnsafeEntityLib(entityLib EntityLib) _UnsafeEntityLib

Deprecated: UnsafeEntityLib 访问实体原型库的内部方法

Types

type ComponentAttribute

type ComponentAttribute struct {
	Instance     any                           // 组件实例（必填）
	Name         string                        // 组件名称
	NonRemovable bool                          // 是否不可删除
	Extra        generic.SliceMap[string, any] // 自定义属性
}

ComponentAttribute 组件原型属性

func ComponentWith

func ComponentWith(inst any, name string, nonRemovable bool, extra ...map[string]any) ComponentAttribute

ComponentWith 创建组件原型属性，用于注册实体原型时自定义相关属性

type ComponentLib

type ComponentLib interface {
	// Declare 声明组件原型（可以重复声明）
	Declare(comp any) ec.ComponentPT
	// Undeclare 取消声明组件原型
	Undeclare(prototype string)
	// Get 获取组件原型
	Get(prototype string) (ec.ComponentPT, bool)
	// Range 遍历所有已注册的组件原型
	Range(fun generic.Func1[ec.ComponentPT, bool])
	// ReversedRange 反向遍历所有已注册的组件原型
	ReversedRange(fun generic.Func1[ec.ComponentPT, bool])
}

ComponentLib 组件原型库

func DefaultComponentLib

func DefaultComponentLib() ComponentLib

DefaultComponentLib 默认组件库

func NewComponentLib

func NewComponentLib() ComponentLib

NewComponentLib 创建组件原型库

type Composite

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

Composite 组件复合器，直接使用As()或Cast()时，无法检测提取后实体是否又更新组件，使用复合器可以解决此问题。

示例：

type IA interface {
	MethodA()
}
...
type IB interface {
	MethodB()
}
...
type CompositeAB struct {
	IA `ec:"A"`			// 指定组件名
	IB `ec:",CompB"`	// 指定组件原型名
}
...
entity.AddComponent("A", compA)
entity.AddComponent("B", compB)
...
cx := Compose[CompositeAB](entity)
if v, ok := cx.As(); ok {
	v.MethodA()
	v.MethodB()
}
cx.Cast().MethodA()
cx.Cast().MethodB()

func Compose

func Compose[T any](entity ec.Entity) *Composite[T]

Compose 创建组件复合器

func (*Composite[T]) As

func (c *Composite[T]) As() (*T, bool)

As 从实体提取一些需要的组件接口，复合在一起直接使用（实体更新组件后，会自动重新提取）

func (*Composite[T]) Cast

func (c *Composite[T]) Cast() *T

Cast 从实体提取一些需要的组件接口，复合在一起直接使用，提取失败会panic（实体更新组件后，会自动重新提取）

func (*Composite[T]) Changed

func (c *Composite[T]) Changed() bool

Changed 实体是否已更新组件

func (*Composite[T]) Entity

func (c *Composite[T]) Entity() ec.Entity

Entity 实体

type EntityAttribute

type EntityAttribute struct {
	Prototype                  string                        // 实体原型名称（必填）
	Instance                   any                           // 实体实例
	Scope                      *ec.Scope                     // 可访问作用域
	ComponentAwakeOnFirstTouch *bool                         // 开启组件被首次访问时，检测并调用Awake()
	ComponentUniqueID          *bool                         // 开启组件唯一Id
	Extra                      generic.SliceMap[string, any] // 自定义属性
}

EntityAttribute 实体原型属性

func EntityWith

func EntityWith(prototype string, inst any, scope *ec.Scope, componentAwakeOnFirstTouch, componentUniqueID *bool, extra ...map[string]any) EntityAttribute

EntityWith 创建实体原型属性，用于注册实体原型时自定义相关属性

type EntityLib

type EntityLib interface {
	EntityPTProvider

	// GetComponentLib 获取组件原型库
	GetComponentLib() ComponentLib
	// Declare 声明实体原型
	Declare(prototype any, comps ...any) ec.EntityPT
	// Redeclare 重声明实体原型
	Redeclare(prototype any, comps ...any) ec.EntityPT
	// Undeclare 取消声明实体原型
	Undeclare(prototype string)
	// Get 获取实体原型
	Get(prototype string) (ec.EntityPT, bool)
	// Range 遍历所有已注册的实体原型
	Range(fun generic.Func1[ec.EntityPT, bool])
	// ReversedRange 反向遍历所有已注册的实体原型
	ReversedRange(fun generic.Func1[ec.EntityPT, bool])
	// contains filtered or unexported methods
}

EntityLib 实体原型库

func NewEntityLib

func NewEntityLib(compLib ComponentLib) EntityLib

NewEntityLib 创建实体原型库

type EntityPTProvider

type EntityPTProvider interface {
	// GetEntityLib 获取实体原型库
	GetEntityLib() EntityLib
}

EntityPTProvider 实体原型提供者