Fix IA weights modifications and New IA Hard Game

Author: andersondalmina

.DS_Store

@@ -1 +1,2 @@
 flappy-bird-neural-network
+.vscode

.gitignore

@@ -1 +1,5 @@
-#flappy-bird-neural-network WIP
+# Flappy Bird Neural Network
+
+![Menu](screenshot.png)
+
+![Game](screenshot1.png)

README.md

@@ -2,39 +2,47 @@ package components
 
 import (
 	"math"
+	"time"
 
 	"github.com/faiface/pixel"
 	"github.com/faiface/pixel/pixelgl"
 )
 
+// BirdHeight is the height of the bird sprite
 const BirdHeight = 46
+
+// BirdWidth is the width of the bird sprite
 const BirdWidth = 54
-const gravity = 20.0
+
+// BirdX is the inicial position X of the bird
 const BirdX = WindowWidth/2 - WindowWidth*0.2
+const gravity = 20.0
 
-var maxSpeed = gravity / 5
+var maxSpeed = gravity / 4
 
 // Bird component
 type Bird struct {
-	x      float64
-	y      float64
-	speed  float64
-	sprite *pixel.Sprite
-	points int64
-	death  bool
-	enable bool
+	x           float64
+	y           float64
+	speed       float64
+	sprite      *pixel.Sprite
+	points      int64
+	death       bool
+	enableGhost bool
+	ghost       bool
 }
 
 // NewBird creates a new bird component
 func NewBird(x float64, sprite *pixel.Sprite) *Bird {
 	return &Bird{
-		x:      x,
-		y:      WindowHeight / 2,
-		speed:  2,
-		sprite: sprite,
-		points: 0,
-		death:  false,
-		enable: true,
+		x:           x,
+		y:           WindowHeight / 2,
+		speed:       2,
+		sprite:      sprite,
+		points:      0,
+		death:       false,
+		enableGhost: true,
+		ghost:       false,
 	}
 }
 
@@ -50,10 +58,6 @@ func (b *Bird) GetPoints() int64 {
 	return b.points
 }
 
-func (b *Bird) Enable() {
-	b.enable = true
-}
-
 func (b *Bird) IsDeath() bool {
 	return b.death
 }
