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()
createPlanets := func(ps PlanetSetting) error {
return m.CreatePlanets(ps.Count(freePlanets), float64(ps.MinDistanceHW), RandIFn(ps.MinSize, ps.MaxSize), RandIFn(ps.MinResource, ps.MaxResource))
createPlanets := func(pc PlanetClass, ps PlanetSetting) error {
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
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)
}
// 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)
}
@@ -41,14 +41,14 @@ func Generate(cfg ...func(*MapSetting)) (Map, error) {
if err != nil {
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)}
for dw := 0; dw < int(ms.DWCount); dw++ {
p := rand.Float64()*(float64(ms.DWMaxDistance)-float64(ms.DWMinDistance)) + float64(ms.DWMinDistance)
phi := rand.Float64() * 360
x := p * math.Cos(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
}
}
@@ -66,17 +66,17 @@ func Generate(cfg ...func(*MapSetting)) (Map, error) {
}
// 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)
}
// 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)
}
// 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)
}
pkg/generator/generator_test.go
+86 -20
View File
@@ -9,27 +9,93 @@ import (
)
func TestGenerator(t *testing.T) {
for players := 10; players <= 50; players++ {
var s generator.MapSetting
m, err := generator.Generate(func(ms *generator.MapSetting) {
ms.Players = uint32(players)
s = *ms
})
if err != nil {
t.Errorf("generate: %s", err)
break
}
assert.Equal(t, players, len(m.HomePlanets), "hw count")
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)
maxPlayers := 20
for players := 10; players <= maxPlayers; players++ {
t.Run(fmt.Sprintf("%d_players", players), func(t *testing.T) {
var s generator.MapSetting
m, err := generator.Generate(func(ms *generator.MapSetting) {
ms.Players = uint32(players)
s = *ms
})
if err != nil {
t.Fatalf("generate: %s", err)
return
}
}
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
}
type PlanetClass int
const (
PlanetClassHW PlanetClass = iota
PlanetClassDW
PlanetClassGiant
PlanetClassBig
PlanetClassNormal
PlanetClassRich
PlanetClassAsterioid
)
type Planet struct {
Position Coordinate
Size float64
Resources float64 // Сырьё
PlanetClass PlanetClass
Position Coordinate
Size float64
Resources float64 // Сырьё
}
type PlanetarySystem struct {
@@ -44,13 +57,13 @@ func NewMap(width, height, players uint32) (*Map, error) {
}, 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 {
coord, err := m.NewCoordinate(deadZoneRadius)
if err != nil {
return err
}
planet := NewPlanet(coord, size(), resources())
planet := NewPlanet(pc, coord, size(), resources())
m.AddPlanet(planet)
}
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))
}
func NewPlanet(c Coordinate, size, resources float64) Planet {
func NewPlanet(pc PlanetClass, c Coordinate, size, resources float64) Planet {
return Planet{
Position: c,
Size: size,
Resources: resources,
PlanetClass: pc,
Position: c,
Size: size,
Resources: resources,
}
}
pkg/generator/settings.go
+9 -8
View File
@@ -9,12 +9,12 @@ const defaultFactor float64 = 0.1
type MapSetting struct {
Players uint32
HWSize uint32
HWResources uint32
HWSize float64
HWResources float64
HWMinDistance uint32
DWCount uint32
DWSize uint32
DWResources uint32
DWSize float64
DWResources float64
DWMinDistance uint32
DWMaxDistance uint32
@@ -31,7 +31,8 @@ func (ms MapSetting) String() string {
}
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 {
@@ -51,8 +52,8 @@ type PlanetSetting struct {
Probability float64
}
func (ps PlanetSetting) Count(freePlanets uint32) int {
return int(math.Ceil(float64(freePlanets) * float64(ps.Probability)))
func (ps PlanetSetting) MaxCount(freePlanets uint32) int {
return int(math.Ceil(float64(freePlanets) * ps.Probability))
}
func DefaultMapSetting() MapSetting {
@@ -82,7 +83,7 @@ func DefaultMapSetting() MapSetting {
MaxResource: 10,
Probability: 0.18,
},
OthersMinDistance: defaultFactor, // minimal of 1 pixel on the plotter
OthersMinDistance: defaultFactor, // min. is 1 pixel on the plotter
NormalPlanets: PlanetSetting{
MinDistanceHW: 0,
MinSize: 0,