Cleanup, new alternating pulse mechanic.

game.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"image/color"
 	"log"
 	"math"
@@ -47,12 +46,6 @@ func (g *Game) Initialize() {
 	g.collisionMask = ebiten.NewImage(screenWidth, screenHeight)
 	g.projectileMask = ebiten.NewImage(screenWidth, screenHeight)
 
-	/* single target
-	g.target = NewMover()
-	g.target.SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
-	*/
-	//g.projectiles = append(g.projectiles, NewProjectile(Coordinates{X: 640 / 2, Y: 480 / 2}, 0., 5.))
-
 	g.explosion = NewExplosion()
 	g.explosion.SetOrigin(origin)
 
@@ -93,146 +86,7 @@ func (g *Game) Update() error {
 		g.projectiles = make(map[int]*Projectile)
 		g.initialized = true
 	} else {
-
+		g.StepGame()
-		if len(g.gamepadIDs) > 0 {
-			xaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickHorizontal)
-			yaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickVertical)
-
-			maxButton := ebiten.GamepadButton(ebiten.GamepadButtonCount(0))
-			for b := ebiten.GamepadButton(0); b < maxButton; b++ {
-				if ebiten.IsGamepadButtonPressed(0, ebiten.GamepadButton7) {
-					if !g.explosion.Active {
-						g.explosion.SetOrigin(g.mover.Pos)
-						g.explosion.Reset()
-						g.explosion.ToggleActivate()
-					}
-				}
-			}
-
-			if yaxis <= 0.09 && yaxis >= -0.09 {
-				yaxis = 0
-			}
-			if xaxis <= 0.09 && xaxis >= -0.09 {
-				xaxis = 0
-			}
-
-			inputangle := math.Atan2(yaxis, xaxis)
-			g.mover.SetAngle(inputangle)
-		}
-		/*
-			for id := range g.gamepadIDs {
-				xaxis := ebiten.StandardGamepadAxisValue(id, ebiten.StandardGamepadAxisRightStickHorizontal)
-				yaxis := ebiten.StandardGamepadAxisValue(id, ebiten.StandardGamepadAxisRightStickVertical)
-
-				inputangle := math.Atan2(yaxis, xaxis)
-				g.mover.SetAngle(inputangle)
-			}
-		*/
-
-		g.mover.Update()
-		g.explosion.Update()
-
-		for _, target := range g.targets {
-
-			if !target.Hit {
-				dx := g.mover.Pos.X - target.Pos.X
-				dy := g.mover.Pos.Y - target.Pos.Y
-
-				//dist := math.Sqrt(dx*dx + dy + dy)
-				angle := math.Atan2(dy, dx)
-
-				maxspeed := 3.
-				target.Pos.X += maxspeed * math.Cos(angle)
-				target.Pos.Y += maxspeed * math.Sin(angle)
-			}
-
-			target.Update()
-		}
-
-		for k, p := range g.projectiles {
-
-			//for i := 0; i < len(g.projectiles); i++ {
-			//	g.projectiles[i].Update()
-			p.Update()
-
-			//if g.projectiles[i].Pos.X < 5 || g.projectiles[i].Pos.X > 635 || g.projectiles[i].Pos.Y < 5 || g.projectiles[i].Pos.Y > 475 {
-			if p.Pos.X < 5 || p.Pos.X > 635 || p.Pos.Y < 5 || p.Pos.Y > 475 {
-				p.Velocity = 0
-				delete(g.projectiles, k)
-			}
-
-			//compute collisions
-			for _, target := range g.targets {
-				//first, boundary check
-				if p.Pos.X >= target.Pos.X-MOVER_WIDTH/2 && p.Pos.X <= target.Pos.X+MOVER_WIDTH/2 && p.Pos.Y >= target.Pos.Y-MOVER_HEIGHT/2 && p.Pos.Y <= target.Pos.Y+MOVER_HEIGHT/2 && target.Action == MoverActionDamaged {
-					fmt.Println("potential collision")
-
-					g.collisionMask.Clear()
-					g.collisionMask.DrawImage(g.projectileMask, nil)
-
-					op := &ebiten.DrawImageOptions{}
-					op.GeoM.Reset()
-					op.Blend = ebiten.BlendSourceIn
-					op.GeoM.Translate(target.Pos.X-MOVER_WIDTH/2, target.Pos.Y-MOVER_HEIGHT/2)
-					g.collisionMask.DrawImage(target.Sprite, op)
-
-					//var pixels []byte = make([]byte, MOVER_WIDTH*MOVER_HEIGHT*4)
-					var pixels []byte = make([]byte, screenWidth*screenHeight*4)
-					g.collisionMask.ReadPixels(pixels)
-					for i := 0; i < len(pixels); i = i + 4 {
-						if pixels[i+3] != 0 {
-							fmt.Println("pixel collision")
-							delete(g.projectiles, k)
-							//target.ToggleColor()
-							target.SetHit()
-							//target.SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
-							target.Hit = true
-							break
-						}
-					}
-				}
-			}
-		}
-
-		//append new projectiles
-		if g.counter%14 == 0 {
-			//g.projectiles = append(g.projectiles, NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle, 5.))
-			//g.projectiles = append(g.projectiles, NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle+math.Pi, 5.))
-
-			g.projectiles[g.counter] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle, 5.)
-			g.projectiles[g.counter+1] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle+math.Pi, 5.)
-		}
-
-		//add new target with increasing frequency
-
-		f := 40000 / (g.counter + 1)
-
-		if g.counter%f == 0 {
-			g.targets = append(g.targets, NewMover())
-			g.targets[len(g.targets)-1].SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
-		}
-
-		//handle explosion updates
-		if g.explosion.Active {
-			if g.explosion.Radius > math.Sqrt(640*640+480*480) {
-				g.explosion.ToggleActivate()
-				g.explosion.Reset()
-			}
-
-			//check collisions
-			for _, target := range g.targets {
-				dx := target.Pos.X - g.mover.Pos.X
-				dy := target.Pos.Y - g.mover.Pos.Y
-				r := math.Sqrt(dx*dx + dy*dy)
-
-				if r >= g.explosion.Radius-5 && r <= g.explosion.Radius+5 && target.Action <= MoverActionDefault {
-					//target.ToggleColor()
-					target.SetHit()
-				}
-			}
-		}
-
-		g.counter++
 	}
 
 	g.CleanupTargets()
