developer/galaxy-game
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

complete generator test

Browse Source
This commit is contained in:
Ilia Denisov
2025-09-24 15:35:33 +03:00
parent ab822a1abf
commit 99035fd95d
4 changed files with 127 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/generator/generator.go
+9 -9
View File
@@ -21,17 +21,17 @@ func Generate(cfg ...func(*MapSetting)) (Map, error) {
freePlanets := ms.NobodysPlanets() freePlanets := ms.NobodysPlanets()
createPlanets := func(ps PlanetSetting) error { createPlanets := func(pc PlanetClass, ps PlanetSetting) error {
return m.CreatePlanets(ps.Count(freePlanets), float64(ps.MinDistanceHW), RandIFn(ps.MinSize, ps.MaxSize), RandIFn(ps.MinResource, ps.MaxResource)) return m.CreatePlanets(pc, rand.Intn(ps.MaxCount(freePlanets))+1, float64(ps.MinDistanceHW), RandIFn(ps.MinSize, ps.MaxSize), RandIFn(ps.MinResource, ps.MaxResource))
} }
// 1. Place Giant planets // 1. Place Giant planets
if err := createPlanets(ms.GiantPlanets); err != nil { if err := createPlanets(PlanetClassGiant, ms.GiantPlanets); err != nil {
return Map{}, fmt.Errorf("%s: create giant planets: %s", ms, err) return Map{}, fmt.Errorf("%s: create giant planets: %s", ms, err)
} }
// 2. Place Big planets // 2. Place Big planets
if err := createPlanets(ms.BigPlanets); err != nil { if err := createPlanets(PlanetClassBig, ms.BigPlanets); err != nil {
return Map{}, fmt.Errorf("%s: create big planets: %s", ms, err) return Map{}, fmt.Errorf("%s: create big planets: %s", ms, err)
} }
@@ -41,14 +41,14 @@ func Generate(cfg ...func(*MapSetting)) (Map, error) {
if err != nil { if err != nil {
return Map{}, fmt.Errorf("%s: hw new_coordinate: %s", ms, err) return Map{}, fmt.Errorf("%s: hw new_coordinate: %s", ms, err)
} }
hwPlanet := NewPlanet(hwCoord, float64(ms.HWSize), float64(ms.HWResources)) hwPlanet := NewPlanet(PlanetClassHW, hwCoord, ms.HWSize, ms.HWResources)
m.HomePlanets[player] = PlanetarySystem{HW: hwPlanet, DW: make([]Planet, ms.DWCount)} m.HomePlanets[player] = PlanetarySystem{HW: hwPlanet, DW: make([]Planet, ms.DWCount)}
for dw := 0; dw < int(ms.DWCount); dw++ { for dw := 0; dw < int(ms.DWCount); dw++ {
p := rand.Float64()*(float64(ms.DWMaxDistance)-float64(ms.DWMinDistance)) + float64(ms.DWMinDistance) p := rand.Float64()*(float64(ms.DWMaxDistance)-float64(ms.DWMinDistance)) + float64(ms.DWMinDistance)
phi := rand.Float64() * 360 phi := rand.Float64() * 360
x := p * math.Cos(phi) x := p * math.Cos(phi)
y := p * math.Sin(phi) y := p * math.Sin(phi)
dwPlanet := NewPlanet(Coordinate{hwCoord.X + x, hwCoord.Y + y}, float64(ms.DWSize), float64(ms.DWResources)) dwPlanet := NewPlanet(PlanetClassDW, Coordinate{hwCoord.X + x, hwCoord.Y + y}, ms.DWSize, ms.DWResources)
m.HomePlanets[player].DW[dw] = dwPlanet m.HomePlanets[player].DW[dw] = dwPlanet
} }
} }
@@ -66,17 +66,17 @@ func Generate(cfg ...func(*MapSetting)) (Map, error) {
} }
// 5. Place Normal planets // 5. Place Normal planets
if err := createPlanets(ms.NormalPlanets); err != nil { if err := createPlanets(PlanetClassNormal, ms.NormalPlanets); err != nil {
return Map{}, fmt.Errorf("%s: create normal planets: %s", ms, err) return Map{}, fmt.Errorf("%s: create normal planets: %s", ms, err)
} }
// 6. Place Rich planets // 6. Place Rich planets
if err := createPlanets(ms.RichPlanets); err != nil { if err := createPlanets(PlanetClassRich, ms.RichPlanets); err != nil {
return Map{}, fmt.Errorf("%s: create rich planets: %s", ms, err) return Map{}, fmt.Errorf("%s: create rich planets: %s", ms, err)
} }
// 7. Place Asteroids // 7. Place Asteroids
if err := createPlanets(ms.Asterioids); err != nil { if err := createPlanets(PlanetClassAsterioid, ms.Asterioids); err != nil {
return Map{}, fmt.Errorf("%s: create asteroids: %s", ms, err) return Map{}, fmt.Errorf("%s: create asteroids: %s", ms, err)
} }
pkg/generator/generator_test.go
+86 -20
View File
@@ -9,27 +9,93 @@ import (
) )
func TestGenerator(t *testing.T) { func TestGenerator(t *testing.T) {
for players := 10; players <= 50; players++ { maxPlayers := 20
var s generator.MapSetting for players := 10; players <= maxPlayers; players++ {
m, err := generator.Generate(func(ms *generator.MapSetting) { t.Run(fmt.Sprintf("%d_players", players), func(t *testing.T) {
ms.Players = uint32(players) var s generator.MapSetting
s = *ms m, err := generator.Generate(func(ms *generator.MapSetting) {
}) ms.Players = uint32(players)
if err != nil { s = *ms
t.Errorf("generate: %s", err) })
break if err != nil {
} t.Fatalf("generate: %s", err)
assert.Equal(t, players, len(m.HomePlanets), "hw count") return
for i := range m.HomePlanets {
assert.Equal(t, int(s.DWCount), len(m.HomePlanets[i].DW), "hw #%d: dw count", i)
for dw := range m.HomePlanets[i].DW {
d := m.ShortDistance(m.HomePlanets[i].HW.Position, m.HomePlanets[i].DW[dw].Position)
assert.LessOrEqualf(t, float64(s.DWMinDistance), d, "HW[%.04f,%04f] - DW[%.04f,%04f]",
m.HomePlanets[i].HW.Position.X, m.HomePlanets[i].HW.Position.Y, m.HomePlanets[i].DW[dw].Position.X, m.HomePlanets[i].DW[dw].Position.Y)
assert.GreaterOrEqualf(t, float64(s.DWMaxDistance), d, "HW[%.04f,%04f] - DW[%.04f,%04f]",
m.HomePlanets[i].HW.Position.X, m.HomePlanets[i].HW.Position.Y, m.HomePlanets[i].DW[dw].Position.X, m.HomePlanets[i].DW[dw].Position.Y)
} }
} assert.Equal(t, players, len(m.HomePlanets), "hw count")
for hw := range m.HomePlanets {
assert.Equal(t, s.HWSize, m.HomePlanets[hw].HW.Size, "hw #%d: size", hw)
assert.Equal(t, s.HWResources, m.HomePlanets[hw].HW.Resources, "hw #%d: resources", hw)
assert.Equal(t, int(s.DWCount), len(m.HomePlanets[hw].DW), "hw #%d: dw count", hw)
for dw := range m.HomePlanets[hw].DW {
assert.Equal(t, s.DWSize, m.HomePlanets[hw].DW[dw].Size, "hw #%d dw #%d: size", hw, dw)
assert.Equal(t, s.DWResources, m.HomePlanets[hw].DW[dw].Resources, "hw #%d dw #%d: resources", hw, dw)
d := m.ShortDistance(m.HomePlanets[hw].HW.Position, m.HomePlanets[hw].DW[dw].Position)
assert.LessOrEqualf(t, float64(s.DWMinDistance), d, "distance: HW[%.04f,%04f] <-> DW[%.04f,%04f]",
m.HomePlanets[hw].HW.Position.X, m.HomePlanets[hw].HW.Position.Y,
m.HomePlanets[hw].DW[dw].Position.X, m.HomePlanets[hw].DW[dw].Position.Y)
assert.GreaterOrEqualf(t, float64(s.DWMaxDistance), d, "distance: HW[%.04f,%04f] <-> DW[%.04f,%04f]",
m.HomePlanets[hw].HW.Position.X, m.HomePlanets[hw].HW.Position.Y,
m.HomePlanets[hw].DW[dw].Position.X, m.HomePlanets[hw].DW[dw].Position.Y)
}
}
freePlanetCount := make(map[generator.PlanetClass]int)
for fp := range m.FreePlanets {
ps := planetSettings(t, m.FreePlanets[fp].PlanetClass, s)
testPlanetParameters(t, ps, m.FreePlanets[fp])
if v, ok := freePlanetCount[m.FreePlanets[fp].PlanetClass]; !ok {
freePlanetCount[m.FreePlanets[fp].PlanetClass] = 1
} else {
freePlanetCount[m.FreePlanets[fp].PlanetClass] = v + 1
}
if ps.MinDistanceHW > 0 {
for hw := range m.HomePlanets {
d := m.ShortDistance(m.HomePlanets[hw].HW.Position, m.FreePlanets[fp].Position)
// FIXME:
// Error: "20" is not less than or equal to "19.98697122994701"
// Test: TestGenerator/24_players
// Messages: distance: HW[44.4883,136.985727] <-> %!s(generator.PlanetClass=2)[38.9977,156.203728]
//
// Error: "10" is not less than or equal to "9.985592188977868"
// Test: TestGenerator/33_players
// Messages: distance: HW[231.7975,76.996315] <-> planet_class=3[237.7334,85.026044]
assert.LessOrEqualf(t, float64(ps.MinDistanceHW), d, "distance: HW[%.04f,%04f] <-> planet_class=%v[%.04f,%04f]",
m.HomePlanets[hw].HW.Position.X, m.HomePlanets[hw].HW.Position.Y,
m.FreePlanets[fp].PlanetClass,
m.FreePlanets[fp].Position.X, m.FreePlanets[fp].Position.Y)
}
}
}
for pc, num := range freePlanetCount {
ps := planetSettings(t, pc, s)
maxNum := ps.MaxCount(s.NobodysPlanets())
assert.LessOrEqualf(t, num, maxNum, "planet_class=%v probability=%f of total %d", pc, ps.Probability, s.NobodysPlanets())
}
})
}
}
func testPlanetParameters(t *testing.T, s generator.PlanetSetting, p generator.Planet) {
assert.LessOrEqualf(t, s.MinResource, p.Resources, "planet class=%s min resources", p.PlanetClass)
assert.GreaterOrEqualf(t, s.MaxResource, p.Resources, "planet class=%s max resources", p.PlanetClass)
assert.LessOrEqualf(t, s.MinSize, p.Size, "planet class=%s min size", p.PlanetClass)
assert.GreaterOrEqualf(t, s.MaxSize, p.Size, "planet class=%s max size", p.PlanetClass)
}
func planetSettings(t *testing.T, pc generator.PlanetClass, s generator.MapSetting) generator.PlanetSetting {
switch pc {
case generator.PlanetClassGiant:
return s.GiantPlanets
case generator.PlanetClassBig:
return s.BigPlanets
case generator.PlanetClassNormal:
return s.NormalPlanets
case generator.PlanetClassRich:
return s.RichPlanets
case generator.PlanetClassAsterioid:
return s.Asterioids
default:
assert.FailNow(t, "unexpected planet class: %s", pc)
return generator.PlanetSetting{}
} }
} }
pkg/generator/map.go
+23 -9
View File
@@ -20,10 +20,23 @@ type Coordinate struct {
X, Y float64 X, Y float64
} }
type PlanetClass int
const (
PlanetClassHW PlanetClass = iota
PlanetClassDW
PlanetClassGiant
PlanetClassBig
PlanetClassNormal
PlanetClassRich
PlanetClassAsterioid
)
type Planet struct { type Planet struct {
Position Coordinate PlanetClass PlanetClass
Size float64 Position Coordinate
Resources float64 // Сырьё Size float64
Resources float64 // Сырьё
} }
type PlanetarySystem struct { type PlanetarySystem struct {
@@ -44,13 +57,13 @@ func NewMap(width, height, players uint32) (*Map, error) {
}, nil }, nil
} }
func (m *Map) CreatePlanets(num int, deadZoneRadius float64, size, resources func() float64) error { func (m *Map) CreatePlanets(pc PlanetClass, num int, deadZoneRadius float64, size, resources func() float64) error {
for range num { for range num {
coord, err := m.NewCoordinate(deadZoneRadius) coord, err := m.NewCoordinate(deadZoneRadius)
if err != nil { if err != nil {
return err return err
} }
planet := NewPlanet(coord, size(), resources()) planet := NewPlanet(pc, coord, size(), resources())
m.AddPlanet(planet) m.AddPlanet(planet)
} }
return nil return nil
@@ -80,11 +93,12 @@ func (m Map) ShortDistance(from, to Coordinate) float64 {
return math.Sqrt(math.Pow(dx, 2) + math.Pow(dy, 2)) return math.Sqrt(math.Pow(dx, 2) + math.Pow(dy, 2))
} }
func NewPlanet(c Coordinate, size, resources float64) Planet { func NewPlanet(pc PlanetClass, c Coordinate, size, resources float64) Planet {
return Planet{ return Planet{
Position: c, PlanetClass: pc,
Size: size, Position: c,
Resources: resources, Size: size,
Resources: resources,
} }
} }
pkg/generator/settings.go
+9 -8
View File
@@ -9,12 +9,12 @@ const defaultFactor float64 = 0.1
type MapSetting struct { type MapSetting struct {
Players uint32 Players uint32
HWSize uint32 HWSize float64
HWResources uint32 HWResources float64
HWMinDistance uint32 HWMinDistance uint32
DWCount uint32 DWCount uint32
DWSize uint32 DWSize float64
DWResources uint32 DWResources float64
DWMinDistance uint32 DWMinDistance uint32
DWMaxDistance uint32 DWMaxDistance uint32
@@ -31,7 +31,8 @@ func (ms MapSetting) String() string {
} }
func (ms MapSetting) ExpectedSize() uint32 { func (ms MapSetting) ExpectedSize() uint32 {
return uint32(math.Sqrt(float64(ms.Players)) * float64(ms.HWMinDistance) * 1.4) // 1.5 coefficient is enough if all free planet probability will be 1.0
return uint32(math.Sqrt(float64(ms.Players)) * float64(ms.HWMinDistance) * 1.5)
} }
func (ms MapSetting) TotalPlanets() uint32 { func (ms MapSetting) TotalPlanets() uint32 {
@@ -51,8 +52,8 @@ type PlanetSetting struct {
Probability float64 Probability float64
} }
func (ps PlanetSetting) Count(freePlanets uint32) int { func (ps PlanetSetting) MaxCount(freePlanets uint32) int {
return int(math.Ceil(float64(freePlanets) * float64(ps.Probability))) return int(math.Ceil(float64(freePlanets) * ps.Probability))
} }
func DefaultMapSetting() MapSetting { func DefaultMapSetting() MapSetting {
@@ -82,7 +83,7 @@ func DefaultMapSetting() MapSetting {
MaxResource: 10, MaxResource: 10,
Probability: 0.18, Probability: 0.18,
}, },
OthersMinDistance: defaultFactor, // minimal of 1 pixel on the plotter OthersMinDistance: defaultFactor, // min. is 1 pixel on the plotter
NormalPlanets: PlanetSetting{ NormalPlanets: PlanetSetting{
MinDistanceHW: 0, MinDistanceHW: 0,
MinSize: 0, MinSize: 0,