234 lines
7.3 KiB
Go
234 lines
7.3 KiB
Go
package game
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
"github.com/soer/football/internal/entities"
|
|
)
|
|
|
|
const epsilon = 1e-9
|
|
|
|
func TestWorld_Friction(t *testing.T) {
|
|
w := NewWorld()
|
|
|
|
w.Puck.Velocity = entities.Vector2{X: 10, Y: 0}
|
|
|
|
w.Update()
|
|
|
|
expectedX := 10.0 * Friction
|
|
if math.Abs(w.Puck.Velocity.X-expectedX) > epsilon {
|
|
t.Errorf("Expected velocity X to be %f, got %f", expectedX, w.Puck.Velocity.X)
|
|
}
|
|
}
|
|
|
|
func TestWorld_StopThreshold(t *testing.T) {
|
|
w := NewWorld()
|
|
// Set velocity just below StopThreshold
|
|
w.Puck.Velocity = entities.Vector2{X: StopThreshold * 0.5, Y: 0}
|
|
|
|
w.Update()
|
|
|
|
if math.Abs(w.Puck.Velocity.X) > epsilon || math.Abs(w.Puck.Velocity.Y) > epsilon {
|
|
t.Errorf("Expected velocity to be 0, got {%f, %f}", w.Puck.Velocity.X, w.Puck.Velocity.Y)
|
|
}
|
|
}
|
|
|
|
func TestWorld_Restitution(t *testing.T) {
|
|
w := NewWorld()
|
|
|
|
w.Puck.Position = entities.Vector2{X: 8, Y: 360}
|
|
w.Puck.Velocity = entities.Vector2{X: -2, Y: 0}
|
|
|
|
w.Update()
|
|
|
|
expectedX := (-2.0 * Friction) * -Restitution
|
|
if math.Abs(w.Puck.Velocity.X-expectedX) > epsilon {
|
|
t.Errorf("Expected velocity X to be %f, got %f", expectedX, w.Puck.Velocity.X)
|
|
}
|
|
}
|
|
|
|
func TestWorld_ZoningAI(t *testing.T) {
|
|
w := NewWorld()
|
|
|
|
// TeamRed Defender
|
|
redDef := &entities.Player{
|
|
Position: entities.Vector2{X: 200, Y: 360},
|
|
HomePosition: entities.Vector2{X: 200, Y: 360},
|
|
Team: entities.TeamRed,
|
|
Role: entities.RoleDefender,
|
|
}
|
|
|
|
// TeamRed Striker
|
|
redStr := &entities.Player{
|
|
Position: entities.Vector2{X: 400, Y: 360},
|
|
HomePosition: entities.Vector2{X: 400, Y: 360},
|
|
Team: entities.TeamRed,
|
|
Role: entities.RoleStriker,
|
|
}
|
|
|
|
// Case 1: Puck in Defensive Zone (Zone 0)
|
|
puckPos0 := entities.Vector2{X: 100, Y: 360}
|
|
|
|
// Defender should intercept
|
|
targetDef0 := w.calculateTarget(redDef, puckPos0)
|
|
expectedDef0 := entities.Vector2{X: (100.0 + GoalLeft.X) / 2, Y: 360}
|
|
if targetDef0 != expectedDef0 {
|
|
t.Errorf("Zone 0: Expected Red Defender to target %v, got %v", expectedDef0, targetDef0)
|
|
}
|
|
|
|
// Striker should return to center
|
|
targetStr0 := w.calculateTarget(redStr, puckPos0)
|
|
expectedStr0 := entities.Vector2{X: WorldCenterX, Y: WorldCenterY}
|
|
if targetStr0 != expectedStr0 {
|
|
t.Errorf("Zone 0: Expected Red Striker to target %v, got %v", expectedStr0, targetStr0)
|
|
}
|
|
|
|
// Case 2: Puck in Middle Zone (Zone 1)
|
|
puckPos1 := entities.Vector2{X: 600, Y: 360}
|
|
|
|
// Defender should stay slightly behind
|
|
targetDef1 := w.calculateTarget(redDef, puckPos1)
|
|
expectedDef1 := entities.Vector2{X: 600 + (GoalLeft.X-600)*0.2, Y: 360}
|
|
if targetDef1 != expectedDef1 {
|
|
t.Errorf("Zone 1: Expected Red Defender to target %v, got %v", expectedDef1, targetDef1)
|
|
}
|
|
|
|
// Striker should pursue
|
|
targetStr1 := w.calculateTarget(redStr, puckPos1)
|
|
if targetStr1 != puckPos1 {
|
|
t.Errorf("Zone 1: Expected Red Striker to target puck %v, got %v", puckPos1, targetStr1)
|
|
}
|
|
|
|
// Case 3: Puck in Offensive Zone (Zone 2)
|
|
puckPos2 := entities.Vector2{X: 1000, Y: 360}
|
|
|
|
// Defender should return home
|
|
targetDef2 := w.calculateTarget(redDef, puckPos2)
|
|
if targetDef2 != redDef.HomePosition {
|
|
t.Errorf("Zone 2: Expected Red Defender to target HomePosition %v, got %v", redDef.HomePosition, targetDef2)
|
|
}
|
|
|
|
// Striker should aggressively pursue
|
|
targetStr2 := w.calculateTarget(redStr, puckPos2)
|
|
if targetStr2 != puckPos2 {
|
|
t.Errorf("Zone 2: Expected Red Striker to target puck %v, got %v", puckPos2, targetStr2)
|
|
}
|
|
}
|
|
|
|
func TestWorld_GoalieAI(t *testing.T) {
|
|
w := NewWorld()
|
|
|
|
// Create a Red Goalie
|
|
redGoalie := &entities.Player{
|
|
Position: entities.Vector2{X: GoalLeft.X, Y: GoalLeft.Y},
|
|
HomePosition: entities.Vector2{X: GoalLeft.X, Y: GoalLeft.Y},
|
|
Team: entities.TeamRed,
|
|
Role: entities.RoleGoalie,
|
|
}
|
|
|
|
// Case 1: Puck is far away. Target should be at GoalieMaxDistance from goal.
|
|
w.Puck.Position = entities.Vector2{X: 500, Y: 360}
|
|
target := w.calculateTarget(redGoalie, w.Puck.Position)
|
|
|
|
dx := target.X - GoalLeft.X
|
|
dy := target.Y - GoalLeft.Y
|
|
dist := math.Sqrt(dx*dx + dy*dy)
|
|
if math.Abs(dist-GoalieMaxDistance) > epsilon {
|
|
t.Errorf("Expected Red Goalie to target distance %f, got %f", GoalieMaxDistance, dist)
|
|
}
|
|
|
|
// Case 2: Puck is close. Target should be exactly at puck position.
|
|
w.Puck.Position = entities.Vector2{X: GoalLeft.X + 10, Y: GoalLeft.Y + 10}
|
|
target = w.calculateTarget(redGoalie, w.Puck.Position)
|
|
if target != w.Puck.Position {
|
|
t.Errorf("Expected Red Goalie to target puck position when close, got %v", target)
|
|
}
|
|
|
|
// Case 3: Puck is behind the goal. Target should be goal center.
|
|
w.Puck.Position = entities.Vector2{X: GoalLeft.X - 10, Y: GoalLeft.Y}
|
|
target = w.calculateTarget(redGoalie, w.Puck.Position)
|
|
if target != GoalLeft {
|
|
t.Errorf("Expected Red Goalie to target goal center when puck is behind, got %v", target)
|
|
}
|
|
|
|
// Case 4: Puck is within GoalieDeadzone. Target should be goal center.
|
|
w.Puck.Position = entities.Vector2{X: GoalLeft.X + GoalieDeadzone*0.5, Y: GoalLeft.Y}
|
|
target = w.calculateTarget(redGoalie, w.Puck.Position)
|
|
if target != GoalLeft {
|
|
t.Errorf("Expected Red Goalie to target goal center when puck is within deadzone, got %v", target)
|
|
}
|
|
|
|
// Case 5: Blue Goalie
|
|
blueGoalie := &entities.Player{
|
|
Position: entities.Vector2{X: GoalRight.X, Y: GoalRight.Y},
|
|
HomePosition: entities.Vector2{X: GoalRight.X, Y: GoalRight.Y},
|
|
Team: entities.TeamBlue,
|
|
Role: entities.RoleGoalie,
|
|
}
|
|
w.Puck.Position = entities.Vector2{X: 700, Y: 360}
|
|
target = w.calculateTarget(blueGoalie, w.Puck.Position)
|
|
dx = target.X - GoalRight.X
|
|
dy = target.Y - GoalRight.Y
|
|
dist = math.Sqrt(dx*dx + dy*dy)
|
|
if math.Abs(dist-GoalieMaxDistance) > epsilon {
|
|
t.Errorf("Expected Blue Goalie to target distance %f, got %f", GoalieMaxDistance, dist)
|
|
}
|
|
}
|
|
|
|
func TestWorld_CheckGoal(t *testing.T) {
|
|
w := NewWorld()
|
|
|
|
// Case 1: Puck goes off left side (Blue scores)
|
|
w.Puck.Position = entities.Vector2{X: -1, Y: 360}
|
|
team, scored := w.CheckGoal()
|
|
if !scored || team != entities.TeamBlue {
|
|
t.Errorf("Expected TeamBlue to score, got %v, %v", team, scored)
|
|
}
|
|
|
|
// Case 2: Puck goes off right side (Red scores)
|
|
w.Puck.Position = entities.Vector2{X: WorldWidth + 1, Y: 360}
|
|
team, scored = w.CheckGoal()
|
|
if !scored || team != entities.TeamRed {
|
|
t.Errorf("Expected TeamRed to score, got %v, %v", team, scored)
|
|
}
|
|
|
|
// Case 3: Puck is in bounds
|
|
w.Puck.Position = entities.Vector2{X: WorldCenterX, Y: WorldCenterY}
|
|
team, scored = w.CheckGoal()
|
|
if scored {
|
|
t.Errorf("Expected no goal, but scored: %v", team)
|
|
}
|
|
}
|
|
|
|
func TestWorld_ResetPositions(t *testing.T) {
|
|
w := NewWorld()
|
|
|
|
// Move puck and players away from home
|
|
w.Puck.Position = entities.Vector2{X: 100, Y: 100}
|
|
w.Puck.Velocity = entities.Vector2{X: 5, Y: 5}
|
|
for _, p := range w.Players {
|
|
p.Position = entities.Vector2{X: 500, Y: 500}
|
|
p.Velocity = entities.Vector2{X: 2, Y: 2}
|
|
}
|
|
|
|
w.ResetPositions()
|
|
|
|
// Verify puck
|
|
if w.Puck.Position != (entities.Vector2{X: WorldCenterX, Y: WorldCenterY}) {
|
|
t.Errorf("Expected puck at center, got %v", w.Puck.Position)
|
|
}
|
|
if w.Puck.Velocity != (entities.Vector2{X: 0, Y: 0}) {
|
|
t.Errorf("Expected puck velocity 0, got %v", w.Puck.Velocity)
|
|
}
|
|
|
|
// Verify players
|
|
for _, p := range w.Players {
|
|
if p.Position != p.HomePosition {
|
|
t.Errorf("Expected player at home position %v, got %v", p.HomePosition, p.Position)
|
|
}
|
|
if p.Velocity != (entities.Vector2{X: 0, Y: 0}) {
|
|
t.Errorf("Expected player velocity 0, got %v", p.Velocity)
|
|
}
|
|
}
|
|
}
|