diff --git a/pkg/bitmap/bitmap.go b/pkg/bitmap/bitmap.go
index 4274eab..2256ba1 100644
--- a/pkg/bitmap/bitmap.go
+++ b/pkg/bitmap/bitmap.go
@@ -84,9 +84,9 @@ func (p Bitmap) SetFreeN(number int) error {
 	return fmt.Errorf("set free pixel: no such number=%d, max=%d", number, n)
 }
 
-func (p Bitmap) Circle(x, y int, r float32, fill bool) {
+func (p Bitmap) Circle(x, y int, r float64, fill bool) {
 	plotX := 0
-	plotY := int(math.Ceil(float64(r)))
+	plotY := int(math.Ceil(r))
 	delta := 3 - 2*plotY
 	lastY := plotY
 	for plotX <= plotY {
diff --git a/pkg/bitmap/bitmap_test.go b/pkg/bitmap/bitmap_test.go
index df8d8b6..d294ddc 100644
--- a/pkg/bitmap/bitmap_test.go
+++ b/pkg/bitmap/bitmap_test.go
@@ -221,7 +221,7 @@ func TestClear(t *testing.T) {
 func TestCircle(t *testing.T) {
 	type testCase struct {
 		x, y   int
-		r      float32
+		r      float64
 		filled bool
 	}
 	for i, tc := range []testCase{
diff --git a/pkg/generator/generator.go b/pkg/generator/generator.go
index c16aac9..d2079c8 100644
--- a/pkg/generator/generator.go
+++ b/pkg/generator/generator.go
@@ -22,7 +22,7 @@ func Generate(cfg ...func(*MapSetting)) (Map, error) {
 	freePlanets := ms.NobodysPlanets()
 
 	createPlanets := func(ps PlanetSetting) error {
-		return m.CreatePlanets(ps.Count(freePlanets), float32(ps.MinDistanceHW), RandIFn(ps.MinSize, ps.MaxSize), RandIFn(ps.MinResource, ps.MaxResource))
+		return m.CreatePlanets(ps.Count(freePlanets), float64(ps.MinDistanceHW), RandIFn(ps.MinSize, ps.MaxSize), RandIFn(ps.MinResource, ps.MaxResource))
 	}
 
 	// 1. Place Giant planets
@@ -37,18 +37,18 @@ func Generate(cfg ...func(*MapSetting)) (Map, error) {
 
 	// 3. Place players' Home Worlds
 	for player := 0; player < int(ms.Players); player++ {
-		coord, err := m.NewCoordinate(float32(ms.HWMinDistance))
+		coord, err := m.NewCoordinate(float64(ms.HWMinDistance))
 		if err != nil {
 			return Map{}, fmt.Errorf("%s: hw new_coordinate: %s", ms, err)
 		}
-		planet := NewPlanet(coord, float32(ms.HWSize), float32(ms.HWResources))
+		planet := NewPlanet(coord, float64(ms.HWSize), float64(ms.HWResources))
 		m.HomePlanets[player] = PlanetarySystem{HW: planet, 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 := float32(p * math.Cos(phi))
-			y := float32(p * math.Sin(phi))
-			dwPlanet := NewPlanet(Coordinate{x, y}, float32(ms.DWSize), float32(ms.DWResources))
+			x := p * math.Cos(phi)
+			y := p * math.Sin(phi)
+			dwPlanet := NewPlanet(Coordinate{x, y}, float64(ms.DWSize), float64(ms.DWResources))
 			m.HomePlanets[player].DW[dw] = dwPlanet
 		}
 	}
diff --git a/pkg/generator/map.go b/pkg/generator/map.go
index 294a685..e128a32 100644
--- a/pkg/generator/map.go
+++ b/pkg/generator/map.go
@@ -16,13 +16,13 @@ type Map struct {
 }
 
 type Coordinate struct {
-	X, Y float32
+	X, Y float64
 }
 
 type Planet struct {
 	Position  Coordinate
-	Size      float32
-	Resources float32 // Сырьё
+	Size      float64
+	Resources float64 // Сырьё
 }
 
 type PlanetarySystem struct {
@@ -43,7 +43,7 @@ func NewMap(width, height, players uint32) (*Map, error) {
 	}, nil
 }
 
-func (m *Map) CreatePlanets(num int, deadZoneRadius float32, size, resources func() float32) error {
+func (m *Map) CreatePlanets(num int, deadZoneRadius float64, size, resources func() float64) error {
 	for range num {
 		coord, err := m.NewCoordinate(deadZoneRadius)
 		if err != nil {
@@ -59,7 +59,7 @@ func (m *Map) AddPlanet(planet Planet) {
 	m.FreePlanets = append(m.FreePlanets, planet)
 }
 
-func (m Map) NewCoordinate(deadZoneRaduis float32) (Coordinate, error) {
+func (m Map) NewCoordinate(deadZoneRaduis float64) (Coordinate, error) {
 	if x, y, err := m.plotter.RandomFreePoint(deadZoneRaduis); err != nil {
 		return Coordinate{}, fmt.Errorf("NewCoordinate: RandomFreePoint: %s", err)
 	} else {
@@ -67,7 +67,7 @@ func (m Map) NewCoordinate(deadZoneRaduis float32) (Coordinate, error) {
 	}
 }
 
-func NewPlanet(c Coordinate, size, resources float32) Planet {
+func NewPlanet(c Coordinate, size, resources float64) Planet {
 	return Planet{
 		Position:  c,
 		Size:      size,
@@ -75,14 +75,14 @@ func NewPlanet(c Coordinate, size, resources float32) Planet {
 	}
 }
 
-// RandI returns a random float32 value between min and max
-func RandI(min, max float32) float32 {
-	return min + rand.Float32()*(max-min)
+// RandI returns a random float64 value between min and max
+func RandI(min, max float64) float64 {
+	return min + rand.Float64()*(max-min)
 }
 
 // RandIFn is a wrapper for the [RandI] func
-func RandIFn(min, max float32) func() float32 {
-	return func() float32 {
+func RandIFn(min, max float64) func() float64 {
+	return func() float64 {
 		return RandI(min, max)
 	}
 }
diff --git a/pkg/generator/plotter/plotter.go b/pkg/generator/plotter/plotter.go
index a97ec1b..85a642b 100644
--- a/pkg/generator/plotter/plotter.go
+++ b/pkg/generator/plotter/plotter.go
@@ -10,35 +10,35 @@ import (
 )
 
 type Plotter struct {
-	factor              float32
+	factor              float64
 	clearFn             func()
-	circleFn            func(x, y int, r float32)
+	circleFn            func(x, y int, r float64)
 	freeCountFn         func() int
 	freeNumberToCoordFn func(int) (int, int, error)
 }
 
-func NewPlotter(width, height uint32, factor float32) (Plotter, error) {
+func NewPlotter(width, height uint32, factor float64) (Plotter, error) {
 	return NewBitmapPlotter(NewBitmap(width, height, factor), factor)
 }
 
-func NewBitmap(width, height uint32, factor float32) bitmap.Bitmap {
+func NewBitmap(width, height uint32, factor float64) bitmap.Bitmap {
 	return bitmap.NewBitmap(AsPlotterSize(width, height, factor))
 }
 
-func NewBitmapPlotter(bm bitmap.Bitmap, factor float32) (Plotter, error) {
+func NewBitmapPlotter(bm bitmap.Bitmap, factor float64) (Plotter, error) {
 	if factor > 1 || factor <= 0 {
 		return Plotter{}, fmt.Errorf("factor should be: 0 > F <= 1")
 	}
 	return Plotter{
 		factor:              factor,
 		clearFn:             bm.Clear,
-		circleFn:            func(x, y int, r float32) { bm.Circle(x, y, r, true) },
+		circleFn:            func(x, y int, r float64) { bm.Circle(x, y, r, true) },
 		freeCountFn:         bm.FreeCount,
 		freeNumberToCoordFn: bm.GetFreeN,
 	}, nil
 }
 
-func (p Plotter) RandomFreePoint(deadZoneRaduis float32) (float32, float32, error) {
+func (p Plotter) RandomFreePoint(deadZoneRaduis float64) (float64, float64, error) {
 	fsCount := p.freeCountFn()
 	if fsCount == 0 {
 		return 0, 0, errors.New("RandomFreePoint: no free space left")
@@ -51,22 +51,22 @@ func (p Plotter) RandomFreePoint(deadZoneRaduis float32) (float32, float32, erro
 	if deadZoneRaduis > 0 {
 		p.plotDeadZone(x, y, deadZoneRaduis)
 	}
-	planetX := float32(x)*p.factor + rand.Float32()*p.factor
-	planetY := float32(y)*p.factor + rand.Float32()*p.factor
+	planetX := float64(x)*p.factor + rand.Float64()*p.factor
+	planetY := float64(y)*p.factor + rand.Float64()*p.factor
 	return planetX, planetY, nil
 }
 
-func (p Plotter) MarkDeadZone(x, y float32, radius float32) {
+func (p Plotter) MarkDeadZone(x, y float64, radius float64) {
 	p.plotDeadZone(int(x/p.factor), int(y/p.factor), radius)
 }
 
-func (p Plotter) plotDeadZone(x, y int, radius float32) {
+func (p Plotter) plotDeadZone(x, y int, radius float64) {
 	p.circleFn(x, y, radius/p.factor)
 }
 
 func (p Plotter) Clear() { p.clearFn() }
 
-func AsPlotterSize(width, height uint32, factor float32) (uint32, uint32) {
+func AsPlotterSize(width, height uint32, factor float64) (uint32, uint32) {
 	if factor > 1 || factor <= 0 {
 		return width, height
 	}
diff --git a/pkg/generator/plotter/plotter_test.go b/pkg/generator/plotter/plotter_test.go
index 3bf8dbc..82ee030 100644
--- a/pkg/generator/plotter/plotter_test.go
+++ b/pkg/generator/plotter/plotter_test.go
@@ -28,7 +28,7 @@ func TestNewPlotter(t *testing.T) {
 func TestAsPlotterSize(t *testing.T) {
 	for _, tc := range []struct {
 		w, h   uint32
-		f      float32
+		f      float64
 		ew, eh uint32
 	}{
 		{10, 10, 0, 10, 10},
@@ -46,7 +46,7 @@ func TestAsPlotterSize(t *testing.T) {
 }
 
 func TestRandomFreePoint(t *testing.T) {
-	var factor float32 = 0.25
+	var factor float64 = 0.25
 	var w, h uint32 = 20, 20
 	bm := plotter.NewBitmap(w, h, factor)
 	p, err := plotter.NewBitmapPlotter(bm, factor) // 80x80
@@ -58,7 +58,7 @@ func TestRandomFreePoint(t *testing.T) {
 	if err != nil {
 		t.Errorf("expect: no error getting random point, got: %s", err)
 	}
-	if x > float32(w) || y > float32(w) {
+	if x > float64(w) || y > float64(w) {
 		t.Errorf("expect: point coordinates within map size %dx%d, got: x=%f y=%f", w, h, x, y)
 	}
 
@@ -67,7 +67,7 @@ func TestRandomFreePoint(t *testing.T) {
 		t.Errorf("expect: no error when radius is zero, got: %s", err)
 	}
 
-	_, _, err = p.RandomFreePoint(float32(w + h)) // guaranteed to mark whole area dead zone
+	_, _, err = p.RandomFreePoint(float64(w + h)) // guaranteed to mark whole area dead zone
 	if err != nil {
 		t.Errorf("expect: no error getting random point, got: %s", err)
 	}
diff --git a/pkg/generator/settings.go b/pkg/generator/settings.go
index 1e55fbf..d860d53 100644
--- a/pkg/generator/settings.go
+++ b/pkg/generator/settings.go
@@ -5,7 +5,7 @@ import (
 	"math"
 )
 
-const defaultFactor float32 = 0.1
+const defaultFactor float64 = 0.1
 
 type MapSetting struct {
 	Players       uint32
@@ -20,7 +20,7 @@ type MapSetting struct {
 
 	GiantPlanets      PlanetSetting
 	BigPlanets        PlanetSetting
-	OthersMinDistance float32
+	OthersMinDistance float64
 	NormalPlanets     PlanetSetting
 	RichPlanets       PlanetSetting
 	Asterioids        PlanetSetting
@@ -44,11 +44,11 @@ func (ms MapSetting) NobodysPlanets() uint32 {
 
 type PlanetSetting struct {
 	MinDistanceHW uint32
-	MinSize       float32
-	MaxSize       float32
-	MinResource   float32
-	MaxResource   float32
-	Probability   float32
+	MinSize       float64
+	MaxSize       float64
+	MinResource   float64
+	MaxResource   float64
+	Probability   float64
 }
 
 func (ps PlanetSetting) Count(freePlanets uint32) int {
diff --git a/pkg/model/game/planet.go b/pkg/model/game/planet.go
index 6a8e25a..f4d82f8 100644
--- a/pkg/model/game/planet.go
+++ b/pkg/model/game/planet.go
@@ -3,26 +3,26 @@ package game
 import "math"
 
 type Planet struct {
-	X, Y float32
-	Size float32
+	X, Y float64
+	Size float64
 
 	Name  string
 	Owner string
 
 	Production ProductionType
-	Resources  float32 // Сырьё
-	Industry   float32 // Промышленность
-	Population float32 // Население
+	Resources  float64 // Сырьё
+	Industry   float64 // Промышленность
+	Population float64 // Население
 
-	Capital   float32 // CAP $ - Запасы промышленности
-	Material  float32 // MAT M - Запасы сырья
-	Colonists float32 // COL C - Количество колонистов
+	Capital   float64 // CAP $ - Запасы промышленности
+	Material  float64 // MAT M - Запасы сырья
+	Colonists float64 // COL C - Количество колонистов
 	// Параметр "L" означает количество свободных производственных единиц.
 }
 
 // Производственный потенциал (I)
 // промышленность * 0.75 + население * 0.25
-func (p Planet) ProductionCapacity() float32 {
+func (p Planet) ProductionCapacity() float64 {
 	return p.Industry*0.75 + p.Population*0.25
 }
 
@@ -30,7 +30,7 @@ func (p Planet) ProductionCapacity() float32 {
 // TODO: test on real values
 func (p *Planet) IncreaseIndustry() {
 	prod := p.ProductionCapacity() / 5
-	industryIncrement := float32(math.Min(float64(prod), float64(p.Material)))
+	industryIncrement := math.Min(prod, p.Material)
 	p.Industry += industryIncrement
 	if p.Industry > p.Population {
 		p.Industry = p.Population
diff --git a/pkg/model/game/race.go b/pkg/model/game/race.go
index c02b16c..323eaf0 100644
--- a/pkg/model/game/race.go
+++ b/pkg/model/game/race.go
@@ -4,19 +4,19 @@ type Race struct {
 	Name   string
 	Killed bool
 
-	Votes   float32
+	Votes   float64
 	VoteFor string
 
-	Drive   float32
-	Weapons float32
-	Shields float32
-	Cargo   float32
+	Drive   float64
+	Weapons float64
+	Shields float64
+	Cargo   float64
 }
 
-func (r Race) FlightDistance() float32 {
+func (r Race) FlightDistance() float64 {
 	return r.Drive * 40
 }
 
-func (r Race) VisibilityDistance() float32 {
+func (r Race) VisibilityDistance() float64 {
 	return r.Drive * 30
 }