refactor: Use standard geom

3 files changed, 23 insertions, 33 deletions

diff --git a/geometry.go b/geometry.go
index 1398f00..89eb1ed 100644
--- a/geometry.go
+++ b/geometry.go
@@ -1,14 +1,6 @@
 package main
 
-type Vec struct {
-	X, Y float64
-}
+import "image"
 
-type Rectangle struct {
-	leftTop     Vec
-	rightBottom Vec
-}
-
-func (r Rectangle) Contains(point Vec) bool {
-	return point.X > r.leftTop.X && point.X < r.rightBottom.X && point.Y > r.leftTop.Y && point.Y < r.rightBottom.Y
-}
+type Rectangle = image.Rectangle
+type Point = image.Point
diff --git a/main.go b/main.go
index f2b6c64..49e9d02 100644
--- a/main.go
+++ b/main.go
@@ -10,25 +10,18 @@ import (
 
 type Tile struct {
 	*ebiten.Image
-	Size     Vec
-	Position Vec
+	Size     Point
+	Position Point
 }
 
-func NewTile(size Vec, position Vec, color color.Color) Tile {
+func NewTile(size Point, position Point, color color.Color) Tile {
 	image := ebiten.NewImage(int(size.X), int(size.Y))
 	image.Fill(color)
 	return Tile{Size: size, Position: position, Image: image}
 }
 
 var soilColor = color.RGBA{0x60, 0x40, 0x20, 0xff}
-var soil = NewTile(Vec{X: 280, Y: 200}, Vec{X: 20, Y: 20}, soilColor)
-
-func GetDrawImageOptions(size Vec, position Vec) *ebiten.DrawImageOptions {
-	op := &ebiten.DrawImageOptions{}
-	op.GeoM.Translate(position.X-size.X/2, position.Y-size.Y/2)
-
-	return op
-}
+var soil = NewTile(Point{280, 200}, Point{20, 20}, soilColor)
 
 type Game struct {
 	Persons []*Person
@@ -37,12 +30,12 @@ type Game struct {
 func (g *Game) Update() error {
 	if inpututil.IsMouseButtonJustReleased(ebiten.MouseButtonLeft) {
 		x, y := ebiten.CursorPosition()
-		tileClick := Vec{X: float64(x) - soil.Position.X, Y: float64(y) - soil.Position.Y}
+		tileClick := Point{x - soil.Position.X, y - soil.Position.Y}
 		fmt.Println("Click: ", tileClick)
 		for _, p := range g.Persons {
 			p.IsSelected = false
 			fmt.Println("Person: ", p.Position)
-			if p.Bounds().Contains(tileClick) {
+			if tileClick.In(p.CollisionBounds()) {
 				fmt.Println("Person selected")
 				p.IsSelected = true
 			}
@@ -58,12 +51,14 @@ func (g *Game) Draw(screen *ebiten.Image) {
 	soil.Fill(soilColor)
 	for _, p := range g.Persons {
 		bounds := p.Image().Bounds()
+		fmt.Println("Person bounds: ", bounds)
 		op := &ebiten.DrawImageOptions{}
-		op.GeoM.Translate(p.Position.X-float64(bounds.Dx())/2, p.Position.Y-float64(bounds.Dy())/2)
+		op.GeoM.Translate(float64(p.Position.X-bounds.Dx()/2), float64(p.Position.Y-bounds.Dy()/2))
+		fmt.Println("Person position:", p.Position, "Draw geom: ", op.GeoM)
 		soil.DrawImage(p.Image(), op)
 	}
 	op := &ebiten.DrawImageOptions{}
-	op.GeoM.Translate(soil.Position.X, soil.Position.Y)
+	op.GeoM.Translate(float64(soil.Position.X), float64(soil.Position.Y))
 	screen.DrawImage(soil.Image, op)
 }
 
@@ -75,7 +70,7 @@ func main() {
 	ebiten.SetWindowSize(1280, 960)
 	ebiten.SetWindowTitle("Age of Empire")
 	game := &Game{}
-	mainPerson := NewPerson(Vec{float64(soil.Image.Bounds().Dx()) / 2, float64(soil.Image.Bounds().Dy()) / 2})
+	mainPerson := NewPerson(Point{soil.Image.Bounds().Dx() / 2, soil.Image.Bounds().Dy() / 2})
 	game.Persons = append(game.Persons, &mainPerson)
 	if err := ebiten.RunGame(game); err != nil {
 		panic(err)
diff --git a/person.go b/person.go
index 1c316e7..0bf0992 100644
--- a/person.go
+++ b/person.go
@@ -7,14 +7,14 @@ import (
 )
 
 type Person struct {
-	size          Vec
-	Position      Vec
+	size          Point
+	Position      Point
 	IsSelected    bool
 	image         *ebiten.Image
 	selectedImage *ebiten.Image
 }
 
-func NewPerson(position Vec) Person {
+func NewPerson(position Point) Person {
 	image := ebiten.NewImage(10, 10)
 	image.Fill(color.RGBA{0xff, 0xff, 0xff, 0xff})
 	selectedImage := ebiten.NewImage(12, 12)
@@ -22,7 +22,7 @@ func NewPerson(position Vec) Person {
 	op.GeoM.Translate(1, 1)
 	selectedImage.Fill(color.RGBA{0xff, 0x00, 0x00, 0xff})
 	selectedImage.DrawImage(image, op)
-	return Person{Position: position, size: Vec{X: 10, Y: 10}, image: image, selectedImage: selectedImage}
+	return Person{Position: position, size: Point{10, 10}, image: image, selectedImage: selectedImage}
 }
 
 func (p Person) Image() *ebiten.Image {
@@ -32,6 +32,9 @@ func (p Person) Image() *ebiten.Image {
 	return p.image
 }
 
-func (p Person) Bounds() Rectangle {
-	return Rectangle{Vec{p.Position.X - p.size.X/2, p.Position.Y - p.size.Y/2}, Vec{p.Position.X + p.size.X/2, p.Position.Y + p.size.Y/2}}
+func (p Person) CollisionBounds() Rectangle {
+	return Rectangle{
+		p.Position.Sub(p.size.Div(2)),
+		p.Position.Add(p.size.Div(2)),
+	}
 }