diff --git a/pkg/generator/generator.go b/pkg/generator/generator.go index faf56c5..9cacb3a 100644 --- a/pkg/generator/generator.go +++ b/pkg/generator/generator.go @@ -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) } diff --git a/pkg/generator/generator_test.go b/pkg/generator/generator_test.go index df1ef8f..3073b64 100644 --- a/pkg/generator/generator_test.go +++ b/pkg/generator/generator_test.go @@ -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{} } } diff --git a/pkg/generator/map.go b/pkg/generator/map.go index 16abd02..36c92e6 100644 --- a/pkg/generator/map.go +++ b/pkg/generator/map.go @@ -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, } } diff --git a/pkg/generator/settings.go b/pkg/generator/settings.go index d860d53..fa7709b 100644 --- a/pkg/generator/settings.go +++ b/pkg/generator/settings.go @@ -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,