implement node based approach

Signed-off-by: Fabian Kammel <fabian@kammel.dev>

Author: datosh

aabb_collider.go

@@ -0,0 +1,96 @@
+package engine
+
+import (
+	"image/color"
+
+	"engine/vec2"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+)
+
+type AABBCollider struct {
+	BaseNode
+	Position    *vec2.T
+	Size        *vec2.T
+	OnCollision *Signal[Node]
+	DebugMode   bool
+}
+
+func NewAABBCollider(name string, position *vec2.T, size *vec2.T) *AABBCollider {
+	collider := &AABBCollider{
+		BaseNode:    *NewNode(name),
+		Position:    position,
+		Size:        size,
+		OnCollision: NewSignal[Node](),
+	}
+	collider.AddTag("Collider")
+	return collider
+}
+
+func (c *AABBCollider) Update() error {
+	if err := c.BaseNode.Update(); err != nil {
+		return err
+	}
+
+	if ebiten.IsKeyPressed(ebiten.KeyF10) {
+		c.DebugMode = true
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyControl) && ebiten.IsKeyPressed(ebiten.KeyF10) {
+		c.DebugMode = false
+	}
+
+	return nil
+}
+
+func (c *AABBCollider) Draw(screen *ebiten.Image) {
+	c.BaseNode.Draw(screen)
+
+	if c.DebugMode {
+		vector.StrokeRect(
+			screen,
+			float32(c.Position.X),
+			float32(c.Position.Y),
+			float32(c.Size.X),
+			float32(c.Size.Y),
+			1,
+			color.White,
+			false,
+		)
+	}
+}
+
+func (c *AABBCollider) CollidesWithAABB(other *AABBCollider) bool {
+	return c.Position.X < other.Position.X+other.Size.X &&
+		c.Position.X+c.Size.X > other.Position.X &&
+		c.Position.Y < other.Position.Y+other.Size.Y &&
+		c.Position.Y+c.Size.Y > other.Position.Y
+}
+
+func (c *AABBCollider) CollidesWithCircle(other *CircleCollider) bool {
+	// Check if the circle is inside the AABB
+	if other.Position.X >= c.Position.X &&
+		other.Position.X+other.Radius <= c.Position.X+c.Size.X &&
+		other.Position.Y >= c.Position.Y &&
+		other.Position.Y+other.Radius <= c.Position.Y+c.Size.Y {
+		return true
+	}
+
+	// Check if the AABB is inside the circle
+	if c.Position.X >= other.Position.X &&
+		c.Position.X+c.Size.X <= other.Position.X+other.Radius &&
+		c.Position.Y >= other.Position.Y &&
+		c.Position.Y+c.Size.Y <= other.Position.Y+other.Radius {
+		return true
+	}
+
+	// Check if the AABB is outside the circle
+	if c.Position.X > other.Position.X+other.Radius ||
+		c.Position.X+c.Size.X < other.Position.X ||
+		c.Position.Y > other.Position.Y+other.Radius ||
+		c.Position.Y+c.Size.Y < other.Position.Y {
+		return false
+	}
+
+	return true
+}

circle_collider.go

@@ -0,0 +1,75 @@
+package engine
+
+import (
+	"image/color"
+	"math"
+
+	"engine/vec2"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+)
+
+type CircleCollider struct {
+	BaseNode
+	Position    *vec2.T
+	Radius      float64
+	OnCollision *Signal[Node]
+	DebugMode   bool
+}
+
+func NewCircleCollider(name string, position *vec2.T, radius float64) *CircleCollider {
+	collider := &CircleCollider{
+		BaseNode:    *NewNode(name),
+		Position:    position,
+		Radius:      radius,
+		OnCollision: NewSignal[Node](),
+	}
+	collider.AddTag("Collider")
+	return collider
+}
+
+func (c *CircleCollider) Update() error {
+	if err := c.BaseNode.Update(); err != nil {
+		return err
+	}
+
+	if ebiten.IsKeyPressed(ebiten.KeyF10) {
+		c.DebugMode = true
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyControl) && ebiten.IsKeyPressed(ebiten.KeyF10) {
+		c.DebugMode = false
+	}
+
+	return nil
+}
+
+func (c *CircleCollider) Draw(screen *ebiten.Image) {
+	c.BaseNode.Draw(screen)
+
+	if c.DebugMode {
+		vector.StrokeCircle(
+			screen,
+			float32(c.Position.X+c.Radius),
+			float32(c.Position.Y+c.Radius),
+			float32(c.Radius),
+			1,
+			color.White,
+			false,
+		)
+	}
+}
+
+func (c *CircleCollider) CollidesWithCircle(other *CircleCollider) bool {
+	// Calculate distance between centers
+	dx := c.Position.X + c.Radius - (other.Position.X + other.Radius)
+	dy := c.Position.Y + c.Radius - (other.Position.Y + other.Radius)
+	distance := math.Sqrt(dx*dx + dy*dy)
+
+	// If distance is less than sum of radii, they are colliding
+	return distance < (c.Radius + other.Radius)
+}
+
+func (c *CircleCollider) CollidesWithAABB(other *AABBCollider) bool {
+	return other.CollidesWithCircle(c)
+}

cmd/adventure/README.md