@@ -63,50 +67,33 @@ func (b *Bird) Death() {
 }
 
 func (b *Bird) Update() {
-	if b.death == true || b.enable == true {
-		if b.speed < maxSpeed {
-			b.speed += gravity * Delta
-		}
+	if b.speed < maxSpeed {
+		b.speed += gravity * Delta
 	}
 
 	if b.death == true {
 		b.x -= XSpeed * Delta
+
 		if b.y > 80 {
 			b.y -= b.speed
 		}
-	} else {
-		if b.enable && b.y > 80 {
-			b.y -= b.speed
-		} else {
-			if b.y >= WindowHeight/2+20 {
-				b.speed = 2
-			} else if b.y < WindowHeight/2-20 {
-				b.speed = -2
-			}
 
-			b.y -= b.speed
-		}
+		return
 	}
-}
-
-func (b *Bird) Draw(win *pixelgl.Window) error {
-	mat := pixel.IM
 
-	if b.enable && b.speed > 0 {
-		if b.speed > -5 && b.speed < 3 {
-			mat = mat.Rotated(pixel.V(0, 0), b.speed*-15*math.Pi/180)
-		} else {
-			mat = mat.Rotated(pixel.V(0, 0), -45*math.Pi/180)
-		}
-	} else if b.enable == false {
-		mat = mat.Rotated(pixel.V(0, 0), -18*math.Pi/180)
-	}
+	b.y -= b.speed
+}
 
+func (b *Bird) Draw(win *pixelgl.Window) {
+	mat := pixel.IM.Rotated(pixel.V(0, 0), Min(15*math.Pi/180, b.speed*-8*math.Pi/180))
 	mat = mat.Moved(pixel.V(b.x, b.y))
 
-	b.sprite.Draw(win, mat)
+	sprite := b.sprite
+	if b.ghost {
+		sprite = Sprites["bird16"]
+	}
 
-	return nil
+	sprite.Draw(win, mat)
 }
 
 func (b *Bird) Jump() {
@@ -116,3 +103,26 @@ func (b *Bird) Jump() {
 func (b *Bird) IncreasePoint() {
 	b.points++
 }
+
+func (b *Bird) Ghost() bool {
+	return b.ghost
+}
+
+func (b *Bird) IsEnableGhost() bool {
+	return b.enableGhost
+}
+
+func (b *Bird) UseGhost() {
+	if b.enableGhost {
+		b.ghost = true
+		b.enableGhost = false
+
+		time.AfterFunc(2*time.Second, func() {
+			b.ghost = false
+		})
+
+		time.AfterFunc(7*time.Second, func() {
+			b.enableGhost = true
+		})
+	}
+}

assets/.DS_Store

@@ -0,0 +1,43 @@
+package components
+
+import (
+	"github.com/andersondalmina/flappy-bird-neural-network/neuralnetwork"
+)
+
+// Individual component
+type Individual struct {
+	bird   *Bird
+	neural *neuralnetwork.NeuralNetwork
+	inputs []float64
+}
+
+// NewIndividual create a new individual
+func NewIndividual(b *Bird, n *neuralnetwork.NeuralNetwork) *Individual {
+	i := Individual{
+		bird:   b,
+		neural: n,
+		inputs: make([]float64, 2),
+	}
+
+	return &i
+}
+
+// Bird return the individual bird
+func (i *Individual) Bird() *Bird {
+	return i.bird
+}
+
+// Inputs return the inputs
+func (i *Individual) Inputs() []float64 {
+	return i.inputs
+}
+
+// SetInputs set the inputs
+func (i *Individual) SetInputs(inputs []float64) {
+	i.inputs = inputs
+}
+
+// Neural return the neural
+func (i *Individual) Neural() *neuralnetwork.NeuralNetwork {
+	return i.neural
+}

assets/bird16.png

@@ -2,21 +2,39 @@ package components
 
 import (
 	"math"
+	"math/rand"
 
 	"github.com/faiface/pixel"
 	"github.com/faiface/pixel/pixelgl"
 )
 
+// PipeHeight is the width of the pipe sprite
 const PipeHeight = 40.0
 
-// Pipe component
+// PipeWidth is the width of the pipe sprite
+const PipeWidth = 86.0
+
+// Obstacle component interface
+type Obstacle interface {
+	GetX() float64
+	GetY() float64
+	Draw(win *pixelgl.Window)
+	Update()
+	IsDefeated() bool
+	Defeat()
+	CheckCrash(b Bird) bool
+	GetType() float64
+}
+
+// Pipe type of obstacle
 type Pipe struct {
 	x          float64
 	y          float64
 	defeated   bool
 	speed      float64
 	spriteUp   *pixel.Sprite
 	spriteDown *pixel.Sprite
+	direction  int
 }
 
 // NewPipe creates a new pipe component
@@ -28,26 +46,37 @@ func NewPipe(x float64, y float64) *Pipe {
 		speed:      0,
 		spriteUp:   Sprites["pipeUp"],
 		spriteDown: Sprites["pipeDown"],
+		direction:  rand.Intn(1),
 	}
 }
 
-func (b *Pipe) GetX() float64 {
-	return b.x
+// GetType return the type of obstacle
+func (p *Pipe) GetType() float64 {
+	return 1
 }
 
-func (b *Pipe) GetY() float64 {
-	return b.y
+// GetX return X position
+func (p *Pipe) GetX() float64 {
+	return p.x
 }
 
-func (b *Pipe) IsDefeated() bool {
-	return b.defeated
+// GetY return Y position
+func (p *Pipe) GetY() float64 {
+	return p.y
 }
 
-func (b *Pipe) Defeat() {
-	b.defeated = true
+// IsDefeated return if the wall is defeat
+func (p *Pipe) IsDefeated() bool {
+	return p.defeated
 }
 
-func (p *Pipe) Draw(win *pixelgl.Window) error {
+// Defeat mask this wall as defeat
+func (p *Pipe) Defeat() {
+	p.defeated = true
+}
+
+// Draw the wall on window
+func (p *Pipe) Draw(win *pixelgl.Window) {
 	// Draw down part of pipe
 	p.spriteUp.Draw(win, pixel.IM.Moved(pixel.V(p.x, p.y-100)))
 	for i := p.y - 100 - PipeHeight; i > 0; i -= PipeHeight {
@@ -61,6 +90,30 @@ func (p *Pipe) Draw(win *pixelgl.Window) error {
 	}
 
 	p.x -= XSpeed * Delta
+}
+
+// Update the pipe
+func (p *Pipe) Update() {
+	if p.direction == 1 {
+		p.y++
+	} else {
+		p.y--
+	}
+
+	if p.y > WindowHeight-150 {
+		p.direction = 0
+	} else if p.y < 200 {
+		p.direction = 1
+	}
+}
+
+// CheckCrash check if a bird crash on the pipe
+func (p *Pipe) CheckCrash(b Bird) bool {
+	if b.GetX() >= p.GetX()-50 && b.GetX() <= p.GetX()+50 {
+		if b.GetY() <= (p.GetY()-55) || b.GetY() >= (p.GetY()+55) {
+			return true
+		}
+	}
 
-	return nil
+	return false
 }

assets/wall.png

@@ -1,4 +1,4 @@
-package neuralnetwork
+package components
 
 // Number of individuals of each population
 const iNum = 100

components/bird.go

@@ -61,6 +61,12 @@ func loadSprites() map[string]*pixel.Sprite {
 	}
 	result["bird15"] = pixel.NewSprite(picBird, picBird.Bounds())
 
+	picBird, err = loadPicture("./assets/bird16.png")
+	if err != nil {
+		panic(err)
+	}
+	result["bird16"] = pixel.NewSprite(picBird, picBird.Bounds())
+
 	picUp, err := loadPicture("./assets/pipeup.png")
 	if err != nil {
 		panic(err)
@@ -73,6 +79,12 @@ func loadSprites() map[string]*pixel.Sprite {
 	}
 	result["pipeDown"] = pixel.NewSprite(picDown, picDown.Bounds())
 
+	pic, err := loadPicture("./assets/wall.png")
+	if err != nil {
+		panic(err)
+	}
+	result["wall"] = pixel.NewSprite(pic, pic.Bounds())
+
 	return result
 }
 

components/individual.go

@@ -13,18 +13,21 @@ import (
 	"golang.org/x/image/font"
 )
 
+// Text component
 type Text struct {
 	txt   string
 	color color.RGBA
 }
 
+// CreateTextLine create a net text component
 func CreateTextLine(txt string, color color.RGBA) Text {
 	return Text{
 		txt:   txt,
 		color: color,
 	}
 }
 
+// WriteText draw the text on the window
 func WriteText(txt []Text, color color.RGBA, win *pixelgl.Window, mat pixel.Matrix) {
 	face, err := loadTTF("./assets/font.ttf", 14)
 	if err != nil {