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

refactor: float64 types for storage and report

Browse Source
This commit is contained in:
Ilia Denisov
2026-02-02 13:14:57 +02:00
parent 4c14234afb
commit a567229f8a
24 changed files with 264 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/controller/battle.go
+2 -2
View File
@@ -65,9 +65,9 @@ func FilterBattleOpponents(c *Cache, attIdx, defIdx int, cacheProbability map[in
p := DestructionProbability(
c.ShipGroupShipClass(attIdx).Weapons,
c.ShipGroup(attIdx).TechLevel(game.TechWeapons),
c.ShipGroup(attIdx).TechLevel(game.TechWeapons).F(),
c.ShipGroupShipClass(defIdx).Shields,
c.ShipGroup(defIdx).TechLevel(game.TechShields),
c.ShipGroup(defIdx).TechLevel(game.TechShields).F(),
c.ShipGroup(defIdx).FullMass(c.ShipGroupShipClass(defIdx)),
)
// Exclude opponent's group which cannot be probably destroyed
internal/controller/battle_transform.go
+5 -5
View File
@@ -30,11 +30,11 @@ func TransformBattle(c *Cache, b *Battle) *report.BattleReport {
NumberLeft: sg.Number,
ClassName: shipClass.Name,
LoadType: sg.CargoString(),
LoadQuantity: sg.Load,
Drive: sg.TechLevel(game.TechDrive),
Weapons: sg.TechLevel(game.TechWeapons),
Shields: sg.TechLevel(game.TechShields),
Cargo: sg.TechLevel(game.TechCargo),
LoadQuantity: sg.Load.RF(),
Drive: sg.TechLevel(game.TechDrive).RF(),
Weapons: sg.TechLevel(game.TechWeapons).RF(),
Shields: sg.TechLevel(game.TechShields).RF(),
Cargo: sg.TechLevel(game.TechCargo).RF(),
}
cacheShipClass[shipClass.ID] = itemNumber
return itemNumber
internal/controller/bombing.go
+17 -17
View File
@@ -20,12 +20,12 @@ func (c *Cache) bombingReport(p *game.Planet, ri int, groups []int) report.Bombi
Owner: c.g.Race[c.RaceIndex(p.Owner)].Name,
Attacker: c.g.Race[ri].Name,
Production: c.PlanetProductionDisplayName(p.Number),
Industry: p.Industry,
Population: p.Population,
Colonists: p.Colonists,
Capital: p.Capital,
Material: p.Material,
AttackPower: attackPower,
Industry: p.Industry.RF(),
Population: p.Population.RF(),
Colonists: p.Colonists.RF(),
Capital: p.Capital.RF(),
Material: p.Material.RF(),
AttackPower: game.RF(attackPower),
}
bombPlanet(p, attackPower)
r.Wiped = p.Population == 0
@@ -61,23 +61,23 @@ func (c *Cache) ProduceBombings() []report.BombingPlanetReport {
func bombPlanet(p *game.Planet, power float64) {
// Уничтожается население и колонисты в количестве равном [суммарной] мощности бомбардировки
if power > p.Population {
p.Population = 0
if power > p.Population.F() {
p.Pop(0)
} else {
p.Population -= power
p.Pop(p.Population.F() - power)
}
if power > p.Colonists {
p.Colonists = 0
if power > p.Colonists.F() {
p.Col(0)
} else {
p.Colonists -= power
p.Col(p.Colonists.F() - power)
}
// Такое же количество промышленности превращается в сырье
if power > p.Industry {
p.Material += p.Industry
p.Industry = 0
if power > p.Industry.F() {
p.Mat(p.Material.F() + p.Industry.F())
p.Ind(0)
} else {
p.Material += power
p.Industry -= power
p.Mat(p.Material.F() + power)
p.Ind(p.Industry.F() - power)
}
}
internal/controller/bombing_test.go
+17 -17
View File
@@ -12,25 +12,25 @@ import (
func TestBombPlanet(t *testing.T) {
p := controller.NewPlanet(0, "Planet_0", uuid.New(), 1, 1, 1000, 300, 200, 10, game.ResearchDrive.AsType(uuid.Nil))
(&p).Colonists = 100.
assert.Equal(t, 0., p.Material)
assert.Equal(t, 0., p.Material.F())
controller.BombPlanet(&p, 55.)
assert.Equal(t, 245., p.Population)
assert.Equal(t, 45., p.Colonists)
assert.Equal(t, 145., p.Industry)
assert.Equal(t, 55., p.Material)
assert.Equal(t, 245., p.Population.F())
assert.Equal(t, 45., p.Colonists.F())
assert.Equal(t, 145., p.Industry.F())
assert.Equal(t, 55., p.Material.F())
controller.BombPlanet(&p, 56.)
assert.Equal(t, 189., p.Population)
assert.Equal(t, 0., p.Colonists)
assert.Equal(t, 89., p.Industry)
assert.Equal(t, 111., p.Material)
assert.Equal(t, 189., p.Population.F())
assert.Equal(t, 0., p.Colonists.F())
assert.Equal(t, 89., p.Industry.F())
assert.Equal(t, 111., p.Material.F())
controller.BombPlanet(&p, 200.)
assert.Equal(t, 0., p.Population)
assert.Equal(t, 0., p.Colonists)
assert.Equal(t, 0., p.Industry)
assert.Equal(t, 200., p.Material)
assert.Equal(t, 0., p.Population.F())
assert.Equal(t, 0., p.Colonists.F())
assert.Equal(t, 0., p.Industry.F())
assert.Equal(t, 200., p.Material.F())
}
func TestCollectBombingGroups(t *testing.T) {
@@ -126,19 +126,19 @@ func TestProduceBombings(t *testing.T) {
case R1_Planet_1_num:
assert.Equal(t, Race_1.Name, r.Owner)
assert.Equal(t, Race_0.Name, r.Attacker)
assert.InDelta(t, 697.857, r.AttackPower, 0.0003)
assert.InDelta(t, 697.857, r.AttackPower.F(), 0.0003)
assert.True(t, r.Wiped)
assert.Equal(t, uuid.Nil, c.MustPlanet(pn).Owner)
assert.Empty(t, c.MustPlanet(pn).Route)
assert.Equal(t, 0., c.MustPlanet(pn).Population)
assert.Equal(t, 0., c.MustPlanet(pn).Population.F())
case R0_Planet_2_num:
assert.Equal(t, Race_0.Name, r.Owner)
assert.Equal(t, Race_1.Name, r.Attacker)
assert.InDelta(t, 358.85596, r.AttackPower, 0.000001)
assert.Equal(t, 358.856, r.AttackPower.F())
assert.False(t, r.Wiped)
assert.Equal(t, Race_0_ID, c.MustPlanet(pn).Owner)
assert.NotEmpty(t, c.MustPlanet(pn).Route)
assert.InDelta(t, 500.-358.85596, c.MustPlanet(pn).Population, 0.000001)
assert.InDelta(t, 500.-358.85596, c.MustPlanet(pn).Population.F(), 0.000001)
}
}
}
internal/controller/fleet_send.go
+1 -1
View File
@@ -34,7 +34,7 @@ func (c *Cache) SendFleet(ri, fi int, planetNumber uint) error {
if !ok {
return e.NewEntityNotExistsError("destination planet #%d", planetNumber)
}
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X, p1.Y, p2.X, p2.Y)
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X.F(), p1.Y.F(), p2.X.F(), p2.Y.F())
if rangeToDestination > c.g.Race[ri].FlightDistance() {
return e.NewSendUnreachableDestinationError("range=%.03f", rangeToDestination)
}
internal/controller/generate_game.go
+6 -6
View File
@@ -134,16 +134,16 @@ func NewPlanet(num uint, name string, owner uuid.UUID, x, y, size, pop, ind, res
PlanetReport: game.PlanetReport{
UninhabitedPlanet: game.UninhabitedPlanet{
UnidentifiedPlanet: game.UnidentifiedPlanet{
X: x,
Y: y,
X: game.F(x),
Y: game.F(y),
Number: num,
},
Size: size,
Size: game.F(size),
Name: name,
Resources: res,
Resources: game.F(res),
},
Population: pop,
Industry: ind,
Population: game.F(pop),
Industry: game.F(ind),
Production: prod,
},
}
internal/controller/planet.go
+7 -7
View File
@@ -108,7 +108,7 @@ func (c *Cache) PlanetProduction(ri int, number int, prod game.ProductionType, s
if p.Production.Type == game.ProductionShip && (prod != game.ProductionShip || *subjectID != *p.Production.SubjectID) {
mat, _ := c.MustShipType(ri, *p.Production.SubjectID).ProductionCost()
p.Material += mat * (*p.Production.Progress)
p.Mat(p.Material.F() + mat*(*p.Production.Progress))
*p.Production.Progress = 0.
} else if prod == game.ProductionShip {
// new ship class to produce; otherwise we must have been returned from the func earlier
@@ -265,15 +265,15 @@ func (c *Cache) listProducingPlanets() iter.Seq[uint] {
// Internal funcs
func (c *Cache) putPopulation(pn uint, v float64) {
c.MustPlanet(pn).Population = v
c.MustPlanet(pn).Pop(v)
}
func (c *Cache) putColonists(pn uint, v float64) {
c.MustPlanet(pn).Colonists = v
c.MustPlanet(pn).Col(v)
}
func (c *Cache) putMaterial(pn uint, v float64) {
c.MustPlanet(pn).Material = v
c.MustPlanet(pn).Mat(v)
}
func ProduceShip(p *game.Planet, shipMass float64) uint {
@@ -281,20 +281,20 @@ func ProduceShip(p *game.Planet, shipMass float64) uint {
if productionAvailable <= 0 {
return 0
}
CAP_perShip := shipMass / p.Resources
CAP_perShip := shipMass / p.Resources.F()
productionForMass := shipMass * 10.
ships := uint(0)
flZero := 0.
p.Production.Progress = &flZero
for productionAvailable > 0 {
var productionExtraCAP float64
if CAP_deficit := p.Capital - CAP_perShip; CAP_deficit < 0 {
if CAP_deficit := p.Capital.F() - CAP_perShip; CAP_deficit < 0 {
productionExtraCAP = -CAP_deficit
}
productionCost := productionExtraCAP + productionForMass
if productionAvailable >= productionCost {
productionAvailable -= productionCost
p.Capital = p.Capital - (CAP_perShip - productionExtraCAP)
p.Cap(p.Capital.F() - (CAP_perShip - productionExtraCAP))
ships++
} else {
progress := productionAvailable / productionCost
internal/controller/planet_test.go
+9 -9
View File
@@ -152,7 +152,7 @@ func TestProduceShips(t *testing.T) {
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 1)
assert.Equal(t, uint(7), c.ShipGroup(0).Number)
assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SHIP", "Drone"))
assert.InDelta(t, shipMass*progress, c.MustPlanet(R0_Planet_0_num).Material, 0.00001) // 99.(0099) material build
assert.InDelta(t, shipMass*progress, c.MustPlanet(R0_Planet_0_num).Material.F(), 0.00001) // 99.(0099) material build
c.MustPlanet(R0_Planet_0_num).Material = 0
c.MustPlanet(R0_Planet_0_num).Colonists = 0
@@ -197,7 +197,7 @@ func TestProduceShip(t *testing.T) {
r = controller.ProduceShip(&p, Drone.EmptyMass())
assert.Equal(t, uint(100), r)
assert.Equal(t, 0., *p.Production.Progress)
assert.Equal(t, 0., number.Fixed3(p.Capital)) // TODO: zero CAP is not actual '0.0' after series of decrements
assert.Equal(t, 0., number.Fixed3(p.Capital.F())) // TODO: zero CAP is not actual '0.0' after series of decrements
(&p).Production = game.ProductionShip.AsType(uuid.Nil)
(&p).Capital = 0.
@@ -242,17 +242,17 @@ func TestTurnPlanetProductions(t *testing.T) {
pn := int(R0_Planet_0_num)
assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "CAP", ""))
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Capital)
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Colonists)
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Capital.F())
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Colonists.F())
c.TurnPlanetProductions()
assert.InDelta(t, 196., c.MustPlanet(R0_Planet_0_num).Capital, 0.1)
assert.InDelta(t, 10.0, c.MustPlanet(R0_Planet_0_num).Colonists, 0.000001) // FIXME: should store more exact value
assert.InDelta(t, 196., c.MustPlanet(R0_Planet_0_num).Capital.F(), 0.1)
assert.InDelta(t, 10.0, c.MustPlanet(R0_Planet_0_num).Colonists.F(), 0.000001) // FIXME: should store more exact value
assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "MAT", ""))
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Material.F())
c.TurnPlanetProductions()
assert.Equal(t, 10000., c.MustPlanet(R0_Planet_0_num).Material)
assert.InDelta(t, 20.0, c.MustPlanet(R0_Planet_0_num).Colonists, 0.000001)
assert.Equal(t, 10000., c.MustPlanet(R0_Planet_0_num).Material.F())
assert.InDelta(t, 20.0, c.MustPlanet(R0_Planet_0_num).Colonists.F(), 0.000001)
assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "DRIVE", ""))
assert.Equal(t, 1.1, c.Race(Race_0_idx).TechLevel(game.TechDrive))
internal/controller/route.go
+8 -8
View File
@@ -39,7 +39,7 @@ func (c *Cache) SetRoute(ri int, rt game.RouteType, origin, destination uint) er
if !ok {
return e.NewEntityNotExistsError("destination planet #%d", destination)
}
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X, p1.Y, p2.X, p2.Y)
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X.F(), p1.Y.F(), p2.X.F(), p2.Y.F())
if rangeToDestination > c.g.Race[ri].FlightDistance() {
return e.NewSendUnreachableDestinationError("range=%.03f max=%.03f", rangeToDestination, c.g.Race[ri].FlightDistance())
}
@@ -127,7 +127,7 @@ func (c *Cache) SendRoutedGroups() {
if !ok {
continue
}
var res *float64
var res *game.Float
var ct game.CargoType
switch rt {
case game.RouteColonist:
@@ -152,7 +152,7 @@ func (c *Cache) SendRoutedGroups() {
st := c.ShipGroupShipClass(sgi)
ships := sg.Number
sgCapacity := sg.CargoCapacity(st)
toLoad := *res
toLoad := (*res).F()
if toLoad > sgCapacity {
toLoad = sgCapacity
} else if maxShips := uint(math.Ceil(toLoad / (sgCapacity / float64(ships)))); maxShips < ships {
@@ -160,9 +160,9 @@ func (c *Cache) SendRoutedGroups() {
sg = c.ShipGroup(newGroupIdx)
}
// decrease planet resource
*res = *res - toLoad
*res = (*res).Add(-toLoad)
// load group
sg.Load += toLoad
sg.Load = sg.Load.Add(toLoad)
sg.CargoType = &ct
c.LaunchShips(sg, dest)
groups = reorderGroups(groups)
@@ -214,7 +214,7 @@ func (c *Cache) RemoveUnreachableRoutes() {
ri := c.RaceIndex(p1.Owner)
for rt, destination := range p1.Route {
p2 := c.MustPlanet(destination)
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X, p1.Y, p2.X, p2.Y)
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X.F(), p1.Y.F(), p2.X.F(), p2.Y.F())
if rangeToDestination > c.g.Race[ri].FlightDistance() {
delete(p1.Route, rt)
}
@@ -224,7 +224,7 @@ func (c *Cache) RemoveUnreachableRoutes() {
func (c *Cache) doUnload(groups iter.Seq[int]) {
for sgi := range groups {
c.unsafeUnloadCargo(sgi, c.ShipGroup(sgi).Load)
c.unsafeUnloadCargo(sgi, c.ShipGroup(sgi).Load.F())
}
}
@@ -255,7 +255,7 @@ func (c *Cache) selectColUnloadGroup(groups []int) (result iter.Seq[int]) {
sg := c.ShipGroup(i)
ri := c.RaceIndex(sg.OwnerID)
groupByRace[ri] = append(groupByRace[ri], i)
loadByRace[ri] += sg.Load
loadByRace[ri] += sg.Load.F()
}
if len(loadByRace) < 2 {
// only one race has to unload cargo
internal/controller/route_test.go
+18 -18
View File
@@ -129,7 +129,7 @@ func TestListRoutedSendGroupIds(t *testing.T) {
assert.Equal(t, Race_0_ID, sg.OwnerID)
assert.Greater(t, sg.CargoCapacity(st), 0.)
assert.Equal(t, game.StateInOrbit, sg.State())
assert.Equal(t, 0., sg.Load)
assert.Equal(t, 0., sg.Load.F())
assert.Nil(t, sg.FleetID)
}
}
@@ -149,11 +149,11 @@ func TestEnrouteGroups_SplitGroup(t *testing.T) {
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 2)
assert.Equal(t, game.StateInOrbit, c.ShipGroup(0).State())
assert.Equal(t, uint(1), c.ShipGroup(0).Number)
assert.Equal(t, 0., c.ShipGroup(0).Load)
assert.Equal(t, 0., c.ShipGroup(0).Load.F())
assert.Equal(t, game.StateLaunched, c.ShipGroup(1).State())
assert.Equal(t, uint(4), c.ShipGroup(1).Number)
assert.Equal(t, 65., c.ShipGroup(1).Load)
assert.Equal(t, 0., c.MustPlanet(R0_Planet_0_num).Colonists)
assert.Equal(t, 65., c.ShipGroup(1).Load.F())
assert.Equal(t, 0., c.MustPlanet(R0_Planet_0_num).Colonists.F())
}
func TestEnrouteGroups_GroupSorting(t *testing.T) {
@@ -177,8 +177,8 @@ func TestEnrouteGroups_GroupSorting(t *testing.T) {
assert.Equal(t, game.StateInOrbit, c.ShipGroup(0).State())
assert.Equal(t, game.StateLaunched, c.ShipGroup(1).State())
assert.Equal(t, 100., c.ShipGroup(1).Load)
assert.Equal(t, 0., c.MustPlanet(R0_Planet_0_num).Colonists)
assert.Equal(t, 100., c.ShipGroup(1).Load.F())
assert.Equal(t, 0., c.MustPlanet(R0_Planet_0_num).Colonists.F())
}
func TestEnrouteGroups_LaunchOrder(t *testing.T) {
@@ -215,7 +215,7 @@ func TestEnrouteGroups_LaunchOrder(t *testing.T) {
sgi := 0
assert.Equal(t, game.StateLaunched, c.ShipGroup(sgi).State())
assert.Equal(t, R0_Planet_2_num, c.ShipGroup(sgi).Destination)
assert.Equal(t, 105., c.ShipGroup(sgi).Load)
assert.Equal(t, 105., c.ShipGroup(sgi).Load.F())
assert.NotNil(t, c.ShipGroup(sgi).CargoType)
assert.Equal(t, game.CargoColonist, *c.ShipGroup(sgi).CargoType)
assert.Equal(t, uint(5), c.ShipGroup(sgi).Number)
@@ -224,7 +224,7 @@ func TestEnrouteGroups_LaunchOrder(t *testing.T) {
sgi = 3
assert.Equal(t, game.StateLaunched, c.ShipGroup(sgi).State())
assert.Equal(t, R0_Planet_2_num, c.ShipGroup(sgi).Destination)
assert.Equal(t, 45., c.ShipGroup(sgi).Load)
assert.Equal(t, 45., c.ShipGroup(sgi).Load.F())
assert.NotNil(t, c.ShipGroup(sgi).CargoType)
assert.Equal(t, game.CargoColonist, *c.ShipGroup(sgi).CargoType)
assert.Equal(t, uint(3), c.ShipGroup(sgi).Number)
@@ -233,7 +233,7 @@ func TestEnrouteGroups_LaunchOrder(t *testing.T) {
sgi = 2
assert.Equal(t, game.StateLaunched, c.ShipGroup(sgi).State())
assert.Equal(t, R0_Planet_2_num, c.ShipGroup(sgi).Destination)
assert.Equal(t, 100., c.ShipGroup(sgi).Load)
assert.Equal(t, 100., c.ShipGroup(sgi).Load.F())
assert.NotNil(t, c.ShipGroup(sgi).CargoType)
assert.Equal(t, game.CargoCapital, *c.ShipGroup(sgi).CargoType)
assert.Equal(t, uint(5), c.ShipGroup(sgi).Number)
@@ -242,7 +242,7 @@ func TestEnrouteGroups_LaunchOrder(t *testing.T) {
sgi = 4
assert.Equal(t, game.StateLaunched, c.ShipGroup(sgi).State())
assert.Equal(t, R0_Planet_2_num, c.ShipGroup(sgi).Destination)
assert.Equal(t, 20., c.ShipGroup(sgi).Load)
assert.Equal(t, 20., c.ShipGroup(sgi).Load.F())
assert.NotNil(t, c.ShipGroup(sgi).CargoType)
assert.Equal(t, game.CargoMaterial, *c.ShipGroup(sgi).CargoType)
assert.Equal(t, uint(1), c.ShipGroup(sgi).Number)
@@ -251,7 +251,7 @@ func TestEnrouteGroups_LaunchOrder(t *testing.T) {
sgi = 1
assert.Equal(t, game.StateLaunched, c.ShipGroup(sgi).State())
assert.Equal(t, R1_Planet_1_num, c.ShipGroup(sgi).Destination)
assert.Equal(t, 0., c.ShipGroup(sgi).Load)
assert.Equal(t, 0., c.ShipGroup(sgi).Load.F())
assert.Nil(t, c.ShipGroup(sgi).CargoType)
assert.Equal(t, uint(1), c.ShipGroup(sgi).Number)
}
@@ -406,15 +406,15 @@ func TestTurnUnloadEnroutedGroups(t *testing.T) {
c.TurnUnloadEnroutedGroups()
assert.Equal(t, 0., c.ShipGroup(0).Load)
assert.Equal(t, 222., c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, 0., c.ShipGroup(1).Load)
assert.Equal(t, 11., c.MustPlanet(R0_Planet_0_num).Capital)
assert.Equal(t, 0., c.ShipGroup(2).Load)
assert.Equal(t, 96.8, c.MustPlanet(Uninhabited_Planet_4_num).Population)
assert.Equal(t, 0., c.ShipGroup(0).Load.F())
assert.Equal(t, 222., c.MustPlanet(R0_Planet_0_num).Material.F())
assert.Equal(t, 0., c.ShipGroup(1).Load.F())
assert.Equal(t, 11., c.MustPlanet(R0_Planet_0_num).Capital.F())
assert.Equal(t, 0., c.ShipGroup(2).Load.F())
assert.Equal(t, 96.8, c.MustPlanet(Uninhabited_Planet_4_num).Population.F())
assert.Equal(t, Race_1_ID, c.MustPlanet(Uninhabited_Planet_4_num).Owner)
assert.Equal(t, game.ProductionCapital, c.MustPlanet(Uninhabited_Planet_4_num).Production.Type)
assert.Equal(t, 17.3, c.ShipGroup(3).Load)
assert.Equal(t, 17.3, c.ShipGroup(3).Load.F())
}
func TestRemoveUnreachableRoutes(t *testing.T) {
internal/controller/ship_group.go
+17 -17
View File
@@ -61,7 +61,7 @@ func (c *Cache) ShipGroupJoinFleet(groupIndex int, fID *uuid.UUID) {
func (c *Cache) ShipGroupShipsNumber(groupIndex int, number uint) {
c.validateShipGroupIndex(groupIndex)
if c.g.ShipGroups[groupIndex].Number > 0 {
c.g.ShipGroups[groupIndex].Load = c.g.ShipGroups[groupIndex].Load / float64(c.g.ShipGroups[groupIndex].Number) * float64(number)
c.g.ShipGroups[groupIndex].Load = game.F(c.g.ShipGroups[groupIndex].Load.F() / float64(c.g.ShipGroups[groupIndex].Number) * float64(number))
}
c.g.ShipGroups[groupIndex].Number = number
}
@@ -228,20 +228,20 @@ func (c *Cache) DisassembleGroup(ri int, groupIndex, quantity uint) error {
if c.ShipGroup(sgi).CargoType != nil {
ct := *c.ShipGroup(sgi).CargoType
load := c.ShipGroup(sgi).Load
load := c.ShipGroup(sgi).Load.F()
switch ct {
case game.CargoColonist:
if p.Owner == c.g.Race[ri].ID {
p = game.UnloadColonists(p, load)
}
case game.CargoMaterial:
p.Material += load
p.Material = p.Material.Add(load)
case game.CargoCapital:
p.Capital += load
p.Capital = p.Capital.Add(load)
}
}
p.Material += c.ShipGroup(sgi).EmptyMass(st)
p.Material = p.Material.Add(c.ShipGroup(sgi).EmptyMass(st))
c.unsafeDeleteShipGroup(sgi)
@@ -300,11 +300,11 @@ func (c *Cache) LoadCargo(ri int, groupIndex uint, ct game.CargoType, ships uint
sgi = nsgi
}
capacity := c.ShipGroup(sgi).CargoCapacity(st)
freeShipGroupCargoLoad := capacity - c.ShipGroup(sgi).Load
freeShipGroupCargoLoad := capacity - c.ShipGroup(sgi).Load.F()
if freeShipGroupCargoLoad == 0 {
return e.NewCargoLoadNoSpaceLeftError()
}
var availableOnPlanet *float64
var availableOnPlanet *game.Float
switch ct {
case game.CargoMaterial:
availableOnPlanet = &p.Material
@@ -315,18 +315,18 @@ func (c *Cache) LoadCargo(ri int, groupIndex uint, ct game.CargoType, ships uint
default:
return e.NewGameStateError("CargoType not accepted: %v", ct)
}
if quantity > *availableOnPlanet || *availableOnPlanet == 0 {
if quantity > float64(*availableOnPlanet) || *availableOnPlanet == 0 {
return e.NewCargoLoadNotEnoughError("planet: #%d, %s=%.03f", p.Number, ct, *availableOnPlanet)
}
toBeLoaded := quantity
if quantity == 0 {
toBeLoaded = *availableOnPlanet
toBeLoaded = float64(*availableOnPlanet)
}
if toBeLoaded > freeShipGroupCargoLoad {
toBeLoaded = freeShipGroupCargoLoad
}
*availableOnPlanet = *availableOnPlanet - toBeLoaded
c.ShipGroup(sgi).Load += toBeLoaded
*availableOnPlanet = (*availableOnPlanet).Add(-toBeLoaded)
c.ShipGroup(sgi).Load = c.ShipGroup(sgi).Load.Add(toBeLoaded)
if c.ShipGroup(sgi).Load > 0 {
c.ShipGroup(sgi).CargoType = &ct
}
@@ -379,9 +379,9 @@ func (c *Cache) UnloadCargo(ri int, groupIndex uint, ships uint, quantity float6
toBeUnloaded := quantity
if quantity == 0 {
toBeUnloaded = c.ShipGroup(sgi).Load
toBeUnloaded = c.ShipGroup(sgi).Load.F()
}
if toBeUnloaded > c.ShipGroup(sgi).Load {
if toBeUnloaded > c.ShipGroup(sgi).Load.F() {
return e.NewCargoUnoadNotEnoughError("load: %.03f", c.ShipGroup(sgi).Load)
}
@@ -401,7 +401,7 @@ func (c *Cache) unsafeUnloadCargo(sgi int, q float64) {
p := c.MustPlanet(c.ShipGroup(sgi).Destination)
ct := *c.ShipGroup(sgi).CargoType
var availableOnPlanet *float64
var availableOnPlanet *game.Float
switch ct {
case game.CargoColonist:
availableOnPlanet = &p.Colonists
@@ -414,9 +414,9 @@ func (c *Cache) unsafeUnloadCargo(sgi int, q float64) {
case game.CargoCapital:
availableOnPlanet = &p.Capital
}
*availableOnPlanet += q
*availableOnPlanet = (*availableOnPlanet).Add(q)
c.ShipGroup(sgi).Load -= q // TODO: apply rounding for Load property?
c.ShipGroup(sgi).Load = c.ShipGroup(sgi).Load.Add(-q) // TODO: apply rounding for Load property?
if c.ShipGroup(sgi).Load == 0 {
c.ShipGroup(sgi).CargoType = nil
}
@@ -532,7 +532,7 @@ func (c *Cache) breakGroupSafe(ri int, groupIndex uint, newGroupShips uint) (int
func (c *Cache) breakGroupUnsafe(ri, sgi int, newGroupShips uint) int {
newGroup := *c.ShipGroup(sgi)
if c.ShipGroup(sgi).CargoType != nil {
newGroup.Load = c.ShipGroup(sgi).Load / float64(c.ShipGroup(sgi).Number) * float64(newGroupShips)
newGroup.Load = game.F(c.ShipGroup(sgi).Load.F() / float64(c.ShipGroup(sgi).Number) * float64(newGroupShips))
}
newGroup.Number = newGroupShips
c.ShipGroupShipsNumber(sgi, c.ShipGroup(sgi).Number-newGroup.Number)
internal/controller/ship_group_move.go
+1 -1
View File
@@ -40,7 +40,7 @@ func (c *Cache) moveShipGroup(i int, delta float64) {
destPlanet := c.MustPlanet(sg.Destination)
arrived := false
sg.StateInSpace.X, sg.StateInSpace.Y, arrived =
util.NextTravelCoord(c.g.Map.Width, c.g.Map.Height, originX, originY, destPlanet.X, destPlanet.Y, delta)
util.NextTravelCoord(c.g.Map.Width, c.g.Map.Height, originX, originY, destPlanet.X.F(), destPlanet.Y.F(), delta)
if arrived {
sg.StateInSpace = nil
}
internal/controller/ship_group_send.go
+2 -2
View File
@@ -44,7 +44,7 @@ func (c *Cache) SendGroup(ri int, groupIndex, planetNumber, quantity uint) error
if !ok {
return e.NewEntityNotExistsError("destination planet #%d", planetNumber)
}
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X, p1.Y, p2.X, p2.Y)
rangeToDestination := util.ShortDistance(c.g.Map.Width, c.g.Map.Height, p1.X.F(), p1.Y.F(), p2.X.F(), p2.Y.F())
if rangeToDestination > c.g.Race[ri].FlightDistance() {
return e.NewSendUnreachableDestinationError("range=%.03f", rangeToDestination)
}
@@ -81,7 +81,7 @@ func (c *Cache) LaunchShips(sg *game.ShipGroup, destination uint) *game.ShipGrou
default:
panic("state invalid")
}
c.g.ShipGroups[i] = LaunchShips(*sg, destination, p.X, p.Y)
c.g.ShipGroups[i] = LaunchShips(*sg, destination, p.X.F(), p.Y.F())
return &c.g.ShipGroups[i]
}
}
internal/controller/ship_group_send_test.go
+4 -4
View File
@@ -51,8 +51,8 @@ func TestSendGroup(t *testing.T) {
assert.Equal(t, uint(3), c.ShipGroup(3).Number)
assert.Equal(t, game.StateLaunched, c.ShipGroup(3).State())
assert.NotNil(t, c.ShipGroup(3).StateInSpace)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).X, c.ShipGroup(3).StateInSpace.X)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).Y, c.ShipGroup(3).StateInSpace.Y)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).X.F(), c.ShipGroup(3).StateInSpace.X)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).Y.F(), c.ShipGroup(3).StateInSpace.Y)
assert.NoError(t, g.SendGroup(Race_0.Name, 4, R0_Planet_0_num, 2)) // un-send 2 of 3
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
@@ -61,8 +61,8 @@ func TestSendGroup(t *testing.T) {
assert.Equal(t, uint(1), c.MustShipGroup(Race_0_idx, 4).Number)
assert.Equal(t, game.StateLaunched, c.MustShipGroup(Race_0_idx, 4).State())
assert.NotNil(t, c.MustShipGroup(Race_0_idx, 4).StateInSpace)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).X, c.MustShipGroup(Race_0_idx, 4).StateInSpace.X)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).Y, c.MustShipGroup(Race_0_idx, 4).StateInSpace.Y)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).X.F(), c.MustShipGroup(Race_0_idx, 4).StateInSpace.X)
assert.Equal(t, c.MustPlanet(R0_Planet_0_num).Y.F(), c.MustShipGroup(Race_0_idx, 4).StateInSpace.Y)
assert.NoError(t, g.SendGroup(Race_0.Name, 4, R0_Planet_0_num, 0)) // un-send the rest 1
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
internal/controller/ship_group_test.go
+38 -38
View File
@@ -142,9 +142,9 @@ func TestBreakGroup(t *testing.T) {
assert.NotNil(t, c.ShipGroup(3).FleetID)
assert.Equal(t, game.CargoColonist.Ref(), c.ShipGroup(0).CargoType)
assert.Equal(t, 24.6, number.Fixed3(c.ShipGroup(0).Load))
assert.Equal(t, 24.6, number.Fixed3(c.ShipGroup(0).Load.F()))
assert.Equal(t, game.CargoColonist.Ref(), c.ShipGroup(3).CargoType)
assert.Equal(t, 8.2, number.Fixed3(c.ShipGroup(3).Load))
assert.Equal(t, 8.2, number.Fixed3(c.ShipGroup(3).Load.F()))
// group #1 -> MAX 6 off the fleet
assert.NoError(t, g.BreakGroup(Race_0.Name, 1, 6)) // group #1 (0)
@@ -295,48 +295,48 @@ func TestLoadCargo(t *testing.T) {
// break group and load maximum
assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 2, 0))
assert.Equal(t, 58.0, c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, 58.0, c.MustPlanet(R0_Planet_0_num).Material.F())
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 6)
assert.Nil(t, c.ShipGroup(0).CargoType)
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(5).CargoType)
assert.Equal(t, uint(9), c.ShipGroup(0).Number)
assert.Equal(t, 0.0, c.ShipGroup(0).Load)
assert.Equal(t, 0.0, c.ShipGroup(0).Load.F())
assert.Equal(t, uint(2), c.ShipGroup(5).Number)
assert.Equal(t, 42.0, c.ShipGroup(5).Load)
assert.Equal(t, 42.0, c.ShipGroup(5).Load.F())
// break group and load limited
assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 2, 18))
assert.Equal(t, 40.0, c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, 40.0, c.MustPlanet(R0_Planet_0_num).Material.F())
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
assert.Nil(t, c.ShipGroup(0).CargoType)
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(6).CargoType)
assert.Equal(t, uint(7), c.ShipGroup(0).Number)
assert.Equal(t, 0.0, c.ShipGroup(0).Load)
assert.Equal(t, 0.0, c.ShipGroup(0).Load.F())
assert.Equal(t, uint(2), c.ShipGroup(6).Number)
assert.Equal(t, 18.0, c.ShipGroup(6).Load)
assert.Equal(t, 18.0, c.ShipGroup(6).Load.F())
// add cargo to planet
c.PutMaterial(R0_Planet_0_num, 100)
// loading all available cargo
assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 0, 0))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, 100.0, c.ShipGroup(0).Load) // free: 131.0
assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Material.F())
assert.Equal(t, 100.0, c.ShipGroup(0).Load.F()) // free: 131.0
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(0).CargoType)
// add cargo to planet
c.PutMaterial(R0_Planet_0_num, 200)
assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 11, 31))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
assert.Equal(t, 169.0, c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, 131.0, c.ShipGroup(0).Load) // free: 100.0
assert.Equal(t, 169.0, c.MustPlanet(R0_Planet_0_num).Material.F())
assert.Equal(t, 131.0, c.ShipGroup(0).Load.F()) // free: 100.0
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(0).CargoType)
// load to maximum cargo space left
assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 11, 0))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
assert.Equal(t, 153.0, c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, 147.0, c.ShipGroup(0).Load) // free: 0.0
assert.Equal(t, 153.0, c.MustPlanet(R0_Planet_0_num).Material.F())
assert.Equal(t, 147.0, c.ShipGroup(0).Load.F()) // free: 0.0
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(0).CargoType)
// ship group is full
@@ -413,33 +413,33 @@ func TestUnloadCargo(t *testing.T) {
// unload MAT on foreign planet / break group
assert.NoError(t, g.UnloadCargo(Race_0.Name, 6, 3, 0))
assert.Equal(t, 27.273, number.Fixed3(c.MustPlanet(R1_Planet_1_num).Material))
assert.Equal(t, 27.273, number.Fixed3(c.MustPlanet(R1_Planet_1_num).Material.F()))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
assert.Equal(t, uint(3), c.ShipGroup(6).Number)
assert.Nil(t, c.ShipGroup(6).CargoType)
assert.Equal(t, 0.0, c.ShipGroup(6).Load)
assert.Equal(t, 0.0, c.ShipGroup(6).Load.F())
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(5).CargoType)
assert.Equal(t, uint(8), c.ShipGroup(5).Number)
assert.Equal(t, 72.727, number.Fixed3(c.ShipGroup(5).Load))
assert.Equal(t, 72.727, number.Fixed3(c.ShipGroup(5).Load.F()))
// unload MAT on foreign planet / break group / limited MAT
assert.NoError(t, g.UnloadCargo(Race_0.Name, 6, 3, 20.0))
assert.Equal(t, 47.273, number.Fixed3(c.MustPlanet(R1_Planet_1_num).Material))
assert.Equal(t, 47.273, number.Fixed3(c.MustPlanet(R1_Planet_1_num).Material.F()))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 8)
assert.Equal(t, uint(3), c.ShipGroup(7).Number)
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(7).CargoType)
assert.Equal(t, 7.273, number.Fixed3(c.ShipGroup(7).Load))
assert.Equal(t, 7.273, number.Fixed3(c.ShipGroup(7).Load.F()))
assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(5).CargoType)
assert.Equal(t, uint(5), c.ShipGroup(5).Number)
assert.Equal(t, 45.455, number.Fixed3(c.ShipGroup(5).Load))
assert.Equal(t, 45.455, number.Fixed3(c.ShipGroup(5).Load.F()))
// unload ALL
assert.NoError(t, g.UnloadCargo(Race_0.Name, 1, 0, 0))
assert.Equal(t, 100.0, number.Fixed3(c.MustPlanet(R0_Planet_0_num).Colonists))
assert.Equal(t, 100.0, number.Fixed3(c.MustPlanet(R0_Planet_0_num).Colonists.F()))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 8)
assert.Equal(t, uint(10), c.ShipGroup(0).Number)
assert.Nil(t, c.ShipGroup(0).CargoType)
assert.Equal(t, 0.0, number.Fixed3(c.ShipGroup(0).Load))
assert.Equal(t, 0.0, number.Fixed3(c.ShipGroup(0).Load.F()))
}
func TestDisassembleGroup(t *testing.T) {
@@ -489,40 +489,40 @@ func TestDisassembleGroup(t *testing.T) {
e.GenericErrorText(e.ErrBeakGroupNumberNotEnough))
groupEmptyMass := c.ShipGroup(4).EmptyMass(c.MustShipClass(Race_0_idx, Race_0_Freighter))
planetMAT := c.MustPlanet(R1_Planet_1_num).Material
planetCOL := c.MustPlanet(R1_Planet_1_num).Colonists
planetMAT := c.MustPlanet(R1_Planet_1_num).Material.F()
planetCOL := c.MustPlanet(R1_Planet_1_num).Colonists.F()
assert.NoError(t, g.DisassembleGroup(Race_0.Name, 5, 0))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
assert.Equal(t, planetMAT+groupEmptyMass, c.MustPlanet(R1_Planet_1_num).Material)
assert.Equal(t, planetCOL, c.MustPlanet(R1_Planet_1_num).Colonists)
assert.Equal(t, planetMAT+groupEmptyMass, c.MustPlanet(R1_Planet_1_num).Material.F())
assert.Equal(t, planetCOL, c.MustPlanet(R1_Planet_1_num).Colonists.F())
groupEmptyMass = c.ShipGroup(3).EmptyMass(c.MustShipClass(Race_0_idx, Race_0_Freighter))
groupLoadMAT := c.ShipGroup(3).Load
planetMAT = c.MustPlanet(R1_Planet_1_num).Material
groupLoadMAT := c.ShipGroup(3).Load.F()
planetMAT = c.MustPlanet(R1_Planet_1_num).Material.F()
assert.NoError(t, g.DisassembleGroup(Race_0.Name, 4, 0))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
assert.Equal(t, planetMAT+groupEmptyMass+groupLoadMAT, c.MustPlanet(R1_Planet_1_num).Material)
assert.Equal(t, planetMAT+groupEmptyMass+groupLoadMAT, c.MustPlanet(R1_Planet_1_num).Material.F())
groupEmptyMass = c.ShipGroup(2).EmptyMass(c.MustShipClass(Race_0_idx, Race_0_Freighter))
planetMAT = c.MustPlanet(R0_Planet_0_num).Material
planetCOL = c.MustPlanet(R0_Planet_0_num).Colonists
planetMAT = c.MustPlanet(R0_Planet_0_num).Material.F()
planetCOL = c.MustPlanet(R0_Planet_0_num).Colonists.F()
planetPOP := 90.0
c.PutPopulation(R0_Planet_0_num, planetPOP)
assert.Equal(t, planetPOP, c.MustPlanet(R0_Planet_0_num).Population)
assert.Equal(t, planetPOP, c.MustPlanet(R0_Planet_0_num).Population.F())
var quantity uint = 3
groupEmptyMass = groupEmptyMass / float64(c.ShipGroup(2).Number) * float64(quantity)
newGroupUnloadedCOL := c.ShipGroup(2).Load / float64(c.ShipGroup(2).Number) * float64(quantity)
newGroupUnloadedCOL := c.ShipGroup(2).Load.F() / float64(c.ShipGroup(2).Number) * float64(quantity)
expectPOPIncrease := newGroupUnloadedCOL * 8
freePOPLeft := c.MustPlanet(R0_Planet_0_num).Size - c.MustPlanet(R0_Planet_0_num).Population
freePOPLeft := c.MustPlanet(R0_Planet_0_num).Size.F() - c.MustPlanet(R0_Planet_0_num).Population.F()
expectAddedCOL := (expectPOPIncrease - freePOPLeft) / 8
expectAddedPOP := freePOPLeft
assert.NoError(t, g.DisassembleGroup(Race_0.Name, 3, quantity))
assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
assert.Equal(t, planetCOL+expectAddedCOL, c.MustPlanet(R0_Planet_0_num).Colonists)
assert.Equal(t, planetPOP+expectAddedPOP, c.MustPlanet(R0_Planet_0_num).Population)
assert.Equal(t, planetMAT+groupEmptyMass, c.MustPlanet(R0_Planet_0_num).Material)
assert.Equal(t, planetCOL+expectAddedCOL, c.MustPlanet(R0_Planet_0_num).Colonists.F())
assert.Equal(t, planetPOP+expectAddedPOP, c.MustPlanet(R0_Planet_0_num).Population.F())
assert.Equal(t, planetMAT+groupEmptyMass, c.MustPlanet(R0_Planet_0_num).Material.F())
assert.Equal(t, uint(7), c.ShipGroup(2).Number)
assert.Equal(t, 56.0, c.ShipGroup(2).Load)
assert.Equal(t, 56.0, c.ShipGroup(2).Load.F())
}
internal/controller/ship_group_upgrade.go
+1 -1
View File
@@ -65,7 +65,7 @@ func (c *Cache) UpgradeGroup(ri int, groupIndex uint, techInput string, limitShi
if c.g.Race[ri].TechLevel(tech) < limitLevel {
return e.NewUpgradeTechLevelInsufficientError("%s=%.03f < %.03f", tech.String(), c.g.Race[ri].TechLevel(tech), limitLevel)
}
targetLevel[tech] = game.FutureUpgradeLevel(c.g.Race[ri].TechLevel(tech), c.ShipGroup(sgi).TechLevel(tech), limitLevel)
targetLevel[tech] = game.FutureUpgradeLevel(c.g.Race[ri].TechLevel(tech), c.ShipGroup(sgi).TechLevel(tech).F(), limitLevel)
} else {
targetLevel[tech] = game.CurrentUpgradingLevel(c.g.ShipGroups[sgi], tech)
}
internal/model/game/group.go
+13 -13
View File
@@ -107,7 +107,7 @@ type ShipGroup struct {
Number uint `json:"number"` // Number (quantity) ships of specific ShipType
CargoType *CargoType `json:"loadType,omitempty"`
Load float64 `json:"load"` // Cargo loaded - "Масса груза"
Load Float `json:"load"` // Cargo loaded - "Масса груза"
Tech TechSet `json:"tech"`
@@ -117,8 +117,8 @@ type ShipGroup struct {
StateUpgrade *InUpgrade `json:"stateUpgrade,omitempty"`
}
func (sg ShipGroup) TechLevel(t Tech) float64 {
return sg.Tech.Value(t)
func (sg ShipGroup) TechLevel(t Tech) Float {
return F(sg.Tech.Value(t))
}
// TODO: refactor to separate method with *ShipGroup as parameter
@@ -170,19 +170,19 @@ func (sg ShipGroup) Equal(other ShipGroup) bool {
sg.TechLevel(TechShields) == other.TechLevel(TechShields) &&
sg.TechLevel(TechCargo) == other.TechLevel(TechCargo) &&
sg.CargoType == other.CargoType &&
sg.Load/float64(sg.Number) == other.Load/float64(other.Number) &&
sg.Load.F()/float64(sg.Number) == other.Load.F()/float64(other.Number) &&
sg.State() == other.State()
}
// Грузоподъёмность
func (sg ShipGroup) CargoCapacity(st *ShipType) float64 {
return sg.TechLevel(TechCargo) * (st.Cargo + (st.Cargo*st.Cargo)/20) * float64(sg.Number)
return sg.TechLevel(TechCargo).F() * (st.Cargo + (st.Cargo*st.Cargo)/20) * float64(sg.Number)
}
// Масса перевозимого груза -
// общее количество единиц груза, деленное на технологический уровень Грузоперевозок
func (sg ShipGroup) CarryingMass() float64 {
return sg.Load / sg.TechLevel(TechCargo)
return sg.Load.F() / sg.TechLevel(TechCargo).F()
}
// Масса группы без учёта груза
@@ -199,7 +199,7 @@ func (sg ShipGroup) FullMass(st *ShipType) float64 {
// Эффективность двигателя -
// равна мощности Двигателей, умноженной на технологический уровень блока Двигателей
func (sg ShipGroup) DriveEffective(st *ShipType) float64 {
return st.Drive * sg.TechLevel(TechDrive)
return st.Drive * sg.TechLevel(TechDrive).F()
}
// Корабли перемещаются за один ход на количество световых лет, равное
@@ -209,27 +209,27 @@ func (sg ShipGroup) Speed(st *ShipType) float64 {
}
func (sg ShipGroup) UpgradeDriveCost(st *ShipType, drive float64) float64 {
return (1 - sg.TechLevel(TechDrive)/drive) * 10 * st.Drive
return (1 - sg.TechLevel(TechDrive).F()/drive) * 10 * st.Drive
}
// TODO: test on other values
func (sg ShipGroup) UpgradeWeaponsCost(st *ShipType, weapons float64) float64 {
return (1 - sg.TechLevel(TechWeapons)/weapons) * 10 * st.WeaponsBlockMass()
return (1 - sg.TechLevel(TechWeapons).F()/weapons) * 10 * st.WeaponsBlockMass()
}
func (sg ShipGroup) UpgradeShieldsCost(st *ShipType, shields float64) float64 {
return (1 - sg.TechLevel(TechShields)/shields) * 10 * st.Shields
return (1 - sg.TechLevel(TechShields).F()/shields) * 10 * st.Shields
}
func (sg ShipGroup) UpgradeCargoCost(st *ShipType, cargo float64) float64 {
return (1 - sg.TechLevel(TechCargo)/cargo) * 10 * st.Cargo
return (1 - sg.TechLevel(TechCargo).F()/cargo) * 10 * st.Cargo
}
// Мощность бомбардировки
func (sg ShipGroup) BombingPower(st *ShipType) float64 {
return (math.Sqrt(st.Weapons*sg.TechLevel(TechWeapons))/10. + 1.) *
return (math.Sqrt(st.Weapons*sg.TechLevel(TechWeapons).F())/10. + 1.) *
st.Weapons *
sg.TechLevel(TechWeapons) *
sg.TechLevel(TechWeapons).F() *
float64(st.Armament) *
float64(sg.Number)
}
internal/model/game/group_test.go
+5 -5
View File
@@ -228,22 +228,22 @@ func TestShipGroupEqual(t *testing.T) {
right = *left
left.SetTechLevel(game.TechDrive, 1.1)
assert.Equal(t, 1.1, left.TechLevel(game.TechDrive))
assert.Equal(t, 1.1, left.TechLevel(game.TechDrive).F())
assert.False(t, left.Equal(right))
right = *left
left.SetTechLevel(game.TechWeapons, 1.1)
assert.Equal(t, 1.1, left.TechLevel(game.TechWeapons))
assert.Equal(t, 1.1, left.TechLevel(game.TechWeapons).F())
assert.False(t, left.Equal(right))
right = *left
left.SetTechLevel(game.TechShields, 1.1)
assert.Equal(t, 1.1, left.TechLevel(game.TechShields))
assert.Equal(t, 1.1, left.TechLevel(game.TechShields).F())
assert.False(t, left.Equal(right))
right = *left
left.SetTechLevel(game.TechCargo, 1.1)
assert.Equal(t, 1.1, left.TechLevel(game.TechCargo))
assert.Equal(t, 1.1, left.TechLevel(game.TechCargo).F())
assert.False(t, left.Equal(right))
// non-essential properties
@@ -254,6 +254,6 @@ func TestShipGroupEqual(t *testing.T) {
// dirty hack to equalize loads
left.Number = 5
left.Load = right.Load / float64(right.Number) * float64(left.Number)
left.Load = game.F(right.Load.F() / float64(right.Number) * float64(left.Number))
assert.True(t, left.Equal(right))
}
internal/model/game/group_upgrade.go
+6 -6
View File
@@ -32,16 +32,16 @@ func BlockUpgradeCost(blockMass, currentBlockTech, targetBlockTech float64) floa
func GroupUpgradeCost(sg ShipGroup, st ShipType, drive, weapons, shields, cargo float64) UpgradeCalc {
uc := &UpgradeCalc{Cost: make(map[Tech]float64)}
if drive > 0 {
uc.Cost[TechDrive] = BlockUpgradeCost(st.DriveBlockMass(), sg.TechLevel(TechDrive), drive)
uc.Cost[TechDrive] = BlockUpgradeCost(st.DriveBlockMass(), sg.TechLevel(TechDrive).F(), drive)
}
if weapons > 0 {
uc.Cost[TechWeapons] = BlockUpgradeCost(st.WeaponsBlockMass(), sg.TechLevel(TechWeapons), weapons)
uc.Cost[TechWeapons] = BlockUpgradeCost(st.WeaponsBlockMass(), sg.TechLevel(TechWeapons).F(), weapons)
}
if shields > 0 {
uc.Cost[TechShields] = BlockUpgradeCost(st.ShieldsBlockMass(), sg.TechLevel(TechShields), shields)
uc.Cost[TechShields] = BlockUpgradeCost(st.ShieldsBlockMass(), sg.TechLevel(TechShields).F(), shields)
}
if cargo > 0 {
uc.Cost[TechCargo] = BlockUpgradeCost(st.CargoBlockMass(), sg.TechLevel(TechCargo), cargo)
uc.Cost[TechCargo] = BlockUpgradeCost(st.CargoBlockMass(), sg.TechLevel(TechCargo).F(), cargo)
}
return *uc
}
@@ -69,7 +69,7 @@ func FutureUpgradeLevel(raceLevel, groupLevel, limit float64) float64 {
}
func UpgradeGroupPreference(sg ShipGroup, st ShipType, tech Tech, v float64) ShipGroup {
if v <= 0 || st.BlockMass(tech) == 0 || sg.TechLevel(tech) >= v {
if v <= 0 || st.BlockMass(tech) == 0 || sg.TechLevel(tech).F() >= v {
return sg
}
var su InUpgrade
@@ -84,7 +84,7 @@ func UpgradeGroupPreference(sg ShipGroup, st ShipType, tech Tech, v float64) Shi
ti = len(su.UpgradeTech) - 1
}
su.UpgradeTech[ti].Level = v
su.UpgradeTech[ti].Cost = BlockUpgradeCost(st.BlockMass(tech), sg.TechLevel(tech), v) * float64(sg.Number)
su.UpgradeTech[ti].Cost = BlockUpgradeCost(st.BlockMass(tech), sg.TechLevel(tech).F(), v) * float64(sg.Number)
sg.StateUpgrade = &su
return sg
internal/model/game/planet.go
+39 -19
View File
@@ -7,25 +7,25 @@ import (
)
type UnidentifiedPlanet struct {
X float64 `json:"x"`
Y float64 `json:"y"`
X Float `json:"x"`
Y Float `json:"y"`
Number uint `json:"number"`
}
type UninhabitedPlanet struct {
UnidentifiedPlanet
Size float64 `json:"size"`
Size Float `json:"size"`
Name string `json:"name"`
Resources float64 `json:"resources"` // R - Ресурсы
Capital float64 `json:"capital"` // CAP $ - Запасы промышленности
Material float64 `json:"material"` // MAT M - Запасы ресурсов / сырьё
Resources Float `json:"resources"` // R - Ресурсы
Capital Float `json:"capital"` // CAP $ - Запасы промышленности
Material Float `json:"material"` // MAT M - Запасы ресурсов / сырьё
}
type PlanetReport struct {
UninhabitedPlanet
Industry float64 `json:"industry"` // I - Промышленность
Population float64 `json:"population"` // P - Население
Colonists float64 `json:"colonists"` // COL C - Количество колонистов
Industry Float `json:"industry"` // I - Промышленность
Population Float `json:"population"` // P - Население
Colonists Float `json:"colonists"` // COL C - Количество колонистов
Production Production `json:"production"` // TODO: internal/report format
// Параметр "L" - Свободный производственный потенциал
}
@@ -41,13 +41,33 @@ type PlanetReportForeign struct {
PlanetReport
}
func (p *Planet) Mat(v float64) {
p.Material = F(v)
}
func (p *Planet) Pop(v float64) {
p.Population = F(v)
}
func (p *Planet) Col(v float64) {
p.Colonists = F(v)
}
func (p *Planet) Ind(v float64) {
p.Industry = F(v)
}
func (p *Planet) Cap(v float64) {
p.Capital = F(v)
}
func (p Planet) Votes() float64 {
return p.Population / 1000.
return p.Population.F() / 1000.
}
// Производственный потенциал
func (p Planet) ProductionCapacity() float64 {
return PlanetProduction(p.Industry, p.Population)
return PlanetProduction(p.Industry.F(), p.Population.F())
}
func PlanetProduction(industry, population float64) float64 {
@@ -64,12 +84,12 @@ func (p *Planet) ProduceIndustry() {
production := p.ProductionCapacity()
var ind float64
if p.Material > 0 {
ind = math.Min(production/5, p.Material)
p.Material -= ind
ind = math.Min(production/5, p.Material.F())
p.Mat(p.Material.F() - ind)
production -= ind * 5.
}
ind += (production * p.Resources) / (5.*p.Resources + 1.)
p.Industry += ind
ind += (production * p.Resources.F()) / (5.*p.Resources.F() + 1.)
p.Ind(p.Industry.F() + ind)
if p.Industry > p.Population {
p.Capital += p.Industry - p.Population
p.Industry = p.Population
@@ -78,7 +98,7 @@ func (p *Planet) ProduceIndustry() {
// Производство материалов
func (p *Planet) ProduceMaterial() {
p.Material += p.ProductionCapacity() * p.Resources
p.Material = p.Material.Add(p.ProductionCapacity() * p.Resources.F())
}
// Автоматическое увеличение населения на каждом ходу
@@ -115,10 +135,10 @@ func (p *Planet) UnpackColonists() {
}
func UnloadColonists(p Planet, v float64) Planet {
p.Population += v * 8
p.Pop(p.Population.F() + v*8)
if p.Population > p.Size {
p.Colonists += (p.Population - p.Size) / 8
p.Population = p.Size
p.Col(p.Colonists.F() + (p.Population.F()-p.Size.F())/8.)
p.Pop(p.Size.F())
}
return p
}
internal/model/game/planet_test.go
+35 -35
View File
@@ -36,24 +36,24 @@ func TestProduceIndustry(t *testing.T) {
},
}
HW.ProduceIndustry()
assert.InDelta(t, 196.078, HW.Capital, 0.0005)
assert.InDelta(t, 196.078, HW.Capital.F(), 0.0005)
HW.Capital = 0
HW.Material = 200
HW.ProduceIndustry()
assert.Equal(t, 200., HW.Capital)
assert.Equal(t, 0., HW.Material)
assert.Equal(t, 200., HW.Capital.F())
assert.Equal(t, 0., HW.Material.F())
DW.ProduceIndustry()
assert.InDelta(t, 98.039, DW.Capital, 0.0003)
assert.InDelta(t, 98.039, DW.Capital.F(), 0.0003)
DW.Capital = 0
DW.Material = 100
DW.ProduceIndustry()
assert.Equal(t, 100., DW.Capital)
assert.Equal(t, 0., DW.Material)
assert.Equal(t, 100., DW.Capital.F())
assert.Equal(t, 0., DW.Material.F())
}
func TestProduceMaterial(t *testing.T) {
@@ -67,19 +67,19 @@ func TestProduceMaterial(t *testing.T) {
Industry: 1000,
},
}
assert.Equal(t, 0., HW.Material)
assert.Equal(t, 0., HW.Material.F())
HW.ProduceMaterial()
assert.Equal(t, 10000., HW.Material)
assert.Equal(t, 10000., HW.Material.F())
HW.Industry = 500
HW.Population = 500
HW.ProduceMaterial()
assert.Equal(t, 15000., HW.Material)
assert.Equal(t, 15000., HW.Material.F())
HW.Population = 1000
HW.ProduceMaterial()
assert.Equal(t, 21250., HW.Material)
assert.Equal(t, 21250., HW.Material.F())
}
func TestUnpackCapital(t *testing.T) {
@@ -93,28 +93,28 @@ func TestUnpackCapital(t *testing.T) {
Industry: 1000,
},
}
assert.Equal(t, 0., HW.Capital)
assert.Equal(t, 0., HW.Capital.F())
HW.UnpackCapital()
assert.Equal(t, 1000., HW.Industry)
assert.Equal(t, 0., HW.Capital)
assert.Equal(t, 1000., HW.Industry.F())
assert.Equal(t, 0., HW.Capital.F())
HW.Capital = 123.
HW.UnpackCapital()
assert.Equal(t, 1000., HW.Industry)
assert.Equal(t, 123., HW.Capital)
assert.Equal(t, 1000., HW.Industry.F())
assert.Equal(t, 123., HW.Capital.F())
HW.Industry = 987.
HW.UnpackCapital()
assert.Equal(t, 1000., HW.Industry)
assert.Equal(t, 110., HW.Capital)
assert.Equal(t, 1000., HW.Industry.F())
assert.Equal(t, 110., HW.Capital.F())
HW.Population = 876.
HW.Industry = 800.
HW.UnpackCapital()
assert.Equal(t, 876., HW.Population)
assert.Equal(t, 876., HW.Industry)
assert.Equal(t, 34., HW.Capital)
assert.Equal(t, 876., HW.Population.F())
assert.Equal(t, 876., HW.Industry.F())
assert.Equal(t, 34., HW.Capital.F())
}
func TestUnpackColonists(t *testing.T) {
@@ -128,26 +128,26 @@ func TestUnpackColonists(t *testing.T) {
Industry: 1000,
},
}
assert.Equal(t, 0., HW.Colonists)
assert.Equal(t, 0., HW.Colonists.F())
HW.UnpackColonists()
assert.Equal(t, 1000., HW.Population)
assert.Equal(t, 0., HW.Colonists)
assert.Equal(t, 1000., HW.Population.F())
assert.Equal(t, 0., HW.Colonists.F())
HW.Colonists = 1.05
HW.UnpackColonists()
assert.Equal(t, 1000., HW.Population)
assert.Equal(t, 1.05, HW.Colonists)
assert.Equal(t, 1000., HW.Population.F())
assert.Equal(t, 1.05, HW.Colonists.F())
HW.Population = 996.0
HW.UnpackColonists()
assert.Equal(t, 1000., HW.Population)
assert.Equal(t, 0.55, HW.Colonists)
assert.Equal(t, 1000., HW.Population.F())
assert.Equal(t, 0.55, HW.Colonists.F())
HW.Population = 0.0
HW.UnpackColonists()
assert.Equal(t, 4.4, HW.Population)
assert.Equal(t, 0., HW.Colonists)
assert.Equal(t, 4.4, HW.Population.F())
assert.Equal(t, 0., HW.Colonists.F())
}
func TestProducePopulation(t *testing.T) {
@@ -161,15 +161,15 @@ func TestProducePopulation(t *testing.T) {
Industry: 1000,
},
}
assert.Equal(t, 500., HW.Population)
assert.Equal(t, 0., HW.Colonists)
assert.Equal(t, 500., HW.Population.F())
assert.Equal(t, 0., HW.Colonists.F())
HW.ProducePopulation()
assert.Equal(t, 540., HW.Population)
assert.Equal(t, 0., HW.Colonists)
assert.Equal(t, 540., HW.Population.F())
assert.Equal(t, 0., HW.Colonists.F())
HW.Population = 1000.
HW.ProducePopulation()
assert.Equal(t, 1000., HW.Population)
assert.Equal(t, 10., HW.Colonists)
assert.Equal(t, 1000., HW.Population.F())
assert.Equal(t, 10., HW.Colonists.F())
}
internal/model/report/battle.go
+5 -5
View File
@@ -23,11 +23,11 @@ type BattleReportGroup struct {
NumberLeft uint `json:"numLeft"`
ClassName string `json:"className"`
LoadType string `json:"loadType"`
LoadQuantity float64 `json:"loadQuantity"`
Drive float64 `json:"drive"`
Weapons float64 `json:"wwapons"`
Shields float64 `json:"shields"`
Cargo float64 `json:"cargo"`
LoadQuantity Float `json:"loadQuantity"`
Drive Float `json:"drive"`
Weapons Float `json:"wwapons"`
Shields Float `json:"shields"`
Cargo Float `json:"cargo"`
}
type BattleActionReport struct {
internal/model/report/bombing.go
+6 -6
View File
@@ -9,11 +9,11 @@ type BombingPlanetReport struct {
Owner string `json:"owner"`
Attacker string `json:"attacker"`
Production string `json:"production"`
Industry float64 `json:"industry"` // I - Промышленность
Population float64 `json:"population"` // P - Население
Colonists float64 `json:"colonists"` // COL C - Количество колонистов
Capital float64 `json:"capital"` // CAP $ - Запасы промышленности
Material float64 `json:"material"` // MAT M - Запасы ресурсов / сырья
AttackPower float64 `json:"attack"`
Industry Float `json:"industry"` // I - Промышленность
Population Float `json:"population"` // P - Население
Colonists Float `json:"colonists"` // COL C - Количество колонистов
Capital Float `json:"capital"` // CAP $ - Запасы промышленности
Material Float `json:"material"` // MAT M - Запасы ресурсов / сырья
AttackPower Float `json:"attack"`
Wiped bool `json:"wiped"`
}
internal/repo/game.go
-9
View File
@@ -38,18 +38,9 @@ func saveTurn(s Storage, t uint, g *game.Game) error {
if err := s.Write(path, g); err != nil {
return NewStorageError(err)
}
// TODO: save reports
for i := range g.Race {
saveRace(s, g, i)
}
// TODO: save battles
return saveState(s, g) // FIXME: either save it here, or in tre repo controller
}
func saveRace(s Storage, g *game.Game, i int) {
}
func (r *repo) SaveState(g *game.Game) error {
return saveState(r.s, g)
}