@@ -298,11 +152,171 @@ func (g *Game) CleanupTargets() {
 		}
 	}
 	//then culling the last elements of the slice
-	if len(g.targets)-i > 0 {
+	/*if len(g.targets)-i > 0 {
 		fmt.Printf("Removing %d elements\n", len(g.targets)-i)
-	}
+	}*/
 	for j := i; j < len(g.targets); j++ {
 		g.targets[j] = nil
 	}
 	g.targets = g.targets[:i]
 }
+
+func (g *Game) StepGame() {
+
+	g.HandleInput()
+
+	g.mover.Update()
+	g.explosion.Update()
+
+	g.UpdateTargets()
+	g.UpdateProjectiles()
+
+	//append new projectiles
+	g.AppendProjectiles()
+
+	//add new target with increasing frequency
+	g.AddNewTargets()
+
+	//handle pulsewave updates
+	g.HandlePulseWaveUpdate()
+
+	g.counter++
+}
+
+func (g *Game) AddNewTargets() {
+	f := 40000 / (g.counter + 1)
+	if g.counter%f == 0 {
+		g.targets = append(g.targets, NewMover())
+		g.targets[len(g.targets)-1].SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
+	}
+}
+
+func (g *Game) HandlePulseWaveUpdate() {
+	if g.explosion.Active {
+		if g.explosion.Radius > math.Sqrt(640*640+480*480) {
+			g.explosion.ToggleActivate()
+			g.explosion.Reset()
+			g.ResetTargetTouches()
+		}
+
+		//check collisions
+		for _, target := range g.targets {
+			dx := target.Pos.X - g.mover.Pos.X
+			dy := target.Pos.Y - g.mover.Pos.Y
+			r := math.Sqrt(dx*dx + dy*dy)
+
+			if r >= g.explosion.Radius-5 && r <= g.explosion.Radius+5 && target.Action <= MoverActionDamaged && !target.Touched {
+				target.ToggleColor()
+				target.Touched = true
+				//target.SetHit()
+			}
+		}
+	}
+}
+
+func (g *Game) UpdateProjectiles() {
+	for k, p := range g.projectiles {
+
+		//for i := 0; i < len(g.projectiles); i++ {
+		//	g.projectiles[i].Update()
+		p.Update()
+
+		//if g.projectiles[i].Pos.X < 5 || g.projectiles[i].Pos.X > 635 || g.projectiles[i].Pos.Y < 5 || g.projectiles[i].Pos.Y > 475 {
+		if p.Pos.X < 5 || p.Pos.X > 635 || p.Pos.Y < 5 || p.Pos.Y > 475 {
+			p.Velocity = 0
+			delete(g.projectiles, k)
+		}
+
+		//compute projectile collisions
+		for _, target := range g.targets {
+			//first, boundary check
+			if p.Pos.X >= target.Pos.X-MOVER_WIDTH/2 && p.Pos.X <= target.Pos.X+MOVER_WIDTH/2 && p.Pos.Y >= target.Pos.Y-MOVER_HEIGHT/2 && p.Pos.Y <= target.Pos.Y+MOVER_HEIGHT/2 && target.Action == MoverActionDamaged {
+				//fmt.Println("potential collision")
+
+				g.collisionMask.Clear()
+				g.collisionMask.DrawImage(g.projectileMask, nil)
+
+				op := &ebiten.DrawImageOptions{}
+				op.GeoM.Reset()
+				op.Blend = ebiten.BlendSourceIn
+				op.GeoM.Translate(target.Pos.X-MOVER_WIDTH/2, target.Pos.Y-MOVER_HEIGHT/2)
+				g.collisionMask.DrawImage(target.Sprite, op)
+
+				//var pixels []byte = make([]byte, MOVER_WIDTH*MOVER_HEIGHT*4)
+				var pixels []byte = make([]byte, screenWidth*screenHeight*4)
+				g.collisionMask.ReadPixels(pixels)
+				for i := 0; i < len(pixels); i = i + 4 {
+					if pixels[i+3] != 0 {
+						//fmt.Println("pixel collision")
+						delete(g.projectiles, k)
+						//target.ToggleColor()
+						target.SetHit()
+						//target.SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
+						target.Hit = true
+						break
+					}
+				}
+			}
+		}
+	}
+}
+
+func (g *Game) UpdateTargets() {
+	for _, target := range g.targets {
+
+		if !target.Hit {
+			dx := g.mover.Pos.X - target.Pos.X
+			dy := g.mover.Pos.Y - target.Pos.Y
+			angle := math.Atan2(dy, dx)
+
+			maxspeed := 3.
+			target.Pos.X += maxspeed * math.Cos(angle)
+			target.Pos.Y += maxspeed * math.Sin(angle)
+		}
+
+		target.Update()
+	}
+}
+
+func (g *Game) ResetTargetTouches() {
+	for _, t := range g.targets {
+		t.Touched = false
+	}
+}
+
+func (g *Game) AppendProjectiles() {
+	if g.counter%14 == 0 && ebiten.IsGamepadButtonPressed(0, ebiten.GamepadButton7) {
+
+		g.projectiles[g.counter] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle, 5.)
+		g.projectiles[g.counter+1] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle+math.Pi, 5.)
+	}
+}
+
+func (g *Game) HandleInput() {
+	if len(g.gamepadIDs) > 0 {
+		maxButton := ebiten.GamepadButton(ebiten.GamepadButtonCount(0))
+		for b := ebiten.GamepadButton(0); b < maxButton; b++ {
+			if ebiten.IsGamepadButtonPressed(0, ebiten.GamepadButton11) {
+				if !g.explosion.Active {
+					g.explosion.SetOrigin(g.mover.Pos)
+					g.explosion.Reset()
+					g.explosion.ToggleActivate()
+				}
+			}
+		}
+
+		//account for controller sensitivity
+		xaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickHorizontal)
+		yaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickVertical)
+
+		if yaxis <= 0.09 && yaxis >= -0.09 {
+			yaxis = 0
+		}
+		if xaxis <= 0.09 && xaxis >= -0.09 {
+			xaxis = 0
+		}
+
+		inputangle := math.Atan2(yaxis, xaxis)
+		g.mover.SetAngle(inputangle)
+	}
+}

mover.go

@@ -68,6 +68,7 @@ type Mover struct {
 	rotating   bool
 	Toggled    bool
 	Hit        bool
+	Touched    bool
 	dyingcount int
 }
 
@@ -164,5 +165,10 @@ func (m *Mover) SetHit() {
 }
 
 func (m *Mover) ToggleColor() {
-	m.Toggled = !m.Toggled
+	//m.Toggled = !m.Toggled
+	if m.Action == MoverActionDefault {
+		m.Action = MoverActionDamaged
+	} else if m.Action == MoverActionDamaged {
+		m.Action = MoverActionDefault
+	}
 }