@@ -0,0 +1,49 @@
+# Adventure
+
+## Overview
+
+
+
+## Mechanics
+
+### Enemies
+
+#### Rare
+
+Glow - itself is strong, should be focus target.
+Name should reflect their additional properties.
+
+#### Elite
+
+Aura - buffs nearby enemies, should focus minions first.
+Name should reflect their aura properties.
+
+### Exploration
+
+Best items and discoveries should be off the main path.
+
+Teach player early that exploration is optional, but provides huge upsides.
+
+#### Light
+
+No light, no visibility.
+This is something a character has to figure out before entering a dungeon.
+Ring with light, or a torch, or a lamp, or a spell, ...
+
+### Auto Loot Feature
+
+Consider characters attributes when picking up items.
+In multi-character party do a priority consideration of:
++ attributes
++ distance to item
++ inventory space
+
+### Inventory
+
+Space-based vs. weight-based.
+
+Space-based inventory, where backpacks and pouches are different containers with
+requirements such as strength, or a mage pouch that requires intelligence.
+
+Interesting item sizes, e.g., 1x6 staff, 3x3 shield, ... could reflect the
+characteristics of the specific containers: backpacks, pouches, etc.

cmd/gestrandet/assets/img/enemy.png

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"engine"
+	"engine/vec2"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+type Enemy struct {
+	*engine.Entity
+}
+
+func NewEnemy() *Enemy {
+	enemy := &Enemy{Entity: engine.NewEntity()}
+
+	image := assetLoader.LoadImage("assets/img/enemy.png")
+	enemy.Image = image
+	enemy.ImageScale = 0.5
+	enemy.Position = &vec2.T{X: 900, Y: 700}
+	enemy.HitboxSize = &vec2.T{X: 64, Y: 64}
+	enemy.HitboxOffset = &vec2.T{X: 0, Y: 0}
+
+	return enemy
+}
+
+func (e *Enemy) Update() error {
+	return nil
+}
+
+func (e *Enemy) Draw(screen *ebiten.Image) {
+	e.Entity.Draw(screen)
+}

cmd/gestrandet/enemy.go

@@ -15,6 +15,7 @@ type Gestrandet struct {
 	m        *Map
 	gameOver bool
 	player   *Player
+	enemy    *Enemy
 	world    *ebiten.Image
 	camera   *engine.Camera
 }
@@ -24,6 +25,7 @@ func (si *Gestrandet) Update() error {
 		return fmt.Errorf("Game Over")
 	}
 	si.player.Update()
+	si.enemy.Update()
 	si.camera.FocusOn(si.player.Center())
 
 	if ebiten.IsKeyPressed(ebiten.KeyL) {
@@ -50,9 +52,10 @@ func (si *Gestrandet) Update() error {
 func (si *Gestrandet) Draw(screen *ebiten.Image) {
 	si.m.Draw(si.world)
 	si.player.Draw(si.world)
+	si.enemy.Draw(si.world)
 	si.camera.Render(si.world, screen)
 
-	ebitenutil.DebugPrint(screen, fmt.Sprintf("TPS: %v, FPS: %v", ebiten.CurrentTPS(), ebiten.CurrentFPS()))
+	ebitenutil.DebugPrint(screen, fmt.Sprintf("TPS: %v, FPS: %v", ebiten.ActualTPS(), ebiten.ActualFPS()))
 	ebitenutil.DebugPrintAt(screen, si.camera.String(), 0, 20)
 	mouseInfo := fmt.Sprintf(
 		"OnScreen: %v, World: %v",
@@ -72,6 +75,7 @@ func NewGestrandet() *Gestrandet {
 		m:        NewMap(),
 		gameOver: false,
 		player:   NewPlayer(),
+		enemy:    NewEnemy(),
 	}
 	gestrandet.camera = engine.NewCamera(vec2.NewI(gestrandet.Layout(0, 0)).AsT())
 	gestrandet.world = gestrandet.m.mapLoader.Generate()

cmd/gestrandet/gestrandet.go

@@ -29,7 +29,7 @@ func newEnemy1Animation() *engine.Animation {
 		assetLoader.LoadImage("assets/img/spritemap.png"),
 		vec2.I{X: 64, Y: 48},
 		[]vec2.I{{X: 0, Y: 0}, {X: 1, Y: 0}},
-		[]time.Duration{time.Millisecond * 500, time.Millisecond * 500},
+		engine.UniformDuration(time.Millisecond*500, 2),
 	)
 }
 
@@ -38,7 +38,7 @@ func newEnemy2Animation() *engine.Animation {
 		assetLoader.LoadImage("assets/img/spritemap.png"),
 		vec2.I{X: 64, Y: 48},
 		[]vec2.I{{X: 3, Y: 0}, {X: 2, Y: 0}},
-		[]time.Duration{time.Millisecond * 500, time.Millisecond * 500},
+		engine.UniformDuration(time.Millisecond*500, 2),
 	)
 }
 
@@ -60,7 +60,11 @@ func NewEnemy(position *vec2.T, enemyType EnemyType) *Enemy {
 
 	enemy.Image = enemy.animation.CurrentImage()
 	enemy.Position = position
-	enemy.HitboxSize = vec2.NewI(enemy.Image.Size()).AsT()
+	enemy.HitboxSize = vec2.NewI(
+		enemy.Image.Bounds().Size().X,
+		enemy.Image.Bounds().Size().Y,
+	).AsT()
+
 	return enemy
 }