fs storage

game/internal/generator/plotter/plotter.go

@@ -0,0 +1,76 @@
+package plotter
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"math/rand"
+
+	"galaxy/game/internal/bitmap"
+)
+
+type Plotter struct {
+	factor              float64
+	clearFn             func()
+	circleFn            func(x, y int, r float64)
+	freeCountFn         func() int
+	freeNumberToCoordFn func(int) (int, int, error)
+}
+
+func NewPlotter(width, height uint32, factor float64) (Plotter, error) {
+	return NewBitmapPlotter(NewBitmap(width, height, factor), factor)
+}
+
+func NewBitmap(width, height uint32, factor float64) bitmap.Bitmap {
+	return bitmap.NewBitmap(AsPlotterSize(width, height, factor))
+}
+
+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 float64) { bm.Circle(x, y, r, true) },
+		freeCountFn:         bm.FreeCount,
+		freeNumberToCoordFn: bm.GetFreeN,
+	}, nil
+}
+
+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")
+	}
+	next := rand.Intn(fsCount)
+	x, y, err := p.freeNumberToCoordFn(next)
+	if err != nil {
+		return 0, 0, fmt.Errorf("RandomFreePoint: freeNumberToCoordFn: %s", err)
+	}
+	if deadZoneRaduis > 0 {
+		p.plotDeadZone(x, y, deadZoneRaduis)
+	}
+	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 float64, radius float64) {
+	p.plotDeadZone(int(x/p.factor), int(y/p.factor), radius)
+}
+
+func (p Plotter) plotDeadZone(x, y int, radius float64) {
+	// Adding extra 'pixel' to avoid radius became less than deadZoneRaduis
+	// after division by factor due to floating-point operations specifics
+	p.circleFn(x, y, (radius+p.factor)/p.factor)
+}
+
+func (p Plotter) Clear() { p.clearFn() }
+
+func AsPlotterSize(width, height uint32, factor float64) (uint32, uint32) {
+	if factor > 1 || factor <= 0 {
+		return width, height
+	}
+	return uint32(math.Ceil(float64(width) / float64(factor))), uint32(math.Ceil(float64(height) / float64(factor)))
+}

game/internal/generator/plotter/plotter_test.go

@@ -0,0 +1,86 @@
+package plotter_test
+
+import (
+	"testing"
+
+	"galaxy/game/internal/generator/plotter"
+)
+
+func TestNewPlotter(t *testing.T) {
+	_, err := plotter.NewPlotter(10, 10, 0)
+	if err == nil {
+		t.Error("expect: error when factor=0")
+	}
+	_, err = plotter.NewPlotter(10, 10, -0.01)
+	if err == nil {
+		t.Error("expect: error when factor<0")
+	}
+	_, err = plotter.NewPlotter(10, 10, 1.001)
+	if err == nil {
+		t.Error("expect: error when factor>1")
+	}
+	_, err = plotter.NewPlotter(10, 10, 1)
+	if err != nil {
+		t.Error("expect: no error when factor=1")
+	}
+}
+
+func TestAsPlotterSize(t *testing.T) {
+	for _, tc := range []struct {
+		w, h   uint32
+		f      float64
+		ew, eh uint32
+	}{
+		{10, 10, 0, 10, 10},
+		{10, 10, -1, 10, 10},
+		{10, 10, 1.1, 10, 10},
+		{10, 20, 0.5, 20, 40},
+		{30, 60, 0.3, 100, 200},
+		{10, 20, 0.25, 40, 80},
+	} {
+		w, h := plotter.AsPlotterSize(tc.w, tc.h, tc.f)
+		if tc.ew != w || tc.eh != h {
+			t.Errorf("expect: w=%d h=%d, got: w=%d h=%d", tc.ew, tc.eh, w, h)
+		}
+	}
+}
+
+func TestRandomFreePoint(t *testing.T) {
+	var factor float64 = 0.25
+	var w, h uint32 = 20, 20
+	bm := plotter.NewBitmap(w, h, factor)
+	p, err := plotter.NewBitmapPlotter(bm, factor) // 80x80
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	x, y, err := p.RandomFreePoint(3)
+	if err != nil {
+		t.Errorf("expect: no error getting random point, got: %s", err)
+	}
+	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)
+	}
+
+	_, _, err = p.RandomFreePoint(0)
+	if err != nil {
+		t.Errorf("expect: no error when radius is zero, got: %s", err)
+	}
+
+	_, _, 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)
+	}
+
+	_, _, err = p.RandomFreePoint(1)
+	if err == nil {
+		t.Error("expect: error when no free space left, got: none")
+	}
+
+	p.Clear()
+
+	_, _, err = p.RandomFreePoint(10)
+	if err != nil {
+		t.Errorf("expect: no error getting random point after clearing, got: %s", err)
+	}
+}