Use float32 consistently for coordinates.

1 files changed, 28 insertions, 28 deletions

diff --git a/pongo.go b/pongo.go
index 70910ee..6ad7b07 100644
--- a/pongo.go
+++ b/pongo.go
@@ -19,16 +19,16 @@ const (
 	paddleSpeed = 5
 )
 
-func rectRight(r *sdl.Rect) int32 {
+func rectRight(r *sdl.FRect) float32 {
 	return r.X + r.W
 }
 
-func rectBottom(r *sdl.Rect) int32 {
+func rectBottom(r *sdl.FRect) float32 {
 	return r.Y + r.H
 }
 
 type vector2 struct {
-	x, y float64
+	x, y float32
 }
 
 func (v vector2) add(w vector2) vector2 {
@@ -40,17 +40,17 @@ type ball struct {
 	velocity vector2
 }
 
-func (b *ball) bounds() *sdl.Rect {
+func (b *ball) bounds() *sdl.FRect {
 	const ballSize = 30
-	return &sdl.Rect{
-		X: int32(b.pos.x - ballSize/2),
-		Y: int32(b.pos.y - ballSize/2),
+	return &sdl.FRect{
+		X: b.pos.x - ballSize/2,
+		Y: b.pos.y - ballSize/2,
 		W: ballSize,
 		H: ballSize,
 	}
 }
 
-func (b *ball) predictIntersection(targetX float64) (float64, bool) {
+func (b *ball) predictIntersection(targetX float32) (float32, bool) {
 	if b.velocity.x <= 0 {
 		return 0, false
 	}
@@ -62,16 +62,16 @@ func (b *ball) predictIntersection(targetX float64) (float64, bool) {
 	if prediction < 0 {
 		bounces := int(-prediction / screenHeight)
 		if bounces%2 == 0 {
-			return -prediction - float64(screenHeight*bounces), true
+			return -prediction - float32(screenHeight*bounces), true
 		}
-		return prediction + float64(screenHeight*(bounces+1)), true
+		return prediction + float32(screenHeight*(bounces+1)), true
 	}
 	if prediction > screenHeight {
 		bounces := int(prediction / screenHeight)
 		if bounces%2 == 0 {
-			return prediction - float64(screenHeight*bounces), true
+			return prediction - float32(screenHeight*bounces), true
 		}
-		return -prediction + float64(screenHeight*(bounces+1)), true
+		return -prediction + float32(screenHeight*(bounces+1)), true
 	}
 	return prediction, true
 }
@@ -92,19 +92,19 @@ func (b *ball) reset(side side) {
 }
 
 type paddle struct {
-	pos  float64
+	pos  float32
 	side side
 }
 
-func (p *paddle) bounds() *sdl.Rect {
+func (p *paddle) bounds() *sdl.FRect {
 	const (
 		paddleHeight = 200
 		thickness    = 10
 		padding      = 100
 	)
-	r := &sdl.Rect{
+	r := &sdl.FRect{
 		X: padding - thickness/2,
-		Y: int32(p.pos - paddleHeight/2),
+		Y: p.pos - paddleHeight/2,
 		W: thickness,
 		H: paddleHeight,
 	}
@@ -184,7 +184,7 @@ func pong() error {
 				paddle1.pos += paddleSpeed
 			}
 
-			if prediction, ok := ball.predictIntersection(float64(paddle2.bounds().X)); ok {
+			if prediction, ok := ball.predictIntersection(paddle2.bounds().X); ok {
 				switch {
 				case paddle2.pos <= prediction-paddleSpeed && rectBottom(paddle2.bounds()) <= screenHeight:
 					paddle2.pos += paddleSpeed
@@ -199,31 +199,31 @@ func pong() error {
 				if _, err := ping.Play(-1, 0); err != nil {
 					fmt.Fprintln(os.Stderr, err)
 				}
-				d := ball.pos.y - paddle1.pos
+				d := (ball.pos.y - paddle1.pos) / (paddle1.bounds().H/2 + ball.bounds().H)
 				if d < 0 {
 					d = -d
 				}
-				angle := d / (float64(paddle1.bounds().H)/2 + float64(ball.bounds().H)) * (75 * 2 * math.Pi / 360)
+				angle := d * 75 * 2 * math.Pi / 360
 				if ball.pos.y < paddle1.pos {
 					angle = -angle
 				}
-				speed := ballSpeed * (1 + 4*d/(float64(paddle1.bounds().H)/2+float64(ball.bounds().H)))
-				ball.velocity = vector2{speed * math.Cos(angle), speed * math.Sin(angle)}
+				speed := ballSpeed * (1 + 4*d)
+				ball.velocity = vector2{speed * float32(math.Cos(float64(angle))), speed * float32(math.Sin(float64(angle)))}
 			case ball.bounds().HasIntersection(paddle2.bounds()) && ball.velocity.x >= 0:
 				if _, err := ping.Play(-1, 0); err != nil {
 					fmt.Fprintln(os.Stderr, err)
 				}
-				d := ball.pos.y - paddle2.pos
+				d := (ball.pos.y - paddle2.pos) / (paddle2.bounds().H/2 + ball.bounds().H)
 				if d < 0 {
 					d = -d
 				}
-				angle := d / (float64(paddle2.bounds().H)/2 + float64(ball.bounds().H)) * (75 * 2 * math.Pi / 360)
+				angle := d * 75 * 2 * math.Pi / 360
 				if ball.pos.y < paddle2.pos {
 					angle = -angle
 				}
 				angle += math.Pi
-				speed := ballSpeed * (1 + 4*d/(float64(paddle2.bounds().H)/2+float64(ball.bounds().H)))
-				ball.velocity = vector2{speed * math.Cos(angle), speed * math.Sin(angle)}
+				speed := ballSpeed * (1 + 4*d)
+				ball.velocity = vector2{speed * float32(math.Cos(float64(angle))), speed * float32(math.Sin(float64(angle)))}
 			case rectRight(ball.bounds()) <= 0:
 				aiScore++
 				ball.reset(right)
@@ -254,13 +254,13 @@ func pong() error {
 		if err := renderer.SetDrawColor(245, 245, 245, 255); err != nil {
 			fmt.Fprintln(os.Stderr, err)
 		}
-		if err := renderer.FillRect(paddle1.bounds()); err != nil {
+		if err := renderer.FillRectF(paddle1.bounds()); err != nil {
 			fmt.Fprintln(os.Stderr, err)
 		}
-		if err := renderer.FillRect(paddle2.bounds()); err != nil {
+		if err := renderer.FillRectF(paddle2.bounds()); err != nil {
 			fmt.Fprintln(os.Stderr, err)
 		}
-		if err := renderer.FillRect(ball.bounds()); err != nil {
+		if err := renderer.FillRectF(ball.bounds()); err != nil {
 			fmt.Fprintln(os.Stderr, err)
 		}