Fixes on scene IA HARD and persisting training data

Author: andersondalmina

components/bird.go

@@ -16,113 +16,93 @@ const BirdWidth = 54
 
 // BirdX is the inicial position X of the bird
 const BirdX = WindowWidth/2 - WindowWidth*0.2
-const gravity = 20.0
 
-var maxSpeed = gravity / 4
+const ghostCountdown = 1300
+
+var gravity = 20.0
+var maxSpeed = gravity * 30
 
 // Bird component
 type Bird struct {
-	x           float64
-	y           float64
-	speed       float64
-	sprite      *pixel.Sprite
-	points      int64
-	death       bool
-	enableGhost bool
-	ghost       bool
+	X              float64
+	Y              float64
+	speed          float64
+	sprite         *pixel.Sprite
+	Points         int64
+	Dead           bool
+	Ghost          bool
+	GhostCountdown int
 }
 
 // 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,
-		enableGhost: true,
-		ghost:       false,
+		X:              x,
+		Y:              WindowHeight / 2,
+		speed:          0,
+		sprite:         sprite,
+		Points:         0,
+		Dead:           false,
+		Ghost:          false,
+		GhostCountdown: ghostCountdown,
 	}
 }
 
-func (b *Bird) GetX() float64 {
-	return b.x
-}
-
-func (b *Bird) GetY() float64 {
-	return b.y
-}
-
-func (b *Bird) GetPoints() int64 {
-	return b.points
-}
-
-func (b *Bird) IsDeath() bool {
-	return b.death
-}
-
-func (b *Bird) Death() {
-	b.death = true
+// Kill set bird as dead
+func (b *Bird) Kill() {
+	b.Dead = true
 }
 
+// Update run all operations on bird
 func (b *Bird) Update() {
-	if b.speed < maxSpeed {
-		b.speed += gravity * Delta
+	if b.GhostCountdown > 0 {
+		b.GhostCountdown--
 	}
 
-	if b.death == true {
-		b.x -= XSpeed * Delta
-
-		if b.y > 80 {
-			b.y -= b.speed
-		}
+	if b.speed < maxSpeed {
+		b.speed += gravity
+	}
 
-		return
+	if b.Dead {
+		b.X -= GameXSpeed * Delta
 	}
 
-	b.y -= b.speed
+	if b.Y > 80 || b.speed < 0 {
+		b.Y -= b.speed * Delta
+	}
 }
 
+// Draw the bird on window
 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))
+	mat := pixel.IM.Rotated(pixel.V(0, 0), Min(15*math.Pi/180, -b.speed/10*math.Pi/180))
+	mat = mat.Moved(pixel.V(b.X, b.Y))
 
 	sprite := b.sprite
-	if b.ghost {
+	if b.Ghost {
 		sprite = Sprites["bird16"]
 	}
 
 	sprite.Draw(win, mat)
 }
 
+// Jump change speed of bird to jump
 func (b *Bird) Jump() {
-	b.speed = -gravity * Delta * 23
+	b.speed = -gravity * 20
 }
 
+// IncreasePoint run all inscreases
 func (b *Bird) IncreasePoint() {
-	b.points++
-}
-
-func (b *Bird) Ghost() bool {
-	return b.ghost
-}
-
-func (b *Bird) IsEnableGhost() bool {
-	return b.enableGhost
+	b.Points++
 }
 
+// UseGhost enable ghost power on bird
 func (b *Bird) UseGhost() {
-	if b.enableGhost {
-		b.ghost = true
-		b.enableGhost = false
+	if b.GhostCountdown == 0 {
+		b.GhostCountdown = ghostCountdown
+		b.Ghost = true
 
 		time.AfterFunc(2*time.Second, func() {
-			b.ghost = false
-		})
-
-		time.AfterFunc(7*time.Second, func() {
-			b.enableGhost = true
+			b.Ghost = false
 		})
 	}
 }

components/pipe.go

@@ -22,8 +22,9 @@ type Obstacle interface {
 	Update()
 	IsDefeated() bool
 	Defeat()
-	CheckCrash(b Bird) bool
+	CheckCrash(x, y float64) bool
 	GetType() float64
+	GetWidth() float64
 }
 
 // Pipe type of obstacle
@@ -50,6 +51,11 @@ func NewPipe(x float64, y float64) *Pipe {
 	}
 }
 
+// GetWidth return the pipe width
+func (p *Pipe) GetWidth() float64 {
+	return PipeWidth
+}
+
 // GetType return the type of obstacle
 func (p *Pipe) GetType() float64 {
 	return 1
@@ -79,38 +85,38 @@ func (p *Pipe) Defeat() {
 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 {
+	for i := p.y - 100 - PipeHeight; i > 0; i -= PipeHeight - 1 {
 		p.spriteDown.Draw(win, pixel.IM.Moved(pixel.V(p.x, i)))
 	}
 
 	// Draw up part of pipe
 	p.spriteUp.Draw(win, pixel.IM.Rotated(pixel.V(0, 0), math.Pi).Moved(pixel.V(p.x, p.y+100)))
-	for i := p.y + 100 + PipeHeight; i < WindowHeight+PipeHeight; i += PipeHeight {
+	for i := p.y + 100 + PipeHeight; i < WindowHeight+PipeHeight; i += PipeHeight - 1 {
 		p.spriteDown.Draw(win, pixel.IM.Rotated(pixel.V(0, 0), math.Pi).Moved(pixel.V(p.x, i)))
 	}
 
-	p.x -= XSpeed * Delta
+	p.x -= GameXSpeed * Delta
 }
 
 // Update the pipe
 func (p *Pipe) Update() {
 	if p.direction == 1 {
-		p.y++
+		p.y += 0.5
 	} else {
-		p.y--
+		p.y -= 0.5
 	}
 
-	if p.y > WindowHeight-150 {
+	if p.y > WindowHeight-200 {
 		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) {
+// CheckCrash check if a position crash on pipe
+func (p *Pipe) CheckCrash(x, y float64) bool {
+	if x >= p.GetX()-PipeWidth/2 && x <= p.GetX()+PipeWidth/2 {
+		if y <= (p.GetY()-50) || y >= (p.GetY()+50) {
 			return true
 		}
 	}

components/population.go

@@ -35,6 +35,5 @@ func (p *Population) AddIndividual(i *Individual) {
 
 // RemoveIndividual remove an individual from the population
 func (p *Population) RemoveIndividual(i int) {
-	p.individuals[i] = p.individuals[len(p.individuals)-1]
-	p.individuals = p.individuals[:len(p.individuals)-1]
+	p.individuals = append(p.individuals[:i], p.individuals[i+1:]...)
 }

components/wall.go

@@ -23,6 +23,11 @@ func NewWall(x float64) *Wall {
 	}
 }
 
+// GetWidth return the wall width
+func (w *Wall) GetWidth() float64 {
+	return WallWidth
+}
+
 // GetType return the type of obstacle
 func (w *Wall) GetType() float64 {
 	return 2
@@ -56,17 +61,17 @@ func (w *Wall) Draw(win *pixelgl.Window) {
 		Sprites["wall"].Draw(win, pixel.IM.Moved(pixel.V(w.X, float64(i)*160)))
 	}
 
-	w.X -= XSpeed * Delta
+	w.X -= GameXSpeed * Delta
 }
 
 // Update do nothing
 func (w *Wall) Update() {
 
 }
 
-// CheckCrash check if a bird crash on the wall
-func (w *Wall) CheckCrash(b Bird) bool {
-	if b.GetX() >= w.X-WallWidth/2 && b.GetX() <= w.X+WallWidth/2 {
+// CheckCrash check if a position crash on the wall
+func (w *Wall) CheckCrash(x, y float64) bool {
+	if x >= w.X-WallWidth/2 && x <= w.X+WallWidth/2 {
 		return true
 	}
 

components/window.go

@@ -14,8 +14,8 @@ const WindowHeight = 720
 // Delta is to control FPS
 var Delta float64
 
-// XSpeed is the horizontal speed
-var XSpeed = 180.0
+// GameXSpeed is the horizontal speed
+var GameXSpeed = 180.0
 
 // CreateWindow creates a window
 func CreateWindow(t string) (*pixelgl.Window, error) {

neuralnetwork/layer.go

@@ -10,6 +10,7 @@ type Layer struct {
 	neurons []*Neuron
 }
 
+// NewLayer create a new layer
 func NewLayer(numberNeurons, numberInputs int64) *Layer {
 	neurons := make([]*Neuron, numberNeurons)
 	for i := range neurons {
@@ -21,10 +22,12 @@ func NewLayer(numberNeurons, numberInputs int64) *Layer {
 	}
 }
 
+// Neurons return all neurons of the layer
 func (l *Layer) Neurons() []*Neuron {
 	return l.neurons
 }
 
+// Run predicts all neurons
 func (l *Layer) Run(inputs []float64) []float64 {
 	r := make([]float64, len(l.neurons))
 	for i, n := range l.neurons {