Entity Component System framework for Ebitengine
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

467 lines
11 KiB

package gohan
import (
"fmt"
"log"
"os"
"reflect"
"strconv"
"strings"
"sync"
"time"
"github.com/hajimehoshi/ebiten/v2"
)
var debug int
func init() {
debugEnv := os.Getenv("GOHAN_DEBUG")
debugEnv = strings.TrimSpace(debugEnv)
debugEnv = strings.ToLower(debugEnv)
i, err := strconv.Atoi(debugEnv)
if err == nil {
debug = i
return
}
if debugEnv == "t" || debugEnv == "y" || debugEnv == "on" || debugEnv == "yes" || debugEnv == "true" {
debug = 1
}
}
var w = newWorld()
// world represents a collection of AllEntities, components and Systems.
type world struct {
maxEntityID Entity
maxComponentID componentID
components [][]interface{} // components[Entity][componentID]Component
allEntities []Entity
modifiedEntities []Entity
removedEntities []Entity
handledModifiedEntities map[Entity]bool
// availableEntities is the set of EntityIDs available because they were
// removed from the game.
availableEntities []Entity
systems []System
systemEntities [][]Entity // Slice of entities matching each system.
systemNeeds [][]componentID // Slice of ComponentIDs needed by each system.
systemUses [][]componentID // Slice of ComponentIDs used by each system.
systemComponentIDs [][]componentID // Slice of ComponentIDs needed or used by each system.
systemComponentFields [][]reflect.Value // Slice of component struct fields used by each system.
systemReceivesUpdate []bool
systemReceivesDraw []bool
systemUpdatedEntities int
systemUpdatedEntitiesV int
systemUpdatedEntitiesT time.Time
systemDrawnEntities int
systemDrawnEntitiesV int
systemDrawnEntitiesT time.Time
systemComponentNames []string
haveSystemComponentName map[string]bool
cacheTime time.Duration
entityMutex sync.Mutex
componentMutex sync.Mutex
sync.Mutex
}
// NewWorld returns a new world.
func newWorld() *world {
w := &world{
cacheTime: time.Second,
handledModifiedEntities: make(map[Entity]bool),
haveSystemComponentName: make(map[string]bool),
}
// Pad slices to match IDs starting with 1.
w.components = append(w.components, nil)
w.systemComponentNames = append(w.systemComponentNames, "")
return w
}
// AddSystem registers a system to start receiving Update and Draw calls.
func AddSystem(system System) {
w.Lock()
defer w.Unlock()
systemIndex := len(w.systems)
w.systems = append(w.systems, system)
w.systemReceivesUpdate = append(w.systemReceivesUpdate, true)
w.systemReceivesDraw = append(w.systemReceivesDraw, true)
w.systemEntities = append(w.systemEntities, nil)
w.systemComponentFields = append(w.systemComponentFields, nil)
w.entityMutex.Lock()
defer w.entityMutex.Unlock()
w.modifiedEntities = append(w.modifiedEntities, w.allEntities...)
sV := reflect.ValueOf(system)
sT := reflect.TypeOf(system)
if sV.Kind() == reflect.Ptr {
sV = sV.Elem()
sT = sT.Elem()
}
if sV.Kind() != reflect.Struct {
panic("system must be a struct type")
}
var usedComponentIDs []componentID
var neededComponentIDs []componentID
w.systemComponentIDs = append(w.systemComponentIDs, nil)
for i := 0; i < sT.NumField(); i++ {
field := sV.Field(i)
if !field.CanSet() {
continue
}
tag := sT.Field(i).Tag.Get("gohan")
if tag == "-" {
continue
}
//log.Println("SET FIELD", systemIndex, field.String(), tag, field.CanSet())
w.systemComponentFields[systemIndex] = append(w.systemComponentFields[systemIndex], field)
id := componentIDByName(field.Type().String())
if tag == "?" {
usedComponentIDs = append(usedComponentIDs, id)
} else {
neededComponentIDs = append(neededComponentIDs, id)
}
w.systemComponentIDs[systemIndex] = append(w.systemComponentIDs[systemIndex], id)
}
w.systemNeeds = append(w.systemNeeds, neededComponentIDs)
w.systemUses = append(w.systemUses, usedComponentIDs)
}
/*
// AddSystemAfter registers a system to start receiving Update and Draw calls
// after the specified system (or systems) are called first.
func AddSystemAfter(system System, after ...System) {
gameSystems = append(gameSystems, system)
gameSystemReceivesUpdate = append(gameSystemReceivesUpdate, true)
gameSystemReceivesDraw = append(gameSystemReceivesDraw, true)
gameSystemEntities = append(gameSystemEntities, nil)
attachEntitiesToSystem(system)
}
*/
func (w *world) setSystemComponentFields(e Entity, i int) {
//log.Println(len(w.systemComponentFields[i]))
//log.Println(w.systemComponentFields[i])
for j, field := range w.systemComponentFields[i] {
//log.Println(j, field, field.String())
id := w.systemComponentIDs[i][j]
//log.Println("SYSTEM", i, "FIELD", j, "ID", id)
if w.components[e][id] == nil {
field.Set(reflect.Zero(field.Type()))
} else {
field.Set(reflect.ValueOf(w.components[e][id]))
}
}
}
func (w *world) updateSystem(i int) (int, error) {
w.propagateEntityChanges()
updated := 0
for _, entity := range w.systemEntities[i] {
w.setSystemComponentFields(entity, i)
err := w.systems[i].Update(entity)
if err != nil {
if err == ErrUnregister {
// Unregister system from Update events.
w.systemReceivesUpdate[i] = false
return 0, nil
}
return 0, fmt.Errorf("failed to update %s for entity %d: %+v", w.systemName(i), entity, err)
}
updated++
}
return updated, nil
}
func (w *world) _handleRemovedEntities() {
for _, entity := range w.removedEntities {
// Remove from attached systems.
REMOVED:
for i := range w.systemEntities {
for j, e := range w.systemEntities[i] {
if e == entity {
w.systemEntities[i] = _removeAt(w.systemEntities[i], j)
continue REMOVED
}
}
}
}
// Mark EntityID as available.
w.availableEntities = append(w.availableEntities, w.removedEntities...)
w.removedEntities = w.removedEntities[:0]
}
// _handleModifiedEntities handles changes to entity components by attaching
// and detaching modified entities from affected systems.
func (w *world) _handleModifiedEntities() {
if len(w.modifiedEntities) == 0 {
return
}
for _, entity := range w.modifiedEntities {
if w.handledModifiedEntities[entity] {
continue
}
w.handledModifiedEntities[entity] = true
for i := range w.systems {
systemEntityIndex := -1
for j, systemEntity := range w.systemEntities[i] {
if systemEntity == entity {
systemEntityIndex = j
break
}
}
var skip bool
for _, componentID := range w.systemNeeds[i] {
c := entity.getComponent(componentID)
if c == nil {
skip = true
break
}
}
if !skip {
if systemEntityIndex != -1 {
// Already attached.
continue
}
w.systemEntities[i] = append(w.systemEntities[i], entity)
if debug > 1 {
log.Printf("Attached entity %d to %s.", entity, w.systemName(i))
}
} else if systemEntityIndex != -1 {
// Detach from system.
w.systemEntities[i] = _removeAt(w.systemEntities[i], systemEntityIndex)
}
}
}
for k := range w.handledModifiedEntities {
delete(w.handledModifiedEntities, k)
}
w.modifiedEntities = w.modifiedEntities[:0]
}
func (w *world) propagateEntityChanges() {
w.entityMutex.Lock()
defer w.entityMutex.Unlock()
w._handleRemovedEntities()
w._handleModifiedEntities()
}
// Update updates the game state.
func Update() error {
w.Lock()
defer w.Unlock()
var t time.Time
if debug != 0 {
t = time.Now()
}
var entitiesUpdated int
for i, registered := range w.systemReceivesUpdate {
if !registered {
continue
}
updated, err := w.updateSystem(i)
if err != nil {
return err
}
entitiesUpdated += updated
if debug != 0 {
log.Printf("- %s: %d updated in %.2fms.", w.systemName(i), updated, float64(time.Since(t).Microseconds())/1000)
}
}
w.systemUpdatedEntities = entitiesUpdated
if debug != 0 {
log.Printf("Handled %d entity updates in %.2fms.", entitiesUpdated, float64(time.Since(t).Microseconds())/1000)
}
return nil
}
// CurrentUpdates returns the number of System Update calls required to update
// the game state. Because entities may be handled by more than one System,
// this number may be higher than the number of active entities.
func CurrentUpdates() int {
if time.Since(w.systemUpdatedEntitiesT) >= w.cacheTime {
w.systemUpdatedEntitiesV = w.systemUpdatedEntities
w.systemUpdatedEntitiesT = time.Now()
}
return w.systemUpdatedEntitiesV
}
func (w *world) drawSystem(i int, screen *ebiten.Image) (int, error) {
w.propagateEntityChanges()
var drawn int
for _, entity := range w.systemEntities[i] {
w.setSystemComponentFields(entity, i)
err := w.systems[i].Draw(entity, screen)
if err != nil {
if err == ErrUnregister {
// Unregister system from Draw events.
w.systemReceivesDraw[i] = false
return 0, nil
}
return 0, fmt.Errorf("failed to draw %s for entity %d: %+v", w.systemName(i), entity, err)
}
drawn++
}
return drawn, nil
}
// Draw draws the game on to the screen.
func Draw(screen *ebiten.Image) error {
w.Lock()
defer w.Unlock()
var t time.Time
if debug != 0 {
t = time.Now()
}
var entitiesDrawn int
for i, registered := range w.systemReceivesDraw {
if !registered {
continue
}
drawn, err := w.drawSystem(i, screen)
if err != nil {
return err
}
entitiesDrawn += drawn
if debug != 0 {
log.Printf("- %s: %d drawn in %.2fms.", w.systemName(i), drawn, float64(time.Since(t).Microseconds())/1000)
}
}
w.systemDrawnEntities = entitiesDrawn
if debug != 0 {
log.Printf("Handled %d entity draws in %.2fms.", entitiesDrawn, float64(time.Since(t).Microseconds())/1000)
}
return nil
}
// CurrentDraws returns the number of System Draw calls required to draw the
// game on to the screen. Because entities may be handled by more than one
// System, this number may be higher than the number of active entities.
func CurrentDraws() int {
if time.Since(w.systemDrawnEntitiesT) >= w.cacheTime {
w.systemDrawnEntitiesV = w.systemDrawnEntities
w.systemDrawnEntitiesT = time.Now()
}
return w.systemDrawnEntitiesV
}
// Preallocate creates and then immediately removes the specified number of entities.
// Because Gohan reuses removed entities, this has the effect of pre-allocating
// the memory used later to create entities normally. Pre-allocating enough
// entities to run your application after its systems has been added, but
// before any entities are created, will provide the greatest performance boost.
func Preallocate(entities int) {
if len(w.availableEntities) >= entities {
return
}
e := make([]Entity, entities)
for i := 0; i < entities; i++ {
e[i] = NewEntity()
}
for i := 0; i < entities; i++ {
e[i].Remove()
}
}
func uniqueComponentIDs(v []componentID) []componentID {
var list []componentID
keys := make(map[componentID]bool)
for _, entry := range v {
if _, value := keys[entry]; !value {
keys[entry] = true
list = append(list, entry)
}
}
return list
}
func (w *world) componentName(id componentID) string {
if int(id) < len(w.systemComponentNames) {
return w.systemComponentNames[id]
}
return strconv.Itoa(int(id))
}
func (w *world) systemName(i int) string {
if i < len(w.systems) {
return getName(w.systems[i])
}
return strconv.Itoa(i)
}
func getName(v interface{}) string {
t := reflect.TypeOf(v)
if t.Kind() == reflect.Ptr {
return strings.Title(t.Elem().Name())
} else if t.Kind() == reflect.Struct {
return strings.Title(t.Name())
}
return ""
}
// Reset removes all entities, components and systems.
func Reset() {
old := w
old.Lock()
w = newWorld()
old.Unlock()
}