refactoring to systems complete. also added observers for collision checks

TODO.md

@@ -1,16 +1,9 @@
 ## Levels:
 
-- get rid of floor image
-- use background image over whole screen size
-- put level on top of it
-- paint level in levels/**.lvl on whole screen into the middle
 - use first line as background image name
 - ignore comments in lvl files
-- add whitespace-mode flag in lvl files
+- check  when sphere bounces from  one end to the  other endlessly w/o
-- check when sphere bounces from one end to the other endlessly w/o any solids in between. this is a game lock and equals game over
+  any solids in between. this is a game lock and equals game over
 
-SYSTEM Stuff:
+- Grid Observer:
-
+  https://github.com/mlange-42/arche/issues/374
-- initialize systems in NewLevel()
-- replace level.Update() with systems update
-- mv Draw() from level to systems

assets/levels/gurke.lvl

@@ -5,7 +5,7 @@ Background: background-orange
    # ############   
    #            #   
    ############ #   
-   #     S      #   
+   #   o S      #   
    # ######## ###   
               #     
    ############ #   

assets/loader-levels.go

@@ -76,7 +76,7 @@ func NewTileParticle(class []string) *Tile {
 		Class:      "particle",
 		Solid:      false,
 		Renderable: false,
-		Particle:   -1,
+		Particle:   0,
 		Particles:  sprites,
 	}
 }

game/game.go

@@ -3,6 +3,7 @@ package game
 import (
 	"fmt"
 	"image"
+	"openquell/observers"
 
 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/mlange-42/arche/ecs"
@@ -28,6 +29,9 @@ func NewGame(width, height, startlevel int, startscene int) *Game {
 		Scenes:       map[int]Scene{},
 	}
 
+	observers.NewPlayerObserver(&world)
+	observers.NewParticleObserver(&world)
+
 	game.Scenes[Play] = NewLevelScene(game, startlevel)
 
 	fmt.Println(game.World.Stats().String())

grid/grid.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"openquell/assets"
 	"openquell/components"
+	"openquell/observers"
 
 	"github.com/mlange-42/arche/ecs"
 	"github.com/mlange-42/arche/generic"
@@ -45,14 +46,11 @@ func NewGrid(world *ecs.World,
 		components.Renderable,
 		components.Collectible](world)
 
-	ptmapper := generic.NewMap2[
-		components.Position,
-		components.Particle,
-	](world)
-
 	var pos *components.Position
 	var render *components.Renderable
 
+	playerobserver := observers.GetPlayerObserver(world)
+
 	for point, tile := range mapslice {
 		switch tile.Renderable {
 		case true:
@@ -63,6 +61,8 @@ func NewGrid(world *ecs.World,
 			case tile.Player:
 				entity := playermapper.New()
 				pos, _, render, _ = playermapper.Get(entity)
+				playerobserver.AddEntity(entity)
+
 				fmt.Printf("player start pos: %d,%d\n", point.X*tilesize, point.Y*tilesize)
 			case tile.Collectible:
 				entity := colmapper.New()
@@ -85,12 +85,6 @@ func NewGrid(world *ecs.World,
 		pos.Update(point.X*tilesize, point.Y*tilesize, tilesize)
 	}
 
-	// not part of the grid, but add them as well
-	entity := ptmapper.New()
-	_, particle := ptmapper.Get(entity)
-	particle.Index = assets.Tiles['*'].Particle
-	particle.Particles = assets.Tiles['*'].Particles
-
 	return &Grid{
 		Size:     len(mapslice),
 		Tilesize: tilesize,

observers/particle_observer.go

@@ -0,0 +1,53 @@
+package observers
+
+import (
+	"github.com/mlange-42/arche/ecs"
+	"github.com/mlange-42/arche/ecs/event"
+	"github.com/mlange-42/arche/generic"
+	"github.com/mlange-42/arche/listener"
+)
+
+// will be added as  an ecs.Resource to the world so we  can use it in
+// CollisionSystem to dynamically make it appear or disappear
+type ParticleObserver struct {
+	// we only have one particle so far, if we use multiple ones, turn
+	// this in to a map, see player_observer.go for an example
+	Entity ecs.Entity
+}
+
+// Create a  new resource of  type PlayerObserver which will  hold all
+// player  entities.   We   also  add  a  Listener   which  looks  for
+// EntityRemoved events and  if a player gets removed,  we also remove
+// it from the Entity map in our observer.
+func NewParticleObserver(world *ecs.World) {
+	observer := &ParticleObserver{}
+
+	resmanger := generic.NewResource[ParticleObserver](world)
+	resmanger.Add(observer)
+
+	listen := listener.NewCallback(
+		func(world *ecs.World, event ecs.EntityEvent) {
+			observerID := ecs.ResourceID[ParticleObserver](world)
+			observer := world.Resources().Get(observerID).(*ParticleObserver)
+			observer.RemoveEntity(event.Entity)
+		},
+
+		event.EntityRemoved,
+	)
+
+	world.SetListener(&listen)
+}
+
+func GetParticleObserver(world *ecs.World) *ParticleObserver {
+	observerID := ecs.ResourceID[ParticleObserver](world)
+	observer := world.Resources().Get(observerID).(*ParticleObserver)
+	return observer
+}
+
+func (observer *ParticleObserver) AddEntity(entity ecs.Entity) {
+	observer.Entity = entity
+}
+
+func (observer *ParticleObserver) RemoveEntity(entity ecs.Entity) {
+	observer.Entity = ecs.Entity{}
+}

observers/player_observer.go

@@ -0,0 +1,52 @@
+package observers
+
+import (
+	"github.com/mlange-42/arche/ecs"
+	"github.com/mlange-42/arche/ecs/event"
+	"github.com/mlange-42/arche/generic"
+	"github.com/mlange-42/arche/listener"
+)
+
+// will be added as  an ecs.Resource to the world so we  can use it in
+// CollisionSystem  to check  for  player collisions.
+type PlayerObserver struct {
+	Entities map[ecs.Entity]int
+}
+
+// Create a  new resource of  type PlayerObserver which will  hold all
+// player  entities.   We   also  add  a  Listener   which  looks  for
+// EntityRemoved events and  if a player gets removed,  we also remove
+// it from the Entity map in our observer.
+func NewPlayerObserver(world *ecs.World) {
+	observer := &PlayerObserver{}
+	observer.Entities = make(map[ecs.Entity]int)
+
+	resmanger := generic.NewResource[PlayerObserver](world)
+	resmanger.Add(observer)
+
+	listen := listener.NewCallback(
+		func(world *ecs.World, event ecs.EntityEvent) {
+			observerID := ecs.ResourceID[PlayerObserver](world)
+			observer := world.Resources().Get(observerID).(*PlayerObserver)
+			observer.RemoveEntity(event.Entity)
+		},
+
+		event.EntityRemoved,
+	)
+
+	world.SetListener(&listen)
+}
+
+func GetPlayerObserver(world *ecs.World) *PlayerObserver {
+	observerID := ecs.ResourceID[PlayerObserver](world)
+	observer := world.Resources().Get(observerID).(*PlayerObserver)
+	return observer
+}
+
+func (observer *PlayerObserver) AddEntity(entity ecs.Entity) {
+	observer.Entities[entity] = 1
+}
+
+func (observer *PlayerObserver) RemoveEntity(entity ecs.Entity) {
+	delete(observer.Entities, entity)
+}

systems/collectible_system.go

@@ -2,8 +2,10 @@ package systems
 
 import (
 	"fmt"
-	"image"
+	"openquell/assets"
+	"openquell/components"
 	. "openquell/components"
+	"openquell/observers"
 
 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/mlange-42/arche/ecs"
@@ -11,9 +13,8 @@ import (
 )
 
 type CollectibleSystem struct {
-	World            *ecs.World
+	World    *ecs.World
-	Selector         *generic.Filter3[Position, Collectible, Renderable]
+	Selector *generic.Filter3[Position, Collectible, Renderable]
-	EntitiesToRemove []ecs.Entity
 }
 
 func NewCollectibleSystem(world *ecs.World) *CollectibleSystem {
@@ -25,38 +26,39 @@ func NewCollectibleSystem(world *ecs.World) *CollectibleSystem {
 	return system
 }
 
-func (system *CollectibleSystem) CheckPlayerCollision(
+func (system *CollectibleSystem) Update() {
-	playerposition *Position,
+	playerobserver := observers.GetPlayerObserver(system.World)
-	playervelocity *Velocity) (bool, image.Point) {
 
-	particle_pos := image.Point{}
+	posID := ecs.ComponentID[components.Position](system.World)
-	var bumped bool
+	veloID := ecs.ComponentID[components.Velocity](system.World)
+	particlepositions := []*components.Position{}
+	EntitiesToRemove := []ecs.Entity{}
 
 	query := system.Selector.Query(system.World)
 
 	for query.Next() {
 		colposition, collectible, _ := query.Get()
 
-		ok, _ := playerposition.Intersects(colposition, playervelocity)
+		for player := range playerobserver.Entities {
-		if ok {
+			playerposition := (*Position)(system.World.Get(player, posID))
-			fmt.Printf("bumped into collectible %v\n", collectible)
+			playervelocity := (*Velocity)(system.World.Get(player, veloID))
-			system.EntitiesToRemove = append(system.EntitiesToRemove, query.Entity())
+
-			particle_pos.X = colposition.X
+			ok, _ := playerposition.Intersects(colposition, playervelocity)
-			particle_pos.Y = colposition.Y
+			if ok {
-			bumped = true
+				fmt.Printf("bumped into collectible %v\n", collectible)
+				particlepositions = append(particlepositions, colposition)
+				EntitiesToRemove = append(EntitiesToRemove, query.Entity())
+			}
 		}
 	}
 
-	return bumped, particle_pos
+	for _, pos := range particlepositions {
-}
+		system.AddParticle(pos)
-
-func (system *CollectibleSystem) Update() {
-	// remove collectible if collected
-	for _, entity := range system.EntitiesToRemove {
-		system.World.RemoveEntity(entity)
 	}
 
-	system.EntitiesToRemove = []ecs.Entity{}
+	for _, entity := range EntitiesToRemove {
+		system.World.RemoveEntity(entity)
+	}
 }
 
 func (system *CollectibleSystem) Draw(screen *ebiten.Image) {
@@ -73,3 +75,25 @@ func (system *CollectibleSystem) Draw(screen *ebiten.Image) {
 		screen.DrawImage(sprite.Image, op)
 	}
 }
+
+func (system *CollectibleSystem) AddParticle(position *components.Position) {
+	particleobserver := observers.GetParticleObserver(system.World)
+
+	ptmapper := generic.NewMap2[
+		components.Position,
+		components.Particle,
+	](system.World)
+
+	entity := ptmapper.New()
+	pos, particle := ptmapper.Get(entity)
+	particleobserver.AddEntity(entity)
+
+	particle.Index = assets.Tiles['*'].Particle
+	particle.Particles = assets.Tiles['*'].Particles
+
+	pos.Update(
+		position.X-(16), // FIXME: use global tilesize!
+		position.Y-(16),
+		64,
+	)
+}

systems/particle_system.go

@@ -1,7 +1,6 @@
 package systems
 
 import (
-	"image"
 	. "openquell/components"
 
 	"github.com/hajimehoshi/ebiten/v2"
@@ -25,34 +24,29 @@ func NewParticleSystem(world *ecs.World, cellsize int) *ParticleSystem {
 	return system
 }
 
-func (system *ParticleSystem) Update(detonate bool, position *image.Point) {
+func (system *ParticleSystem) Update() {
 	// display debris after collecting
+	EntitiesToRemove := []ecs.Entity{}
+
 	query := system.Selector.Query(system.World)
 
 	for query.Next() {
 		// we loop, but it's only one anyway
-		ptposition, particle := query.Get()
+		_, particle := query.Get()
 
-		if detonate {
+		switch {
-			// particle appears
+		// particle shows from earlier tick, animate
-			ptposition.Update(
+		case particle.Index > -1 && particle.Index < len(particle.Particles)-1:
-				position.X-(system.Cellsize/2),
+			particle.Index++
-				position.Y-(system.Cellsize/2),
+		default:
-				64,
+			// last sprite reached, remove it
-			)
+			EntitiesToRemove = append(EntitiesToRemove, query.Entity())
-
-			particle.Index = 0 // start displaying the particle
-		} else {
-			switch {
-			// particle shows from earlier tick, animate
-			case particle.Index > -1 && particle.Index < len(particle.Particles)-1:
-				particle.Index++
-			default:
-				// last sprite reached, remove it
-				particle.Index = -1
-			}
 		}
 	}
+
+	for _, entity := range EntitiesToRemove {
+		system.World.RemoveEntity(entity)
+	}
 }
 
 func (system *ParticleSystem) Draw(screen *ebiten.Image) {
@@ -63,11 +57,8 @@ func (system *ParticleSystem) Draw(screen *ebiten.Image) {
 	for query.Next() {
 		pos, particle := query.Get()
 
-		if particle.Index > -1 {
+		op.GeoM.Reset()
-			op.GeoM.Reset()
+		op.GeoM.Translate(float64(pos.X), float64(pos.Y))
-			op.GeoM.Translate(float64(pos.X), float64(pos.Y))
+		screen.DrawImage(particle.Particles[particle.Index], op)
-			screen.DrawImage(particle.Particles[particle.Index], op)
-		}
 	}
-
 }

systems/player_system.go

@@ -2,7 +2,6 @@ package systems
 
 import (
 	"fmt"
-	"image"
 	. "openquell/components"
 	. "openquell/config"
 
@@ -34,9 +33,6 @@ func NewPlayerSystem(world *ecs.World, grid *GridSystem) *PlayerSystem {
 func (system PlayerSystem) Update() error {
 	query := system.Selector.Query(system.World)
 
-	var bumped bool
-	var particle_pos image.Point
-
 	for query.Next() {
 		playerposition, velocity, _, _ := query.Get()
 
@@ -74,14 +70,12 @@ func (system PlayerSystem) Update() error {
 					}
 				}
 			}
-
-			bumped, particle_pos = system.Collectible.CheckPlayerCollision(playerposition, velocity)
 		}
 
 		playerposition.Move(velocity)
 	}
 
-	system.Particle.Update(bumped, &particle_pos)
+	system.Particle.Update()
 	system.Collectible.Update()
 
 	return nil