use gogues ecs, not working, needs rethinking

cmd/game/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
+	"lab.zaar.be/thefish/alchemyst-go/engine/ecs"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap/mapgens"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
@@ -44,8 +45,8 @@ var State = gamestate.GameState{
 	Exit:         make(chan struct{}, 1),
 	Input:        make(chan string, 1),
 	RawInput:     make(chan int, 1),
-	FovRecompute: make(chan struct{},1),
-	Redraw: 	  make(chan struct{},1),
+	FovRecompute: make(chan struct{}, 1),
+	Redraw:       make(chan struct{}, 1),
 }
 
 func main() {
@@ -66,35 +67,58 @@ func main() {
 	State.Level = level
 	vp := mainwindow.NewViewPort(30, 0, 70, 47, mw.GetLayer("base"))
 
-
 	screenMgr := types.NewScreenManager(mainCtx)
 	screenMgr.AddScreen("title", &screens.TitleScreen{})
 	screenMgr.AddScreen("game", screens.NewGameScreen(mw, &State, vp))
 
 	screenMgr.SetScreenByName("game")
 
-
 	//fixme
-	player := &mob.Player{
-		Mob: mob.Mob{
-			Appearance: &types.Appearance{
-				Glyph: &types.PlainGlyphHolder{"@"},
-				ColorSet: &types.TileColorSet{
-					Fg:     &types.PlainColorHolder{255, 255, 255, 255},
-				},
-			},
-			Coords: rooms[0].Center,
-			BlocksPass: true,
-		},
-	}
-	State.Player = player
+	//player := &mob.Player{
+	//	Mob: mob.Mob{
+	//		Appearance: &types.Appearance{
+	//			Glyph: &types.PlainGlyphHolder{"@"},
+	//			ColorSet: &types.TileColorSet{
+	//				Fg:     &types.PlainColorHolder{255, 255, 255, 255},
+	//			},
+	//		},
+	//		Coords: rooms[0].Center,
+	//		BlocksPass: true,
+	//	},
+	//}
+	//State.Player = player
 
-	vp.PlayerCoords = player.Coords
-	vp.Render(&State)
+	//vp.PlayerCoords = player.Coords
+	//vp.Render(&State)
 
 	go decodeInput(mainCtx, mw.GetLayer("base"))
 	go vp.Listen(State)
 
+	controller := ecs.NewController()
+
+	controller.MapComponentClass("coords", types.Coords{})
+	controller.MapComponentClass("appearance", types.Appearance{})
+	controller.MapComponentClass("mob", mob.Mob{})
+
+	player := controller.CreateEntity([]ecs.Component{})
+
+	controller.AddComponent(player, &types.Appearance{
+		Glyph: &types.PlainGlyphHolder{"@"},
+		ColorSet: &types.TileColorSet{
+			Fg: &types.PlainColorHolder{255, 255, 255, 255},
+		},
+	})
+
+	controller.AddComponent(player, rooms[0].Center) //implicit Coords
+
+
+	render := mob.MobRenderSystem{EntityController: controller}
+
+	controller.AddSystem(render, 1)
+
+
+
+
 	//but every call to bearlibterminal must be wrapped to closure and passed to mainfunc
 	var exit = false
 	for !exit {
@@ -112,7 +136,7 @@ func main() {
 			mainCtx.Logger().Warn().Msg("quitting NOW")
 			exit = true
 			break
-		// не оставляйте default в бесконесчном select {} - сожрет всё CPU
+			// не оставляйте default в бесконесчном select {} - сожрет всё CPU
 		default:
 			screenMgr.CurrentScreen.Render()
 			blt.Refresh()

engine/ecs/component.go

@@ -0,0 +1,9 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+import "reflect"
+
+type Component interface {
+	TypeOf() reflect.Type
+}

engine/ecs/controller.go

@@ -0,0 +1,247 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+type Controller struct {
+	systems map[reflect.Type]System
+	sortedSystems map[int][]System
+	priorityKeys []int
+	nextEntityID int
+	components map[reflect.Type][]int
+	entities map[int]map[reflect.Type]Component
+	deadEntities []int
+
+	// The component map will keep track of what components are available
+	componentMap map[string]Component
+}
+
+// NewController is a convenience/constructor method to properly initialize a new processor
+func NewController() *Controller {
+	controller := Controller{}
+	controller.systems = make(map[reflect.Type]System)
+	controller.sortedSystems = make(map[int][]System)
+	controller.priorityKeys = []int{}
+	controller.nextEntityID = 0
+	controller.components = make(map[reflect.Type][]int)
+	controller.entities = make(map[int]map[reflect.Type]Component)
+	controller.deadEntities = []int{}
+	controller.componentMap = make(map[string]Component)
+
+	return &controller
+}
+
+// Create a new entity in the world. An entity is simply a unique integer.
+// If any components are provided, they will be associated with the created entity
+func (c *Controller) CreateEntity(components []Component) int {
+	c.nextEntityID += 1
+
+	if len(components) > 0 {
+		for _, v := range components {
+			c.AddComponent(c.nextEntityID, v)
+		}
+	}
+
+	c.entities[c.nextEntityID] = make(map[reflect.Type]Component)
+
+	return c.nextEntityID
+}
+
+// DeleteEntity removes an entity, all component instances attached to that entity, and any components associations with
+// that entity
+func (c *Controller) DeleteEntity(entity int) {
+	// First, delete all the component associations for the entity to be removed
+	for k, _ := range c.entities[entity] {
+		c.RemoveComponent(entity, k)
+	}
+
+	// Then, delete the entity itself. The components have already been removed and disassociated with it, so a simple
+	// delete will do here
+	delete(c.entities, entity)
+}
+
+// MapComponent registers a component with the controller. This map of components gives the controller access to the
+// valid components for a game system, and allows for dynamic loading of components from the data loader.
+func (c *Controller) MapComponentClass(componentName string, component Component) {
+	// TODO: Possible to overwrite existing components with old name...
+	c.componentMap[componentName] = component
+}
+
+// GetMappedComponentClass returns a component class based on the name it was registered under. This allows for dyanamic
+// mapping of components to entities, for example, from the data loader.
+func (c *Controller) GetMappedComponentClass(componentName string) Component {
+	if _, ok := c.componentMap[componentName]; ok {
+		return c.componentMap[componentName]
+	} else {
+		// TODO: Add better (read: actual) error handling here
+		fmt.Printf("Component[%s] not registered on Controller.\n", componentName)
+		return nil
+	}
+}
+
+// AddComponent adds a component to an entity. The component is added to the global list of components for the
+// processor, and also directly associated with the entity itself. This allows for flexible checking of components,
+// as you can check which entites are associated with a component, and vice versa.
+func (c *Controller) AddComponent(entity int, component Component) {
+	// First, get the type of the component
+	componentType := reflect.TypeOf(component)
+
+	// Record that the component type is associated with the entity.
+	c.components[componentType] = append(c.components[componentType], entity)
+
+	// Now, check to see if the entity is already tracked in the controller entity list. If it is not, add it, and
+	// associate the component with it
+	if _, ok := c.entities[entity]; !ok {
+		c.entities[entity] = make(map[reflect.Type]Component)
+	}
+
+	c.entities[entity][componentType] = component
+}
+
+// HasComponent checks a given entity to see if it has a given component associated with it
+func (c *Controller) HasComponent(entity int, componentType reflect.Type) bool {
+	if _, ok := c.entities[entity][componentType]; ok {
+		return true
+	} else {
+		return false
+	}
+}
+
+// GetComponent returns the component instance for a component type, if one exists for the provided entity
+func (c *Controller) GetComponent(entity int, componentType reflect.Type) Component {
+	// Check the given entity has the provided component
+	if c.HasComponent(entity, componentType) {
+		return c.entities[entity][componentType]
+	}
+
+	return nil
+}
+
+// GetEntity gets a specific entity, and all of its component instances
+func (c *Controller) GetEntity(entity int) map[reflect.Type]Component {
+	for i, _ := range c.entities {
+		if i == entity {
+			return c.entities[entity]
+		}
+	}
+
+	return nil
+}
+
+// GetEntities returns a map of all entities and their component instances
+func (c *Controller) GetEntities() map[int]map[reflect.Type]Component {
+	return c.entities
+}
+
+// GetEntitiesWithComponent returns a list of all entities with a given component attached
+// TODO: Allow for passing a list of components
+func (c *Controller) GetEntitiesWithComponent(componentType reflect.Type) []int {
+	entitiesWithComponent := make([]int, 0)
+	for entity := range c.entities {
+		if c.HasComponent(entity, componentType) {
+			entitiesWithComponent = append(entitiesWithComponent, entity)
+		}
+	}
+
+	return entitiesWithComponent
+}
+
+// UpdateComponent updates a component on an entity with a new version of the same component
+func (c *Controller) UpdateComponent(entity int, componentType reflect.Type, newComponent Component) int {
+	// First, remove the component in question (Don't actually update things, but rather remove and replace)
+	c.RemoveComponent(entity, componentType)
+
+	// Next, replace the removed component with the updated one
+	c.AddComponent(entity, newComponent)
+
+	return entity
+}
+
+// DeleteComponent will delete a component instance from an entity, based on component type. It will also remove the
+// association between the component and the entity, and remove the component from the processor completely if no
+// other entities are using it.
+func (c *Controller) RemoveComponent(entity int, componentType reflect.Type) int {
+	// Find the index of the entity to operate on in the components slice
+	index := -1
+	for i, v := range c.components[componentType] {
+		if (v == entity) {
+			index = i
+		}
+	}
+
+	// If the component was found on the entity, remove the association between the component and the entity
+	if index != -1 {
+		c.components[componentType] = append(c.components[componentType][:index], c.components[componentType][index+1:]...)
+		// If this was the last entity associated with the component, remove the component entry as well
+		if len(c.components[componentType]) == 0 {
+			delete(c.components, componentType)
+		}
+	}
+
+	// Now, remove the component instance from the entity
+	delete(c.entities[entity], componentType)
+
+	return entity
+}
+
+
+// AddSystem registers a system to the controller. A priority can be provided, and systems will be processed in
+// numeric order, low to high. If multiple systems are registered as the same priority, they will be randomly run within
+// that priority group.
+func (c *Controller) AddSystem(system System, priority int) {
+	systemType := reflect.TypeOf(system)
+
+	if _, ok := c.systems[systemType]; !ok {
+		// A system of this type has not been added yet, so add it to the systems list
+		c.systems[systemType] = system
+
+		// Now, append the system to a special list that will be used for sorting by priority
+		if !IntInSlice(priority, c.priorityKeys) {
+			c.priorityKeys = append(c.priorityKeys, priority)
+		}
+		c.sortedSystems[priority] = append(c.sortedSystems[priority], system)
+		sort.Ints(c.priorityKeys)
+	} else {
+		fmt.Printf("A system of type %v was already added to the controller %v!", systemType, c)
+	}
+}
+
+// Process kicks off system processing for all systems attached to the controller. Systems will be processed in the
+// order they are found, or if they have a priority, in priority order. If there is a mix of systems with priority and
+// without, systems with priority will be processed first (in order).
+func (c *Controller) Process(excludedSystems []reflect.Type) {
+	for _, key := range c.priorityKeys {
+		for _, system := range c.sortedSystems[key] {
+			systemType := reflect.TypeOf(system)
+
+			// Check if the current system type was marked as excluded on this call. If it was, not process it.
+			if !TypeInSlice(systemType, excludedSystems) {
+				system.Process()
+			}
+		}
+	}
+}
+
+// HasSystem checks the controller to see if it has a given system associated with it
+func (c *Controller) HasSystem(systemType reflect.Type) bool {
+	if _, ok := c.systems[systemType]; ok {
+		return true
+	} else {
+		return false
+	}
+}
+
+// ProcessSystem allows for on demand processing of individual systems, rather than processing all at once via Process
+func (c *Controller) ProcessSystem(systemType reflect.Type) {
+	if c.HasSystem(systemType) {
+		system := c.systems[systemType]
+		system.Process()
+	}
+}
+
+

engine/ecs/entity.go

@@ -1,3 +1,9 @@
 package ecs
 
+// ECS system by jcerise, github.com/jcerise/gogue
+
 type Entity int
+
+func (e *Entity) HasComponent(c Component) bool {
+	return true
+}

engine/ecs/system.go

@@ -0,0 +1,7 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+type System interface {
+	Process()
+}

engine/ecs/systemMessages.go

@@ -0,0 +1,87 @@
+package ecs
+
+type SystemMessageType struct {
+	Name string
+}
+
+type SystemMessage struct {
+	MessageType SystemMessageType
+	Originator System
+	MessageContent map[string]string
+}
+
+// SystemMessageQueue is a super simple way of messaging between systems. Essentially, it is nothing more than a list of
+// messages. Each message has a type, and an originator. Each system can "subscribe" to a type of message, which
+// basically just means that it will check the queue for any messages of that type before it does anything else.
+// Messages can contain a map of information, which each system that creates messages of that type, and those that
+// subscribe to it should know how to handle any information contained in the message. Ideally, the message queue will
+// be cleared out occasionally, either by the subscribing systems, or the game loop. Pretty simple for now, but should
+// solve a subset of problems nicely.
+type SystemMessageQueue struct {
+	Messages map[System][]SystemMessage
+	Subscriptions map[System][]SystemMessageType
+}
+
+func InitializeSystemMessageQueue() *SystemMessageQueue {
+	smq := SystemMessageQueue{}
+	smq.Messages = make(map[System][]SystemMessage)
+	smq.Subscriptions = make(map[System][]SystemMessageType)
+	return &smq
+}
+
+// BroadcastMessage appends a system message onto the games SystemMessageQueue, allowing it to consumed by a service
+// subscribes to the MessageType.
+func (smq *SystemMessageQueue) BroadcastMessage(messageType SystemMessageType, messageContent map[string]string, originator System) {
+	newMessage := SystemMessage{MessageType: messageType, MessageContent: messageContent, Originator: originator}
+
+	// Find all subscriptions to this message type, and add this message to the subscribers message queue
+	for subscribedSystem, typeList := range smq.Subscriptions {
+		if MessageTypeInSlice(messageType, typeList) {
+			smq.Messages[subscribedSystem] = append(smq.Messages[subscribedSystem], newMessage)
+		}
+	}
+}
+
+// GetSubscribedMessages returns a list of SystemMessages that have messageType. Can return an empty list
+func (smq *SystemMessageQueue) GetSubscribedMessages(system System) []SystemMessage {
+	messages := []SystemMessage{}
+
+	for _, message := range smq.Messages[system] {
+		messages = append(messages, message)
+	}
+
+	return messages
+}
+
+// DeleteMessages deletes a processed message from the queue (for example, if the event has been processed)
+func (smq *SystemMessageQueue) DeleteMessages(messageName string, system System) {
+	modifiedQueue := smq.Messages[system]
+	for index, message := range smq.Messages[system] {
+		if message.MessageType.Name == messageName {
+			modifiedQueue[index] = modifiedQueue[len(modifiedQueue)-1]
+			modifiedQueue = modifiedQueue[:len(modifiedQueue)-1]
+		}
+	}
+
+	smq.Messages[system] = modifiedQueue
+}
+
+//MessageTypeInSlice will return true if the MessageType provided is present in the slice provided, false otherwise
+func MessageTypeInSlice(a SystemMessageType, list []SystemMessageType) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}
+
+//MessageTypeInSliceOfMessages will return true if the MessageType provided is present in the slice provided, false otherwise
+func MessageTypeInSliceOfMessages(a SystemMessageType, list []SystemMessage) bool {
+	for _, b := range list {
+		if b.MessageType == a {
+			return true
+		}
+	}
+	return false
+}

engine/ecs/util.go

@@ -0,0 +1,25 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+import "reflect"
+
+// IntInSlice will return true if the integer value provided is present in the slice provided, false otherwise.
+func IntInSlice(a int, list []int) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}
+
+// TypeInSlice will return true if the reflect.Type provided is present in the slice provided, false otherwise.
+func TypeInSlice(a reflect.Type, list []reflect.Type) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}

engine/gamemap/level.go

@@ -17,7 +17,7 @@ type Level struct {
 	Name     string
 	Branch   string
 	Depth    int
-	Objects  []ecs.Entity
+	Objects  *[]ecs.Entity
 	Tiles    []*Tile
 }
 

engine/mob/mob.go

@@ -2,7 +2,9 @@ package mob
 
 import (
 	"fmt"
+	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+	"reflect"
 )
 
 type Mob struct {
@@ -11,8 +13,14 @@ type Mob struct {
 	BlocksPass bool
 }
 
-func (m *Mob) Walk(dx, dy int) {
-	m.Coords = types.Coords{m.X + dx, m.Y + dy}
+func (m *Mob) Walk(level *gamemap.Level, dx, dy int) {
+	newCoords := types.Coords{m.X + dx, m.Y + dy}
+	if level.GetTile(newCoords).BlocksPass {
+		return
+	}
+	if level.Objects.At(newCoords).HasComponent("block_pass") {
+
+	}
 	fmt.Printf("new coords: %d, %d\n", m.Coords.X, m.Coords.Y)
 }
 
@@ -22,4 +30,8 @@ func (m *Mob) Render() {
 
 func (m *Mob) MoveToCoords(c types.Coords) {
 
+}
+
+func (mob Mob) TypeOf() reflect.Type {
+	return reflect.TypeOf(mob)
 }

engine/mob/mob_render_system.go

@@ -0,0 +1,29 @@
+package mob
+
+import (
+	"lab.zaar.be/thefish/alchemyst-go/engine/ecs"
+	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+)
+
+type MobRenderSystem struct {
+	EntityController *ecs.Controller
+}
+
+func (mrs MobRenderSystem) Process(){
+	for e := range mrs.EntityController.GetEntities() {
+		if mrs.EntityController.HasComponent(e, types.Coords{}.TypeOf()) &&
+			mrs.EntityController.HasComponent(e, types.Appearance{}.TypeOf()) {
+
+			pos := mrs.EntityController.GetComponent(e, types.Coords{}.TypeOf()).(types.Coords)
+			appearance := mrs.EntityController.GetComponent(e, types.Appearance{}.TypeOf()).(types.Appearance)
+
+			// Clear the cell this entity occupies, so it is the only glyph drawn there
+			for i := 0; i <= 2; i++ {
+				//fixme
+				gogue.ClearArea(pos.X, pos.Y, 1, 1, i)
+			}
+			//fixme
+			gogue.PrintGlyph(pos.X, pos.Y, appearance.Glyph, "", appearance.Layer)
+		}
+	}
+}

engine/screens/game.go

@@ -21,28 +21,28 @@ func (ts *GameScreen) HandleInput(input string) {
 	//ts.state.Do(func(){
 	switch input {
 	case "Up", "k", "8":
-		ts.state.Player.Walk(0, -1)
+		ts.state.Player.Walk(ts.state.Level, 0, -1)
 		break
 	case "Down", "j", "2":
-		ts.state.Player.Walk(0, 1)
+		ts.state.Player.Walk(ts.state.Level,0, 1)
 		break
 	case "Left", "h", "4":
-		ts.state.Player.Walk(-1, 0)
+		ts.state.Player.Walk(ts.state.Level,-1, 0)
 		break
 	case "Right", "l", "6":
-		ts.state.Player.Walk(1, 0)
+		ts.state.Player.Walk(ts.state.Level,1, 0)
 		break
 	case "y", "7":
-		ts.state.Player.Walk(-1, -1)
+		ts.state.Player.Walk(ts.state.Level,-1, -1)
 		break
 	case "u", "9":
-		ts.state.Player.Walk(1, -1)
+		ts.state.Player.Walk(ts.state.Level,1, -1)
 		break
 	case "b", "1":
-		ts.state.Player.Walk(-1, 1)
+		ts.state.Player.Walk(ts.state.Level,-1, 1)
 		break
 	case "n", "3":
-		ts.state.Player.Walk(1, 1)
+		ts.state.Player.Walk(ts.state.Level,1, 1)
 		break
 	default:
 		ts.mw.GetLayer("base").ClearArea(0, 3, 40, 1)

engine/types/appearance.go

@@ -3,6 +3,7 @@ package types
 import (
 	"github.com/gammazero/deque"
 	"lab.zaar.be/thefish/alchemyst-go/util"
+	"reflect"
 )
 import blt "lab.zaar.be/thefish/bearlibterminal"
 
@@ -78,7 +79,6 @@ type Appearance struct {
 	ColorSet *TileColorSet `json:"colorSet"`
 }
 
-
 func SingleColorRing(colorValue uint8) *cdeque {
 	c := &cdeque{}
 	c.PushBack(colorValue)
@@ -104,4 +104,8 @@ func FillColorRing(colorValue uint8, minGlow, maxGlow, step int) *cdeque {
 		c.PushBack(uint8(v))
 	}
 	return c
+}
+
+func (app Appearance) TypeOf() reflect.Type {
+	return reflect.TypeOf(app)
 }

engine/types/coords.go

@@ -1,11 +1,18 @@
 package types
 
-import "math"
+import (
+	"math"
+	"reflect"
+)
 
 type Coords struct {
 	X, Y int
 }
 
+func (сс Coords) TypeOf() reflect.Type {
+	return reflect.TypeOf(сс)
+}
+
 func (c *Coords) Get() (int, int) {
 	return c.X, c.Y
 }