Koldun/mapserver
1
0
Fork 0
forked from MTSR/mapserver
Code Pull Requests Activity

types / coords refactoring

Browse Source
This commit is contained in:
BuckarooBanzay 2023-12-29 16:00:11 +01:00
parent 1e1d0813e8
commit b7486a4474
72 changed files with 190 additions and 695 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/app.go
View File

@ -1,7 +1,6 @@
package app package app
import ( import (
"mapserver/blockaccessor"
"mapserver/db" "mapserver/db"
"mapserver/eventbus" "mapserver/eventbus"
"mapserver/mapblockaccessor" "mapserver/mapblockaccessor"
@ -26,7 +25,6 @@ type App struct {
Settings settings.Settings Settings settings.Settings
MapBlockAccessor *mapblockaccessor.MapBlockAccessor MapBlockAccessor *mapblockaccessor.MapBlockAccessor
BlockAccessor *blockaccessor.BlockAccessor
Colormapping *colormapping.ColorMapping Colormapping *colormapping.ColorMapping
Mapblockrenderer *mapblockrenderer.MapBlockRenderer Mapblockrenderer *mapblockrenderer.MapBlockRenderer
Tilerenderer *tilerenderer.TileRenderer Tilerenderer *tilerenderer.TileRenderer

4
app/config.go
View File

@ -2,7 +2,7 @@ package app
import ( import (
"encoding/json" "encoding/json"
"mapserver/layer" "mapserver/types"
"os" "os"
"runtime" "runtime"
"sync" "sync"
@ -43,7 +43,7 @@ func ParseConfig(filename string) (*Config, error) {
SecretKey: RandStringRunes(16), SecretKey: RandStringRunes(16),
} }
layers := []*layer.Layer{ layers := []*types.Layer{
{ {
Id: 0, Id: 0,
Name: "Ground", Name: "Ground",

4
app/setup.go
View File

@ -1,7 +1,6 @@
package app package app
import ( import (
"mapserver/blockaccessor"
"mapserver/db/postgres" "mapserver/db/postgres"
"mapserver/db/sqlite" "mapserver/db/sqlite"
"mapserver/eventbus" "mapserver/eventbus"
@ -89,9 +88,6 @@ func Setup(p params.ParamsType, cfg *Config) *App {
expireDuration, purgeDuration, expireDuration, purgeDuration,
cfg.MapBlockAccessorCfg.MaxItems) cfg.MapBlockAccessorCfg.MaxItems)
// block accessor
a.BlockAccessor = blockaccessor.New(a.MapBlockAccessor)
//color mapping //color mapping
a.Colormapping = colormapping.NewColorMapping() a.Colormapping = colormapping.NewColorMapping()
err = a.Colormapping.LoadDefaults() err = a.Colormapping.LoadDefaults()

8
app/types.go
View File

@ -1,8 +1,6 @@
package app package app
import ( import "mapserver/types"
"mapserver/layer"
)
type Config struct { type Config struct {
ConfigVersion int `json:"configversion"` ConfigVersion int `json:"configversion"`
@ -15,7 +13,7 @@ type Config struct {
EnableMediaRepository bool `json:"enablemediarepository"` EnableMediaRepository bool `json:"enablemediarepository"`
Webdev bool `json:"webdev"` Webdev bool `json:"webdev"`
WebApi *WebApiConfig `json:"webapi"` WebApi *WebApiConfig `json:"webapi"`
Layers []*layer.Layer `json:"layers"` Layers []*types.Layer `json:"layers"`
RenderingFetchLimit int `json:"renderingfetchlimit"` RenderingFetchLimit int `json:"renderingfetchlimit"`
RenderingJobs int `json:"renderingjobs"` RenderingJobs int `json:"renderingjobs"`
RenderingQueue int `json:"renderingqueue"` RenderingQueue int `json:"renderingqueue"`
@ -26,7 +24,7 @@ type Config struct {
Skins *SkinsConfig `json:"skins"` Skins *SkinsConfig `json:"skins"`
WorldPath string `json:"worldpath"` WorldPath string `json:"worldpath"`
DataPath string `json:"datapath"` DataPath string `json:"datapath"`
ColorsTxtPath string `json:colorstxtpath` ColorsTxtPath string `json:"colorstxtpath"`
} }
type MapBlockAccessorConfig struct { type MapBlockAccessorConfig struct {

57
areasparser/parser.go
View File

@ -1,57 +0,0 @@
package areasparser
import (
"bytes"
"encoding/json"
"os"
)
type GenericPos struct {
X int `json:"x"`
Y int `json:"y"`
Z int `json:"z"`
}
type Area struct {
Owner string `json:"owner"`
Name string `json:"name"`
Parent int `json:"parent"`
Pos1 *GenericPos `json:"pos1"`
Pos2 *GenericPos `json:"pos2"`
}
func getInt(o interface{}) int {
v, _ := o.(float64)
return int(v)
}
func (pos *GenericPos) UnmarshalJSON(data []byte) error {
m := make(map[string]interface{})
err := json.Unmarshal(data, &m)
if err != nil {
return err
}
// float-like to int workaround
pos.X = getInt(m["x"])
pos.Y = getInt(m["y"])
pos.Z = getInt(m["z"])
return nil
}
func ParseFile(filename string) ([]*Area, error) {
content, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
return Parse(content)
}
func Parse(data []byte) ([]*Area, error) {
areas := make([]*Area, 0)
json.NewDecoder(bytes.NewReader(data)).Decode(&areas)
return areas, nil
}

20
areasparser/parser_test.go
View File

@ -1,20 +0,0 @@
package areasparser
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestParse(t *testing.T) {
a, err := ParseFile("testdata/areas.json")
assert.NoError(t, err)
assert.True(t, len(a) > 1)
area := a[0]
assert.Equal(t, "ilai_house", area.Name)
assert.Equal(t, "ilai", area.Owner)
assert.NotNil(t, area.Pos1)
assert.NotNil(t, area.Pos2)
assert.Equal(t, 4970, area.Pos1.X)
}

323
areasparser/testdata/areas.json vendored
View File

@ -1,323 +0,0 @@
[
{
"name": "ilai_house",
"owner": "ilai",
"pos1": {
"x": 4970.0,
"y": 8.0,
"z": 88.0
},
"pos2": {
"x": 4983.0,
"y": 16.0,
"z": 99.0
}
},
{
"name": "temple",
"owner": "Lukc",
"pos1": {
"x": -1911.0,
"y": 18.0,
"z": -221.0
},
"pos2": {
"x": -1718.0,
"y": 68.0,
"z": -50.0
}
},
{
"name": "temple",
"owner": "BuckarooBanzai",
"parent": 2.0,
"pos1": {
"x": -1911.0,
"y": 18.0,
"z": -221.0
},
"pos2": {
"x": -1718.0,
"y": 68.0,
"z": -50.0
}
},
{
"name": "Spaceshipyard",
"owner": "Lukc",
"pos1": {
"x": -1784.0,
"y": -49.0,
"z": -1174.0
},
"pos2": {
"x": -1688.0,
"y": 58.0,
"z": -1068.0
}
},
{
"name": "Arena",
"owner": "Lukc",
"pos1": {
"x": -1860.0,
"y": -369.0,
"z": -1162.0
},
"pos2": {
"x": -1751.0,
"y": -310.0,
"z": -1061.0
}
},
{
"name": "Spaceshipyard",
"owner": "T4im",
"parent": 4.0,
"pos1": {
"x": -1784.0,
"y": -49.0,
"z": -1174.0
},
"pos2": {
"x": -1688.0,
"y": 58.0,
"z": -1068.0
}
},
{
"name": "temple",
"owner": "T4im",
"parent": 2.0,
"pos1": {
"x": -1911.0,
"y": 18.0,
"z": -221.0
},
"pos2": {
"x": -1718.0,
"y": 68.0,
"z": -50.0
}
},
{
"name": "Spaceshipyard",
"owner": "BuckarooBanzai",
"parent": 4.0,
"pos1": {
"x": -1784.0,
"y": -49.0,
"z": -1174.0
},
"pos2": {
"x": -1688.0,
"y": 58.0,
"z": -1068.0
}
},
{
"name": "Arena",
"owner": "T4im",
"parent": 5.0,
"pos1": {
"x": -1860.0,
"y": -369.0,
"z": -1162.0
},
"pos2": {
"x": -1751.0,
"y": -310.0,
"z": -1061.0
}
},
{
"name": "Humboldt Research Station",
"owner": "T4im",
"pos1": {
"x": -624.0,
"y": -32.0,
"z": 48.0
},
"pos2": {
"x": -369.0,
"y": 127.0,
"z": 351.0
}
},
{
"name": "centrifuge cascade",
"owner": "pipo",
"pos1": {
"x": -2995.0,
"y": -40.0,
"z": -3003.0
},
"pos2": {
"x": -2958.0,
"y": -26.0,
"z": -2990.0
}
},
{
"name": "centrifuge cascade",
"owner": "barsik",
"parent": 11.0,
"pos1": {
"x": -2995.0,
"y": -40.0,
"z": -3003.0
},
"pos2": {
"x": -2958.0,
"y": -26.0,
"z": -2990.0
}
},
{
"name": "centrifuge cascade",
"owner": "BuckarooBanzai",
"parent": 11.0,
"pos1": {
"x": -2995.0,
"y": -40.0,
"z": -3003.0
},
"pos2": {
"x": -2958.0,
"y": -26.0,
"z": -2990.0
}
},
{
"name": "centrifuge cascade",
"owner": "T4im",
"parent": 11.0,
"pos1": {
"x": -2995.0,
"y": -40.0,
"z": -3003.0
},
"pos2": {
"x": -2958.0,
"y": -26.0,
"z": -2990.0
}
},
{
"name": "centrifuge cascade",
"owner": "Lukc",
"parent": 11.0,
"pos1": {
"x": -2995.0,
"y": -40.0,
"z": -3003.0
},
"pos2": {
"x": -2958.0,
"y": -26.0,
"z": -2990.0
}
},
{
"name": "Spaceshipyard",
"owner": "pipo",
"parent": 6.0,
"pos1": {
"x": -1784.0,
"y": -49.0,
"z": -1174.0
},
"pos2": {
"x": -1688.0,
"y": 58.0,
"z": -1068.0
}
},
{
"name": "Emerald extention",
"owner": "Emerald",
"pos1": {
"x": 5055.0,
"y": 8.0,
"z": 48.0
},
"pos2": {
"x": 5059.0,
"y": 10.0,
"z": 54.0
}
},
{
"name": "tower1",
"owner": "pipo",
"parent": 19.0,
"pos1": {
"x": -14.0,
"y": -126.0,
"z": 587.0
},
"pos2": {
"x": 17.0,
"y": 103.0,
"z": 617.0
}
},
{
"name": "tower1",
"owner": "barsik",
"pos1": {
"x": -14.0,
"y": -126.0,
"z": 587.0
},
"pos2": {
"x": 17.0,
"y": 103.0,
"z": 617.0
}
},
{
"name": "tower1",
"owner": "BuckarooBanzai",
"parent": 19.0,
"pos1": {
"x": -14.0,
"y": -126.0,
"z": 587.0
},
"pos2": {
"x": 17.0,
"y": 103.0,
"z": 617.0
}
},
{
"name": "tower1",
"owner": "T4im",
"parent": 19.0,
"pos1": {
"x": -14.0,
"y": -126.0,
"z": 587.0
},
"pos2": {
"x": 17.0,
"y": 103.0,
"z": 617.0
}
},
{
"name": "Arboretum",
"owner": "pipo",
"pos1": {
"x": -1734.0,
"y": 7.0,
"z": 697.0
},
"pos2": {
"x": -1604.0,
"y": 50.0,
"z": 784.0
}
}
]

43
blockaccessor/blockaccessor.go
View File

@ -1,43 +0,0 @@
package blockaccessor
import (
"mapserver/coords"
"mapserver/mapblockaccessor"
)
func New(mba *mapblockaccessor.MapBlockAccessor) *BlockAccessor {
return &BlockAccessor{mba: mba}
}
type BlockAccessor struct {
mba *mapblockaccessor.MapBlockAccessor
}
type Block struct {
Name string
//TODO: param1, param2
}
func (this *BlockAccessor) GetBlock(x, y, z int) (*Block, error) {
mbc := coords.NewMapBlockCoordsFromBlock(x, y, z)
mapblock, err := this.mba.GetMapBlock(mbc)
if err != nil {
return nil, err
}
if mapblock == nil {
return nil, nil
}
relx := x % 16
rely := y % 16
relz := z % 16
block := Block{
Name: mapblock.GetNodeName(relx, rely, relz),
}
return &block, nil
}

59
blockaccessor/blockaccessor_test.go
View File

@ -1,59 +0,0 @@
package blockaccessor
import (
"fmt"
"io/ioutil"
"mapserver/db/sqlite"
"mapserver/mapblockaccessor"
"mapserver/testutils"
"os"
"testing"
"time"
"github.com/sirupsen/logrus"
)
func TestSimpleAccess(t *testing.T) {
logrus.SetLevel(logrus.DebugLevel)
tmpfile, err := ioutil.TempFile("", "TestMigrate.*.sqlite")
if err != nil {
panic(err)
}
defer os.Remove(tmpfile.Name())
testutils.CreateTestDatabase(tmpfile.Name())
a, err := sqlite.New(tmpfile.Name())
if err != nil {
panic(err)
}
err = a.Migrate()
if err != nil {
panic(err)
}
mba := mapblockaccessor.NewMapBlockAccessor(a, 500*time.Millisecond, 1000*time.Millisecond, 1000)
if mba == nil {
t.Fatal("Mapblockaccessor is nil")
}
ba := New(mba)
if ba == nil {
t.Fatal("blockaccessor is nil")
}
block, err := ba.GetBlock(0, 2, 0)
if err != nil {
panic(err)
}
if block == nil {
t.Fatal("block is nil")
}
fmt.Println(block.Name)
}

8
coords/convert.go
View File

@ -1,5 +1,7 @@
package coords package coords
import "mapserver/types"
// https://bitbucket.org/s_l_teichmann/mtsatellite/src/e1bf980a2b278c570b3f44f9452c9c087558acb3/common/coords.go?at=default&fileviewer=file-view-default // https://bitbucket.org/s_l_teichmann/mtsatellite/src/e1bf980a2b278c570b3f44f9452c9c087558acb3/common/coords.go?at=default&fileviewer=file-view-default
const ( const (
numBitsPerComponent = 12 numBitsPerComponent = 12
@ -11,7 +13,7 @@ const (
MinPlainCoord = -34351347711 MinPlainCoord = -34351347711
) )
func CoordToPlain(c *MapBlockCoords) int64 { func CoordToPlain(c *types.MapBlockCoords) int64 {
return int64(c.Z)<<(2*numBitsPerComponent) + return int64(c.Z)<<(2*numBitsPerComponent) +
int64(c.Y)<<numBitsPerComponent + int64(c.Y)<<numBitsPerComponent +
int64(c.X) int64(c.X)
@ -33,8 +35,8 @@ func pythonModulo(i int16) int16 {
return modulo - -i&mask return modulo - -i&mask
} }
func PlainToCoord(i int64) *MapBlockCoords { func PlainToCoord(i int64) *types.MapBlockCoords {
c := MapBlockCoords{} c := types.MapBlockCoords{}
c.X = unsignedToSigned(pythonModulo(int16(i))) c.X = unsignedToSigned(pythonModulo(int16(i)))
i = (i - int64(c.X)) >> numBitsPerComponent i = (i - int64(c.X)) >> numBitsPerComponent
c.Y = unsignedToSigned(pythonModulo(int16(i))) c.Y = unsignedToSigned(pythonModulo(int16(i)))

9
coords/convert_test.go
View File

@ -1,6 +1,7 @@
package coords package coords
import ( import (
"mapserver/types"
"testing" "testing"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -13,7 +14,7 @@ func init() {
} }
func TestMinCoord(t *testing.T) { func TestMinCoord(t *testing.T) {
c := NewMapBlockCoords(MinCoord, MinCoord, MinCoord) c := types.NewMapBlockCoords(types.MinCoord, types.MinCoord, types.MinCoord)
pc := CoordToPlain(c) pc := CoordToPlain(c)
log.WithFields(logrus.Fields{"coords": c, "plain": pc, "plain-1": pc - 1}).Info("TestMinCoord") log.WithFields(logrus.Fields{"coords": c, "plain": pc, "plain-1": pc - 1}).Info("TestMinCoord")
@ -22,7 +23,7 @@ func TestMinCoord(t *testing.T) {
} }
} }
func testCoordConvert(t *testing.T, mb *MapBlockCoords) { func testCoordConvert(t *testing.T, mb *types.MapBlockCoords) {
log.WithFields(logrus.Fields{"coords": mb}).Info("MapblockCoords") log.WithFields(logrus.Fields{"coords": mb}).Info("MapblockCoords")
p := CoordToPlain(mb) p := CoordToPlain(mb)
@ -45,6 +46,6 @@ func testCoordConvert(t *testing.T, mb *MapBlockCoords) {
} }
func TestZeorCoord(t *testing.T) { func TestZeroCoord(t *testing.T) {
testCoordConvert(t, NewMapBlockCoords(0, 0, 0)) testCoordConvert(t, types.NewMapBlockCoords(0, 0, 0))
} }

7
coords/mapblockcoords_test.go
View File

@ -1,23 +1,24 @@
package coords package coords
import ( import (
"mapserver/types"
"testing" "testing"
) )
func TestNewMapBlockCoordsFromBlock(t *testing.T) { func TestNewMapBlockCoordsFromBlock(t *testing.T) {
c := NewMapBlockCoordsFromBlock(1, 1, 1) c := types.NewMapBlockCoordsFromBlock(1, 1, 1)
if c.X != 0 || c.Y != 0 || c.Z != 0 { if c.X != 0 || c.Y != 0 || c.Z != 0 {
t.Fatal("mismatch", c) t.Fatal("mismatch", c)
} }
c = NewMapBlockCoordsFromBlock(16, 1, 1) c = types.NewMapBlockCoordsFromBlock(16, 1, 1)
if c.X != 1 || c.Y != 0 || c.Z != 0 { if c.X != 1 || c.Y != 0 || c.Z != 0 {
t.Fatal("mismatch", c) t.Fatal("mismatch", c)
} }
c = NewMapBlockCoordsFromBlock(16, 1, -1) c = types.NewMapBlockCoordsFromBlock(16, 1, -1)
if c.X != 1 || c.Y != 0 || c.Z != -1 { if c.X != 1 || c.Y != 0 || c.Z != -1 {
t.Fatal("mismatch", c) t.Fatal("mismatch", c)

14
coords/tileconvert.go
View File

@ -1,7 +1,7 @@
package coords package coords
import ( import (
"mapserver/layer" "mapserver/types"
"math" "math"
) )
@ -9,10 +9,10 @@ const (
MAX_ZOOM = 13 MAX_ZOOM = 13
) )
func GetTileCoordsFromMapBlock(mbc *MapBlockCoords, layers []*layer.Layer) *TileCoords { func GetTileCoordsFromMapBlock(mbc *types.MapBlockCoords, layers []*types.Layer) *TileCoords {
tc := TileCoords{X: mbc.X, Y: (mbc.Z + 1) * -1, Zoom: MAX_ZOOM} tc := TileCoords{X: mbc.X, Y: (mbc.Z + 1) * -1, Zoom: MAX_ZOOM}
currentLayer := layer.FindLayerByY(layers, mbc.Y) currentLayer := types.FindLayerByY(layers, mbc.Y)
if currentLayer == nil { if currentLayer == nil {
return nil return nil
@ -23,7 +23,7 @@ func GetTileCoordsFromMapBlock(mbc *MapBlockCoords, layers []*layer.Layer) *Tile
return &tc return &tc
} }
func GetMapBlockRangeFromTile(tc *TileCoords, y int) *MapBlockRange { func GetMapBlockRangeFromTile(tc *TileCoords, y int) *types.MapBlockRange {
scaleDiff := float64(MAX_ZOOM - tc.Zoom) scaleDiff := float64(MAX_ZOOM - tc.Zoom)
scale := int(math.Pow(2, scaleDiff)) scale := int(math.Pow(2, scaleDiff))
@ -33,8 +33,8 @@ func GetMapBlockRangeFromTile(tc *TileCoords, y int) *MapBlockRange {
mapBlockX2 := mapBlockX1 + scale - 1 mapBlockX2 := mapBlockX1 + scale - 1
mapBlockZ2 := (mapBlockZ1 + ((scale - 1) * -1)) mapBlockZ2 := (mapBlockZ1 + ((scale - 1) * -1))
return &MapBlockRange{ return &types.MapBlockRange{
Pos1: NewMapBlockCoords(mapBlockX1, y, mapBlockZ1), Pos1: types.NewMapBlockCoords(mapBlockX1, y, mapBlockZ1),
Pos2: NewMapBlockCoords(mapBlockX2, y, mapBlockZ2), Pos2: types.NewMapBlockCoords(mapBlockX2, y, mapBlockZ2),
} }
} }

23
coords/tileconvert_test.go
View File

@ -1,15 +1,16 @@
package coords package coords
import ( import (
"github.com/stretchr/testify/assert" "mapserver/types"
"mapserver/layer"
"testing" "testing"
"github.com/stretchr/testify/assert"
) )
func TestConvertMapblockToTile1(t *testing.T) { func TestConvertMapblockToTile1(t *testing.T) {
mbc := NewMapBlockCoords(0, 0, 0) mbc := types.NewMapBlockCoords(0, 0, 0)
layers := []*layer.Layer{ layers := []*types.Layer{
&layer.Layer{ {
Id: 0, Id: 0,
Name: "Base", Name: "Base",
From: -16, From: -16,
@ -47,9 +48,9 @@ func TestGetMapBlockRangeFromTile(t *testing.T) {
} }
func TestConvertMapblockToTile2(t *testing.T) { func TestConvertMapblockToTile2(t *testing.T) {
mbc := NewMapBlockCoords(1, 0, 1) mbc := types.NewMapBlockCoords(1, 0, 1)
layers := []*layer.Layer{ layers := []*types.Layer{
&layer.Layer{ {
Id: 0, Id: 0,
Name: "Base", Name: "Base",
From: -16, From: -16,
@ -73,9 +74,9 @@ func TestConvertMapblockToTile2(t *testing.T) {
} }
func TestConvertMapblockToTile3(t *testing.T) { func TestConvertMapblockToTile3(t *testing.T) {
mbc := NewMapBlockCoords(-1, 0, -1) mbc := types.NewMapBlockCoords(-1, 0, -1)
layers := []*layer.Layer{ layers := []*types.Layer{
&layer.Layer{ {
Id: 0, Id: 0,
Name: "Base", Name: "Base",
From: -16, From: -16,

9
db/accessor.go
View File

@ -1,13 +1,12 @@
package db package db
import ( import (
"mapserver/coords"
"mapserver/layer"
"mapserver/settings" "mapserver/settings"
"mapserver/types"
) )
type Block struct { type Block struct {
Pos *coords.MapBlockCoords Pos *types.MapBlockCoords
Data []byte Data []byte
Mtime int64 Mtime int64
} }
@ -25,6 +24,6 @@ type DBAccessor interface {
GetTimestamp() (int64, error) GetTimestamp() (int64, error)
FindBlocksByMtime(gtmtime int64, limit int) ([]*Block, error) FindBlocksByMtime(gtmtime int64, limit int) ([]*Block, error)
FindNextInitialBlocks(s settings.Settings, layers []*layer.Layer, limit int) (*InitialBlocksResult, error) FindNextInitialBlocks(s settings.Settings, layers []*types.Layer, limit int) (*InitialBlocksResult, error)
GetBlock(pos *coords.MapBlockCoords) (*Block, error) GetBlock(pos *types.MapBlockCoords) (*Block, error)
} }

6
db/postgres/initialblocks.go
View File

@ -3,8 +3,8 @@ package postgres
import ( import (
"mapserver/coords" "mapserver/coords"
"mapserver/db" "mapserver/db"
"mapserver/layer"
"mapserver/settings" "mapserver/settings"
"mapserver/types"
"math" "math"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -53,7 +53,7 @@ func (a *PostgresAccessor) countBlocks(x1, y1, z1, x2, y2, z2 int) (int, error)
//Zoom 9: //Zoom 9:
//10 mapblocks height * 16 * 16 == 2560 //10 mapblocks height * 16 * 16 == 2560
func (a *PostgresAccessor) FindNextInitialBlocks(s settings.Settings, layers []*layer.Layer, limit int) (*db.InitialBlocksResult, error) { func (a *PostgresAccessor) FindNextInitialBlocks(s settings.Settings, layers []*types.Layer, limit int) (*db.InitialBlocksResult, error) {
lastlayer := s.GetInt(SETTING_LAST_LAYER, 0) lastlayer := s.GetInt(SETTING_LAST_LAYER, 0)
lastxblock := s.GetInt(SETTING_LAST_X_BLOCK, -129) lastxblock := s.GetInt(SETTING_LAST_X_BLOCK, -129)
@ -88,7 +88,7 @@ func (a *PostgresAccessor) FindNextInitialBlocks(s settings.Settings, layers []*
} }
tc := coords.NewTileCoords(lastxblock, lastyblock, 9, lastlayer) tc := coords.NewTileCoords(lastxblock, lastyblock, 9, lastlayer)
currentlayer := layer.FindLayerById(layers, lastlayer) currentlayer := types.FindLayerById(layers, lastlayer)
tcr := coords.GetMapBlockRangeFromTile(tc, 0) tcr := coords.GetMapBlockRangeFromTile(tc, 0)
tcr.Pos1.Y = currentlayer.From tcr.Pos1.Y = currentlayer.From

6
db/postgres/postgres.go
View File

@ -3,8 +3,8 @@ package postgres
import ( import (
"database/sql" "database/sql"
"embed" "embed"
"mapserver/coords"
"mapserver/db" "mapserver/db"
"mapserver/types"
"time" "time"
_ "github.com/lib/pq" _ "github.com/lib/pq"
@ -47,7 +47,7 @@ func (db *PostgresAccessor) Migrate() error {
} }
func convertRows(posx, posy, posz int, data []byte, mtime int64) *db.Block { func convertRows(posx, posy, posz int, data []byte, mtime int64) *db.Block {
c := coords.NewMapBlockCoords(posx, posy, posz) c := types.NewMapBlockCoords(posx, posy, posz)
return &db.Block{Pos: c, Data: data, Mtime: mtime} return &db.Block{Pos: c, Data: data, Mtime: mtime}
} }
@ -122,7 +122,7 @@ func (a *PostgresAccessor) GetTimestamp() (int64, error) {
return 0, nil return 0, nil
} }
func (a *PostgresAccessor) GetBlock(pos *coords.MapBlockCoords) (*db.Block, error) { func (a *PostgresAccessor) GetBlock(pos *types.MapBlockCoords) (*db.Block, error) {
rows, err := a.db.Query(getBlockQuery, pos.X, pos.Y, pos.Z) rows, err := a.db.Query(getBlockQuery, pos.X, pos.Y, pos.Z)
if err != nil { if err != nil {
return nil, err return nil, err

6
db/sqlite/initialblocks.go
View File

@ -3,8 +3,8 @@ package sqlite
import ( import (
"mapserver/coords" "mapserver/coords"
"mapserver/db" "mapserver/db"
"mapserver/layer"
"mapserver/settings" "mapserver/settings"
"mapserver/types"
) )
const ( const (
@ -21,7 +21,7 @@ order by b.pos asc, b.mtime asc
limit ? limit ?
` `
func (a *Sqlite3Accessor) FindNextInitialBlocks(s settings.Settings, layers []*layer.Layer, limit int) (*db.InitialBlocksResult, error) { func (a *Sqlite3Accessor) FindNextInitialBlocks(s settings.Settings, layers []*types.Layer, limit int) (*db.InitialBlocksResult, error) {
result := &db.InitialBlocksResult{} result := &db.InitialBlocksResult{}
blocks := make([]*db.Block, 0) blocks := make([]*db.Block, 0)
@ -70,7 +70,7 @@ func (a *Sqlite3Accessor) FindNextInitialBlocks(s settings.Settings, layers []*l
lastpos = pos lastpos = pos
blockcoordy := mb.Pos.Y blockcoordy := mb.Pos.Y
currentlayer := layer.FindLayerByY(layers, blockcoordy) currentlayer := types.FindLayerByY(layers, blockcoordy)
if currentlayer != nil { if currentlayer != nil {
blocks = append(blocks, mb) blocks = append(blocks, mb)

3
db/sqlite/sqlite.go
View File

@ -6,6 +6,7 @@ import (
"errors" "errors"
"mapserver/coords" "mapserver/coords"
"mapserver/db" "mapserver/db"
"mapserver/types"
"time" "time"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -140,7 +141,7 @@ func (db *Sqlite3Accessor) GetTimestamp() (int64, error) {
return 0, nil return 0, nil
} }
func (db *Sqlite3Accessor) GetBlock(pos *coords.MapBlockCoords) (*db.Block, error) { func (db *Sqlite3Accessor) GetBlock(pos *types.MapBlockCoords) (*db.Block, error) {
ppos := coords.CoordToPlain(pos) ppos := coords.CoordToPlain(pos)
rows, err := db.db.Query(getBlockQuery, ppos) rows, err := db.db.Query(getBlockQuery, ppos)

6
db/sqlite/sqlite_test.go
View File

@ -2,8 +2,8 @@ package sqlite
import ( import (
"io/ioutil" "io/ioutil"
"mapserver/coords"
"mapserver/testutils" "mapserver/testutils"
"mapserver/types"
"os" "os"
"testing" "testing"
@ -11,7 +11,7 @@ import (
) )
func TestMigrateEmpty(t *testing.T) { func TestMigrateEmpty(t *testing.T) {
tmpfile, err := ioutil.TempFile("", "TestMigrateEmpty.*.sqlite") tmpfile, err := os.CreateTemp("", "TestMigrateEmpty.*.sqlite")
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -64,7 +64,7 @@ func TestMigrateAndQuery(t *testing.T) {
panic(err) panic(err)
} }
block, err := a.GetBlock(coords.NewMapBlockCoords(0, 0, 0)) block, err := a.GetBlock(types.NewMapBlockCoords(0, 0, 0))
if err != nil { if err != nil {
panic(err) panic(err)

1
go.mod
View File

@ -30,6 +30,7 @@ require (
github.com/mattn/go-isatty v0.0.17 // indirect github.com/mattn/go-isatty v0.0.17 // indirect
github.com/mattn/go-sqlite3 v1.14.16 // indirect github.com/mattn/go-sqlite3 v1.14.16 // indirect
github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
github.com/minetest-go/areasparser v1.0.5 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/prometheus/client_model v0.4.1-0.20230718164431-9a2bf3000d16 // indirect github.com/prometheus/client_model v0.4.1-0.20230718164431-9a2bf3000d16 // indirect
github.com/prometheus/common v0.44.0 // indirect github.com/prometheus/common v0.44.0 // indirect

2
go.sum
View File

@ -184,6 +184,8 @@ github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0j
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
github.com/minetest-go/areasparser v1.0.5 h1:kyfb7mk4S7Gvx5N42uJK8ze3BAbfj8uyLsv2Tuy43MQ=
github.com/minetest-go/areasparser v1.0.5/go.mod h1:NvohBk60WBrAbfvgmJccCEblz9I/Ygba4k9V81rwoNc=
github.com/minetest-go/colormapping v1.0.2 h1:VpbSt6olNcb0yFw3z6wQC/RnZtJVRvtqhpzG+X8mrrc= github.com/minetest-go/colormapping v1.0.2 h1:VpbSt6olNcb0yFw3z6wQC/RnZtJVRvtqhpzG+X8mrrc=
github.com/minetest-go/colormapping v1.0.2/go.mod h1:arMBjO6+z8+yhLvrsX4tCnYq5fzGcPFUOj/4Xb78Ktc= github.com/minetest-go/colormapping v1.0.2/go.mod h1:arMBjO6+z8+yhLvrsX4tCnYq5fzGcPFUOj/4Xb78Ktc=
github.com/minetest-go/mapparser v0.1.8 h1:tmkno1Qi8nIdjQXJLlnq38uVGygZWA8i3ilre/bB9W8= github.com/minetest-go/mapparser v0.1.8 h1:tmkno1Qi8nIdjQXJLlnq38uVGygZWA8i3ilre/bB9W8=

3
mapblockaccessor/get.go
View File

@ -1,7 +1,6 @@
package mapblockaccessor package mapblockaccessor
import ( import (
"mapserver/coords"
"mapserver/eventbus" "mapserver/eventbus"
"mapserver/types" "mapserver/types"
"sync" "sync"
@ -14,7 +13,7 @@ import (
var lock = &sync.RWMutex{} var lock = &sync.RWMutex{}
func (a *MapBlockAccessor) GetMapBlock(pos *coords.MapBlockCoords) (*mapparser.MapBlock, error) { func (a *MapBlockAccessor) GetMapBlock(pos *types.MapBlockCoords) (*mapparser.MapBlock, error) {
cache_enabled := a.maxcount > 0 cache_enabled := a.maxcount > 0
key := getKey(pos) key := getKey(pos)

3
mapblockaccessor/legacyblocks.go
View File

@ -2,7 +2,6 @@ package mapblockaccessor
import ( import (
"mapserver/eventbus" "mapserver/eventbus"
"mapserver/layer"
"mapserver/settings" "mapserver/settings"
"mapserver/types" "mapserver/types"
@ -19,7 +18,7 @@ type FindNextLegacyBlocksResult struct {
LastMtime int64 LastMtime int64
} }
func (a *MapBlockAccessor) FindNextLegacyBlocks(s settings.Settings, layers []*layer.Layer, limit int) (*FindNextLegacyBlocksResult, error) { func (a *MapBlockAccessor) FindNextLegacyBlocks(s settings.Settings, layers []*types.Layer, limit int) (*FindNextLegacyBlocksResult, error) {
nextResult, err := a.accessor.FindNextInitialBlocks(s, layers, limit) nextResult, err := a.accessor.FindNextInitialBlocks(s, layers, limit)

4
mapblockaccessor/mapblockaccessor.go
View File

@ -2,9 +2,9 @@ package mapblockaccessor
import ( import (
"fmt" "fmt"
"mapserver/coords"
"mapserver/db" "mapserver/db"
"mapserver/eventbus" "mapserver/eventbus"
"mapserver/types"
"time" "time"
@ -18,7 +18,7 @@ type MapBlockAccessor struct {
maxcount int maxcount int
} }
func getKey(pos *coords.MapBlockCoords) string { func getKey(pos *types.MapBlockCoords) string {
return fmt.Sprintf("Coord %d/%d/%d", pos.X, pos.Y, pos.Z) return fmt.Sprintf("Coord %d/%d/%d", pos.X, pos.Y, pos.Z)
} }

4
mapblockaccessor/mapblockaccessor_test.go
View File

@ -2,9 +2,9 @@ package mapblockaccessor
import ( import (
"io/ioutil" "io/ioutil"
"mapserver/coords"
"mapserver/db/sqlite" "mapserver/db/sqlite"
"mapserver/testutils" "mapserver/testutils"
"mapserver/types"
"os" "os"
"testing" "testing"
"time" "time"
@ -33,7 +33,7 @@ func TestSimpleAccess(t *testing.T) {
} }
cache := NewMapBlockAccessor(a, 500*time.Millisecond, 1000*time.Millisecond, 1000) cache := NewMapBlockAccessor(a, 500*time.Millisecond, 1000*time.Millisecond, 1000)
mb, err := cache.GetMapBlock(coords.NewMapBlockCoords(0, 0, 0)) mb, err := cache.GetMapBlock(types.NewMapBlockCoords(0, 0, 0))
if err != nil { if err != nil {
panic(err) panic(err)

10
mapblockaccessor/mtime.go
View File

@ -1,9 +1,7 @@
package mapblockaccessor package mapblockaccessor
import ( import (
"mapserver/coords"
"mapserver/eventbus" "mapserver/eventbus"
"mapserver/layer"
"mapserver/types" "mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
@ -14,13 +12,13 @@ import (
type FindMapBlocksByMtimeResult struct { type FindMapBlocksByMtimeResult struct {
HasMore bool HasMore bool
LastPos *coords.MapBlockCoords LastPos *types.MapBlockCoords
LastMtime int64 LastMtime int64
List []*types.ParsedMapblock List []*types.ParsedMapblock
UnfilteredCount int UnfilteredCount int
} }
func (a *MapBlockAccessor) FindMapBlocksByMtime(lastmtime int64, limit int, layerfilter []*layer.Layer) (*FindMapBlocksByMtimeResult, error) { func (a *MapBlockAccessor) FindMapBlocksByMtime(lastmtime int64, limit int, layerfilter []*types.Layer) (*FindMapBlocksByMtimeResult, error) {
fields := logrus.Fields{ fields := logrus.Fields{
"lastmtime": lastmtime, "lastmtime": lastmtime,
@ -41,7 +39,7 @@ func (a *MapBlockAccessor) FindMapBlocksByMtime(lastmtime int64, limit int, laye
result := FindMapBlocksByMtimeResult{} result := FindMapBlocksByMtimeResult{}
mblist := make([]*types.ParsedMapblock, 0) mblist := make([]*types.ParsedMapblock, 0)
var newlastpos *coords.MapBlockCoords var newlastpos *types.MapBlockCoords
result.HasMore = len(blocks) == limit result.HasMore = len(blocks) == limit
result.UnfilteredCount = len(blocks) result.UnfilteredCount = len(blocks)
@ -51,7 +49,7 @@ func (a *MapBlockAccessor) FindMapBlocksByMtime(lastmtime int64, limit int, laye
result.LastMtime = block.Mtime result.LastMtime = block.Mtime
} }
currentLayer := layer.FindLayerByY(layerfilter, block.Pos.Y) currentLayer := types.FindLayerByY(layerfilter, block.Pos.Y)
if currentLayer == nil { if currentLayer == nil {
continue continue

4
mapblockaccessor/update.go
View File

@ -1,13 +1,13 @@
package mapblockaccessor package mapblockaccessor
import ( import (
"mapserver/coords" "mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
cache "github.com/patrickmn/go-cache" cache "github.com/patrickmn/go-cache"
) )
func (a *MapBlockAccessor) Update(pos *coords.MapBlockCoords, mb *mapparser.MapBlock) { func (a *MapBlockAccessor) Update(pos *types.MapBlockCoords, mb *mapparser.MapBlock) {
key := getKey(pos) key := getKey(pos)
cacheBlockCount.Inc() cacheBlockCount.Inc()
a.blockcache.Set(key, mb, cache.DefaultExpiration) a.blockcache.Set(key, mb, cache.DefaultExpiration)

10
mapblockrenderer/renderer.go
View File

@ -4,8 +4,8 @@ import (
"errors" "errors"
"image" "image"
"image/color" "image/color"
"mapserver/coords"
"mapserver/mapblockaccessor" "mapserver/mapblockaccessor"
"mapserver/types"
"time" "time"
"github.com/minetest-go/colormapping" "github.com/minetest-go/colormapping"
@ -73,7 +73,7 @@ func addColorComponent(c *color.RGBA, value int) *color.RGBA {
} }
} }
func (r *MapBlockRenderer) Render(pos1, pos2 *coords.MapBlockCoords) (*image.NRGBA, error) { func (r *MapBlockRenderer) Render(pos1, pos2 *types.MapBlockCoords) (*image.NRGBA, error) {
if pos1.X != pos2.X { if pos1.X != pos2.X {
return nil, errors.New("x does not line up") return nil, errors.New("x does not line up")
} }
@ -111,7 +111,7 @@ func (r *MapBlockRenderer) Render(pos1, pos2 *coords.MapBlockCoords) (*image.NRG
} }
for mapBlockY := maxY; mapBlockY >= minY; mapBlockY-- { for mapBlockY := maxY; mapBlockY >= minY; mapBlockY-- {
currentPos := coords.NewMapBlockCoords(pos1.X, mapBlockY, pos1.Z) currentPos := types.NewMapBlockCoords(pos1.X, mapBlockY, pos1.Z)
mb, err := r.accessor.GetMapBlock(currentPos) mb, err := r.accessor.GetMapBlock(currentPos)
if err != nil { if err != nil {
@ -154,7 +154,7 @@ func (r *MapBlockRenderer) Render(pos1, pos2 *coords.MapBlockCoords) (*image.NRG
} else { } else {
//neighbouring mapblock //neighbouring mapblock
neighbourPos := coords.NewMapBlockCoords(currentPos.X-1, currentPos.Y, currentPos.Z) neighbourPos := types.NewMapBlockCoords(currentPos.X-1, currentPos.Y, currentPos.Z)
neighbourMapblock, err := r.accessor.GetMapBlock(neighbourPos) neighbourMapblock, err := r.accessor.GetMapBlock(neighbourPos)
if neighbourMapblock != nil && err == nil { if neighbourMapblock != nil && err == nil {
@ -174,7 +174,7 @@ func (r *MapBlockRenderer) Render(pos1, pos2 *coords.MapBlockCoords) (*image.NRG
} else { } else {
//neighbouring mapblock //neighbouring mapblock
neighbourPos := coords.NewMapBlockCoords(currentPos.X, currentPos.Y, currentPos.Z+1) neighbourPos := types.NewMapBlockCoords(currentPos.X, currentPos.Y, currentPos.Z+1)
neighbourMapblock, err := r.accessor.GetMapBlock(neighbourPos) neighbourMapblock, err := r.accessor.GetMapBlock(neighbourPos)
if neighbourMapblock != nil && err == nil { if neighbourMapblock != nil && err == nil {

18
mapblockrenderer/renderer_benchmark_test.go
View File

@ -2,10 +2,10 @@ package mapblockrenderer
import ( import (
"io/ioutil" "io/ioutil"
"mapserver/coords"
"mapserver/db/sqlite" "mapserver/db/sqlite"
"mapserver/mapblockaccessor" "mapserver/mapblockaccessor"
"mapserver/testutils" "mapserver/testutils"
"mapserver/types"
"os" "os"
"testing" "testing"
"time" "time"
@ -59,8 +59,8 @@ func BenchmarkRenderEmptySingle(b *testing.B) {
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
pos1 := coords.NewMapBlockCoords(10, 0, 10) pos1 := types.NewMapBlockCoords(10, 0, 10)
pos2 := coords.NewMapBlockCoords(10, 0, 10) pos2 := types.NewMapBlockCoords(10, 0, 10)
_, err := r.Render(pos1, pos2) _, err := r.Render(pos1, pos2)
@ -76,8 +76,8 @@ func BenchmarkRenderSingle(b *testing.B) {
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
pos1 := coords.NewMapBlockCoords(0, 0, 0) pos1 := types.NewMapBlockCoords(0, 0, 0)
pos2 := coords.NewMapBlockCoords(0, 0, 0) pos2 := types.NewMapBlockCoords(0, 0, 0)
_, err := r.Render(pos1, pos2) _, err := r.Render(pos1, pos2)
@ -93,8 +93,8 @@ func BenchmarkRenderStride(b *testing.B) {
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
pos1 := coords.NewMapBlockCoords(0, 10, 0) pos1 := types.NewMapBlockCoords(0, 10, 0)
pos2 := coords.NewMapBlockCoords(0, -1, 0) pos2 := types.NewMapBlockCoords(0, -1, 0)
_, err := r.Render(pos1, pos2) _, err := r.Render(pos1, pos2)
@ -110,8 +110,8 @@ func BenchmarkRenderBigStride(b *testing.B) {
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
pos1 := coords.NewMapBlockCoords(0, 1000, 0) pos1 := types.NewMapBlockCoords(0, 1000, 0)
pos2 := coords.NewMapBlockCoords(0, -1000, 0) pos2 := types.NewMapBlockCoords(0, -1000, 0)
_, err := r.Render(pos1, pos2) _, err := r.Render(pos1, pos2)

8
mapblockrenderer/renderer_test.go
View File

@ -5,9 +5,9 @@ import (
"io/ioutil" "io/ioutil"
"mapserver/coords" "mapserver/coords"
"mapserver/db/sqlite" "mapserver/db/sqlite"
"mapserver/layer"
"mapserver/mapblockaccessor" "mapserver/mapblockaccessor"
"mapserver/testutils" "mapserver/testutils"
"mapserver/types"
"os" "os"
"testing" "testing"
"time" "time"
@ -20,7 +20,7 @@ import (
func TestSimpleRender(t *testing.T) { func TestSimpleRender(t *testing.T) {
logrus.SetLevel(logrus.InfoLevel) logrus.SetLevel(logrus.InfoLevel)
layers := []*layer.Layer{ layers := []*types.Layer{
{ {
Id: 0, Id: 0,
Name: "Base", Name: "Base",
@ -81,8 +81,8 @@ func TestSimpleRender(t *testing.T) {
for x := from; x < to; x++ { for x := from; x < to; x++ {
for z := from; z < to; z++ { for z := from; z < to; z++ {
pos1 := coords.NewMapBlockCoords(x, 10, z) pos1 := types.NewMapBlockCoords(x, 10, z)
pos2 := coords.NewMapBlockCoords(x, -1, z) pos2 := types.NewMapBlockCoords(x, -1, z)
jobs <- JobData{Pos1: pos1, Pos2: pos2} jobs <- JobData{Pos1: pos1, Pos2: pos2}
} }

4
mapblockrenderer/worker.go
View File

@ -3,12 +3,12 @@ package mapblockrenderer
import ( import (
"bytes" "bytes"
"image/png" "image/png"
"mapserver/coords" "mapserver/types"
"time" "time"
) )
type JobData struct { type JobData struct {
Pos1, Pos2 *coords.MapBlockCoords Pos1, Pos2 *types.MapBlockCoords
} }
type JobResult struct { type JobResult struct {

4
mapobject/atm.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type ATM struct{} type ATM struct{}
func (this *ATM) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *ATM) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
nodename := block.GetNodeName(x, y, z) nodename := block.GetNodeName(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "atm") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "atm")

4
mapobject/bones.go
View File

@ -1,8 +1,8 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"strconv" "strconv"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
@ -10,7 +10,7 @@ import (
type BonesBlock struct{} type BonesBlock struct{}
func (this *BonesBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *BonesBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
invMap := block.Metadata.GetInventoryMapAtPos(x, y, z) invMap := block.Metadata.GetInventoryMapAtPos(x, y, z)

4
mapobject/border.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type BorderBlock struct{} type BorderBlock struct{}
func (this *BorderBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *BorderBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "border") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "border")

4
mapobject/digilinelcd.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type DigilineLcdBlock struct{} type DigilineLcdBlock struct{}
func (this *DigilineLcdBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *DigilineLcdBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "digilinelcd") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "digilinelcd")

4
mapobject/digiterms.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type DigitermsBlock struct{} type DigitermsBlock struct{}
func (this *DigitermsBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *DigitermsBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "digiterm") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "digiterm")

4
mapobject/fancyvend.go
View File

@ -1,9 +1,9 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/luaparser" "mapserver/luaparser"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"math" "math"
"strconv" "strconv"
@ -13,7 +13,7 @@ import (
type FancyVend struct{} type FancyVend struct{}
func (this *FancyVend) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *FancyVend) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
nodename := block.GetNodeName(x, y, z) nodename := block.GetNodeName(x, y, z)
invMap := block.Metadata.GetInventoryMapAtPos(x, y, z) invMap := block.Metadata.GetInventoryMapAtPos(x, y, z)

4
mapobject/jumpdrive.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type JumpdriveBlock struct{} type JumpdriveBlock struct{}
func (this *JumpdriveBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *JumpdriveBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "jumpdrive") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "jumpdrive")

4
mapobject/label.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type LabelBlock struct{} type LabelBlock struct{}
func (this *LabelBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *LabelBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "label") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "label")

4
mapobject/listener.go
View File

@ -12,11 +12,11 @@ import (
) )
type MapObjectListener interface { type MapObjectListener interface {
onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject
} }
type MapMultiObjectListener interface { type MapMultiObjectListener interface {
onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) []*mapobjectdb.MapObject onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) []*mapobjectdb.MapObject
} }
type Listener struct { type Listener struct {

4
mapobject/locator.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type Locator struct{} type Locator struct{}
func (this *Locator) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *Locator) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
nodename := block.GetNodeName(x, y, z) nodename := block.GetNodeName(x, y, z)

4
mapobject/luacontroller.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type LuaControllerBlock struct{} type LuaControllerBlock struct{}
func (this *LuaControllerBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *LuaControllerBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
//md := block.Metadata.GetMetadata(x, y, z) //md := block.Metadata.GetMetadata(x, y, z)
nodename := block.GetNodeName(x, y, z) nodename := block.GetNodeName(x, y, z)

4
mapobject/mission.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type MissionBlock struct{} type MissionBlock struct{}
func (this *MissionBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *MissionBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
if md["hidden"] == "1" { if md["hidden"] == "1" {

4
mapobject/nuclearreactor.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type NuclearReactorBlock struct{} type NuclearReactorBlock struct{}
func (this *NuclearReactorBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *NuclearReactorBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "nuclearreactor") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "nuclearreactor")

4
mapobject/poi.go
View File

@ -1,8 +1,8 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
@ -11,7 +11,7 @@ type PoiBlock struct {
Color string Color string
} }
func (this *PoiBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *PoiBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "poi") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "poi")

4
mapobject/privprotector.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type PrivProtectorBlock struct{} type PrivProtectorBlock struct{}
func (this *PrivProtectorBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *PrivProtectorBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "privprotector") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "privprotector")

4
mapobject/protector.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type ProtectorBlock struct{} type ProtectorBlock struct{}
func (this *ProtectorBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *ProtectorBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "protector") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "protector")

4
mapobject/quarry.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type QuarryBlock struct{} type QuarryBlock struct{}
func (this *QuarryBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *QuarryBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
if md["owner"] == "" { if md["owner"] == "" {

4
mapobject/sign.go
View File

@ -1,8 +1,8 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
@ -11,7 +11,7 @@ type SignBlock struct {
Material string Material string
} }
func (this *SignBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *SignBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "sign") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "sign")

4
mapobject/smartshop.go
View File

@ -1,8 +1,8 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"math" "math"
"strconv" "strconv"
@ -11,7 +11,7 @@ import (
type SmartShopBlock struct{} type SmartShopBlock struct{}
func (this *SmartShopBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) []*mapobjectdb.MapObject { func (this *SmartShopBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) []*mapobjectdb.MapObject {
list := make([]*mapobjectdb.MapObject, 0) list := make([]*mapobjectdb.MapObject, 0)
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)

4
mapobject/technicanchor.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type TechnicAnchorBlock struct{} type TechnicAnchorBlock struct{}
func (this *TechnicAnchorBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *TechnicAnchorBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "technicanchor") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "technicanchor")

4
mapobject/technicswitch.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type TechnicSwitchBlock struct{} type TechnicSwitchBlock struct{}
func (this *TechnicSwitchBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *TechnicSwitchBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "technicswitch") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "technicswitch")

4
mapobject/train.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type TrainBlock struct{} type TrainBlock struct{}
func (this *TrainBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *TrainBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "train") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "train")

4
mapobject/travelnet.go
View File

@ -1,8 +1,8 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"strings" "strings"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
@ -10,7 +10,7 @@ import (
type TravelnetBlock struct{} type TravelnetBlock struct{}
func (tn *TravelnetBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (tn *TravelnetBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
// ignore (P) prefixed stations // ignore (P) prefixed stations

4
mapobject/xpprotector.go
View File

@ -1,15 +1,15 @@
package mapobject package mapobject
import ( import (
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type XPProtectorBlock struct{} type XPProtectorBlock struct{}
func (this *XPProtectorBlock) onMapObject(mbpos *coords.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject { func (this *XPProtectorBlock) onMapObject(mbpos *types.MapBlockCoords, x, y, z int, block *mapparser.MapBlock) *mapobjectdb.MapObject {
md := block.Metadata.GetMetadata(x, y, z) md := block.Metadata.GetMetadata(x, y, z)
o := mapobjectdb.NewMapObject(mbpos, x, y, z, "xpprotector") o := mapobjectdb.NewMapObject(mbpos, x, y, z, "xpprotector")

11
mapobjectdb/accessor.go
View File

@ -2,6 +2,7 @@ package mapobjectdb
import ( import (
"mapserver/coords" "mapserver/coords"
"mapserver/types"
"time" "time"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -21,7 +22,7 @@ type Tile struct {
type MapObject struct { type MapObject struct {
//mapblock position //mapblock position
MBPos *coords.MapBlockCoords `json:"mapblock"` MBPos *types.MapBlockCoords `json:"mapblock"`
//block position //block position
X int `json:"x"` X int `json:"x"`
@ -33,7 +34,7 @@ type MapObject struct {
Attributes map[string]string `json:"attributes"` Attributes map[string]string `json:"attributes"`
} }
func NewMapObject(MBPos *coords.MapBlockCoords, x int, y int, z int, _type string) *MapObject { func NewMapObject(MBPos *types.MapBlockCoords, x int, y int, z int, _type string) *MapObject {
fields := logrus.Fields{ fields := logrus.Fields{
"mbpos": MBPos, "mbpos": MBPos,
@ -64,8 +65,8 @@ type SearchAttributeLike struct {
type SearchQuery struct { type SearchQuery struct {
//mapblock position //mapblock position
Pos1 *coords.MapBlockCoords `json:"pos1"` Pos1 *types.MapBlockCoords `json:"pos1"`
Pos2 *coords.MapBlockCoords `json:"pos2"` Pos2 *types.MapBlockCoords `json:"pos2"`
Type string `json:"type"` Type string `json:"type"`
AttributeLike *SearchAttributeLike `json:"attributelike"` AttributeLike *SearchAttributeLike `json:"attributelike"`
Limit *int `json:"limit"` Limit *int `json:"limit"`
@ -77,7 +78,7 @@ type DBAccessor interface {
//Generic map objects (poi, etc) //Generic map objects (poi, etc)
GetMapData(q *SearchQuery) ([]*MapObject, error) GetMapData(q *SearchQuery) ([]*MapObject, error)
RemoveMapData(pos *coords.MapBlockCoords) error RemoveMapData(pos *types.MapBlockCoords) error
AddMapData(data *MapObject) error AddMapData(data *MapObject) error
//Settings //Settings

4
mapobjectdb/accessor_test.go
View File

@ -2,7 +2,7 @@ package mapobjectdb
import ( import (
"fmt" "fmt"
"mapserver/coords" "mapserver/types"
"testing" "testing"
) )
@ -10,7 +10,7 @@ func TestNewMapBlockCoords(t *testing.T) {
attrs := make(map[string]string) attrs := make(map[string]string)
attrs["X"] = "y" attrs["X"] = "y"
pos := coords.NewMapBlockCoords(1, 2, 3) pos := types.NewMapBlockCoords(1, 2, 3)
fmt.Println(pos) fmt.Println(pos)
obj := NewMapObject(pos, 10, 12, 14, "xy") obj := NewMapObject(pos, 10, 12, 14, "xy")

6
mapobjectdb/postgres/mapobjects.go
View File

@ -2,8 +2,8 @@ package postgres
import ( import (
"database/sql" "database/sql"
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"unicode/utf8" "unicode/utf8"
"github.com/google/uuid" "github.com/google/uuid"
@ -63,7 +63,7 @@ func (a *PostgresAccessor) GetMapData(q *mapobjectdb.SearchQuery) ([]*mapobjectd
} }
if currentUID == "" || currentUID != id { if currentUID == "" || currentUID != id {
pos := coords.NewMapBlockCoords(posx, posy, posz) pos := types.NewMapBlockCoords(posx, posy, posz)
mo := &mapobjectdb.MapObject{ mo := &mapobjectdb.MapObject{
MBPos: pos, MBPos: pos,
Type: Type, Type: Type,
@ -87,7 +87,7 @@ func (a *PostgresAccessor) GetMapData(q *mapobjectdb.SearchQuery) ([]*mapobjectd
return result, nil return result, nil
} }
func (a *PostgresAccessor) RemoveMapData(pos *coords.MapBlockCoords) error { func (a *PostgresAccessor) RemoveMapData(pos *types.MapBlockCoords) error {
_, err := a.db.Exec(removeMapDataQuery, pos.X, pos.Y, pos.Z) _, err := a.db.Exec(removeMapDataQuery, pos.X, pos.Y, pos.Z)
return err return err
} }

6
mapobjectdb/sqlite/mapobjects.go
View File

@ -2,8 +2,8 @@ package sqlite
import ( import (
"database/sql" "database/sql"
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"unicode/utf8" "unicode/utf8"
"github.com/google/uuid" "github.com/google/uuid"
@ -63,7 +63,7 @@ func (db *Sqlite3Accessor) GetMapData(q *mapobjectdb.SearchQuery) ([]*mapobjectd
} }
if currentUID == "" || currentUID != uid { if currentUID == "" || currentUID != uid {
pos := coords.NewMapBlockCoords(posx, posy, posz) pos := types.NewMapBlockCoords(posx, posy, posz)
mo := &mapobjectdb.MapObject{ mo := &mapobjectdb.MapObject{
MBPos: pos, MBPos: pos,
Type: Type, Type: Type,
@ -86,7 +86,7 @@ func (db *Sqlite3Accessor) GetMapData(q *mapobjectdb.SearchQuery) ([]*mapobjectd
return result, nil return result, nil
} }
func (a *Sqlite3Accessor) RemoveMapData(pos *coords.MapBlockCoords) error { func (a *Sqlite3Accessor) RemoveMapData(pos *types.MapBlockCoords) error {
_, err := a.db.Exec(removeMapDataAttributesQuery, pos.X, pos.Y, pos.Z) _, err := a.db.Exec(removeMapDataAttributesQuery, pos.X, pos.Y, pos.Z)
if err != nil { if err != nil {
return err return err

8
mapobjectdb/sqlite/mapobjects_test.go
View File

@ -3,8 +3,8 @@ package sqlite
import ( import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"os" "os"
"testing" "testing"
) )
@ -48,7 +48,7 @@ func TestMapObjects(t *testing.T) {
attrs := make(map[string]string) attrs := make(map[string]string)
attrs["X"] = "y" attrs["X"] = "y"
pos := coords.NewMapBlockCoords(0, 0, 0) pos := types.NewMapBlockCoords(0, 0, 0)
o := mapobjectdb.MapObject{ o := mapobjectdb.MapObject{
MBPos: pos, MBPos: pos,
@ -105,7 +105,7 @@ func TestMapObjectsQueryWithAttribute(t *testing.T) {
attrs := make(map[string]string) attrs := make(map[string]string)
attrs["X"] = "y" attrs["X"] = "y"
pos := coords.NewMapBlockCoords(0, 0, 0) pos := types.NewMapBlockCoords(0, 0, 0)
o := mapobjectdb.MapObject{ o := mapobjectdb.MapObject{
MBPos: pos, MBPos: pos,
@ -169,7 +169,7 @@ func TestMapObjectsQueryWithAttributeIgnoreCase(t *testing.T) {
attrs := make(map[string]string) attrs := make(map[string]string)
attrs["X"] = "ABC" attrs["X"] = "ABC"
pos := coords.NewMapBlockCoords(0, 0, 0) pos := types.NewMapBlockCoords(0, 0, 0)
o := mapobjectdb.MapObject{ o := mapobjectdb.MapObject{
MBPos: pos, MBPos: pos,

17
tilerenderer/renderer.go
View File

@ -3,24 +3,25 @@ package tilerenderer
import ( import (
"bytes" "bytes"
"errors" "errors"
"github.com/prometheus/client_golang/prometheus"
"github.com/sirupsen/logrus"
"image" "image"
"image/draw" "image/draw"
"image/png" "image/png"
"mapserver/coords" "mapserver/coords"
"mapserver/db" "mapserver/db"
"mapserver/eventbus" "mapserver/eventbus"
"mapserver/layer"
"mapserver/mapblockrenderer" "mapserver/mapblockrenderer"
"mapserver/tiledb" "mapserver/tiledb"
"mapserver/types"
"strconv" "strconv"
"time" "time"
"github.com/prometheus/client_golang/prometheus"
"github.com/sirupsen/logrus"
) )
type TileRenderer struct { type TileRenderer struct {
mapblockrenderer *mapblockrenderer.MapBlockRenderer mapblockrenderer *mapblockrenderer.MapBlockRenderer
layers []*layer.Layer layers []*types.Layer
tdb *tiledb.TileDB tdb *tiledb.TileDB
dba db.DBAccessor dba db.DBAccessor
Eventbus *eventbus.Eventbus Eventbus *eventbus.Eventbus
@ -56,7 +57,7 @@ func resizeImage(src *image.NRGBA, tgt *image.NRGBA, xoffset int, yoffset int) {
func NewTileRenderer(mapblockrenderer *mapblockrenderer.MapBlockRenderer, func NewTileRenderer(mapblockrenderer *mapblockrenderer.MapBlockRenderer,
tdb *tiledb.TileDB, tdb *tiledb.TileDB,
dba db.DBAccessor, dba db.DBAccessor,
layers []*layer.Layer) *TileRenderer { layers []*types.Layer) *TileRenderer {
return &TileRenderer{ return &TileRenderer{
mapblockrenderer: mapblockrenderer, mapblockrenderer: mapblockrenderer,
@ -123,14 +124,14 @@ func (tr *TileRenderer) renderImage(tc *coords.TileCoords, recursionDepth int) (
timer := prometheus.NewTimer(renderDuration) timer := prometheus.NewTimer(renderDuration)
defer timer.ObserveDuration() defer timer.ObserveDuration()
currentLayer := layer.FindLayerById(tr.layers, tc.LayerId) currentLayer := types.FindLayerById(tr.layers, tc.LayerId)
if currentLayer == nil { if currentLayer == nil {
return nil, errors.New("No layer found") return nil, errors.New("no layer found")
} }
if tc.Zoom > 13 || tc.Zoom < 1 { if tc.Zoom > 13 || tc.Zoom < 1 {
return nil, errors.New("Invalid zoom") return nil, errors.New("invalid zoom")
} }
if tc.Zoom == 13 { if tc.Zoom == 13 {

4
tilerenderer/renderer_benchmark_test.go
View File

@ -4,11 +4,11 @@ import (
"io/ioutil" "io/ioutil"
"mapserver/coords" "mapserver/coords"
"mapserver/db/sqlite" "mapserver/db/sqlite"
"mapserver/layer"
"mapserver/mapblockaccessor" "mapserver/mapblockaccessor"
"mapserver/mapblockrenderer" "mapserver/mapblockrenderer"
"mapserver/testutils" "mapserver/testutils"
"mapserver/tiledb" "mapserver/tiledb"
"mapserver/types"
"os" "os"
"testing" "testing"
"time" "time"
@ -53,7 +53,7 @@ func BenchmarkTileRender(b *testing.B) {
tdb, _ := tiledb.New(tiletmpdir) tdb, _ := tiledb.New(tiletmpdir)
layers := []*layer.Layer{ layers := []*types.Layer{
{ {
Id: 0, Id: 0,
Name: "Base", Name: "Base",

4
tilerenderer/renderer_test.go
View File

@ -4,11 +4,11 @@ import (
"io/ioutil" "io/ioutil"
"mapserver/coords" "mapserver/coords"
"mapserver/db/sqlite" "mapserver/db/sqlite"
"mapserver/layer"
"mapserver/mapblockaccessor" "mapserver/mapblockaccessor"
"mapserver/mapblockrenderer" "mapserver/mapblockrenderer"
"mapserver/testutils" "mapserver/testutils"
"mapserver/tiledb" "mapserver/tiledb"
"mapserver/types"
"os" "os"
"testing" "testing"
"time" "time"
@ -53,7 +53,7 @@ func TestTileRender(t *testing.T) {
tdb, _ := tiledb.New(tiletmpdir) tdb, _ := tiledb.New(tiletmpdir)
layers := []*layer.Layer{ layers := []*types.Layer{
{ {
Id: 0, Id: 0,
Name: "Base", Name: "Base",

2
layer/layer.go → types/layer.go
View File

@ -1,4 +1,4 @@
package layer package types
type Layer struct { type Layer struct {
Id int `json:"id"` Id int `json:"id"`

2
coords/mapblockcoords.go → types/mapblockcoords.go
View File

@ -1,4 +1,4 @@
package coords package types
import ( import (
"math" "math"

6
types/parsedmapblock.go
View File

@ -1,16 +1,14 @@
package types package types
import ( import (
"mapserver/coords"
"github.com/minetest-go/mapparser" "github.com/minetest-go/mapparser"
) )
type ParsedMapblock struct { type ParsedMapblock struct {
Mapblock *mapparser.MapBlock Mapblock *mapparser.MapBlock
Pos *coords.MapBlockCoords Pos *MapBlockCoords
} }
func NewParsedMapblock(mb *mapparser.MapBlock, pos *coords.MapBlockCoords) *ParsedMapblock { func NewParsedMapblock(mb *mapparser.MapBlock, pos *MapBlockCoords) *ParsedMapblock {
return &ParsedMapblock{Mapblock: mb, Pos: pos} return &ParsedMapblock{Mapblock: mb, Pos: pos}
} }

3
web/areas.go
View File

@ -3,12 +3,13 @@ package web
import ( import (
"encoding/json" "encoding/json"
"mapserver/app" "mapserver/app"
"mapserver/areasparser"
"net/http" "net/http"
"os" "os"
"sync" "sync"
"time" "time"
"github.com/minetest-go/areasparser"
) )
type AreasHandler struct { type AreasHandler struct {

4
web/config.go
View File

@ -3,14 +3,14 @@ package web
import ( import (
"encoding/json" "encoding/json"
"mapserver/app" "mapserver/app"
"mapserver/layer" "mapserver/types"
"net/http" "net/http"
) )
// Public facing config // Public facing config
type PublicConfig struct { type PublicConfig struct {
Version string `json:"version"` Version string `json:"version"`
Layers []*layer.Layer `json:"layers"` Layers []*types.Layer `json:"layers"`
MapObjects *app.MapObjectConfig `json:"mapobjects"` MapObjects *app.MapObjectConfig `json:"mapobjects"`
DefaultOverlays []string `json:"defaultoverlays"` DefaultOverlays []string `json:"defaultoverlays"`
EnableSearch bool `json:"enablesearch"` EnableSearch bool `json:"enablesearch"`

4
web/mapblock.go
View File

@ -2,7 +2,7 @@ package web
import ( import (
"encoding/json" "encoding/json"
"mapserver/coords" "mapserver/types"
"net/http" "net/http"
"strconv" "strconv"
"strings" "strings"
@ -21,7 +21,7 @@ func (api *Api) GetMapBlockData(resp http.ResponseWriter, req *http.Request) {
y, _ := strconv.Atoi(parts[1]) y, _ := strconv.Atoi(parts[1])
z, _ := strconv.Atoi(parts[2]) z, _ := strconv.Atoi(parts[2])
c := coords.NewMapBlockCoords(x, y, z) c := types.NewMapBlockCoords(x, y, z)
mb, err := api.Context.MapBlockAccessor.GetMapBlock(c) mb, err := api.Context.MapBlockAccessor.GetMapBlock(c)
if err != nil { if err != nil {

6
web/mapobjects.go
View File

@ -2,8 +2,8 @@ package web
import ( import (
"encoding/json" "encoding/json"
"mapserver/coords"
"mapserver/mapobjectdb" "mapserver/mapobjectdb"
"mapserver/types"
"net/http" "net/http"
"github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus"
@ -31,11 +31,11 @@ func (api *Api) QueryMapobjects(resp http.ResponseWriter, req *http.Request) {
} }
if q.Pos1 == nil { if q.Pos1 == nil {
q.Pos1 = &coords.MapBlockCoords{X: -2048, Y: -2048, Z: -2048} q.Pos1 = &types.MapBlockCoords{X: -2048, Y: -2048, Z: -2048}
} }
if q.Pos2 == nil { if q.Pos2 == nil {
q.Pos2 = &coords.MapBlockCoords{X: 2048, Y: 2048, Z: 2048} q.Pos2 = &types.MapBlockCoords{X: 2048, Y: 2048, Z: 2048}
} }
objects, err := api.Context.Objectdb.GetMapData(&q) objects, err := api.Context.Objectdb.GetMapData(&q)

4
web/viewblock.go
View File

@ -2,7 +2,7 @@ package web
import ( import (
"encoding/json" "encoding/json"
"mapserver/coords" "mapserver/types"
"net/http" "net/http"
"strconv" "strconv"
"strings" "strings"
@ -26,7 +26,7 @@ func (api *Api) GetBlockData(resp http.ResponseWriter, req *http.Request) {
y, _ := strconv.Atoi(parts[1]) y, _ := strconv.Atoi(parts[1])
z, _ := strconv.Atoi(parts[2]) z, _ := strconv.Atoi(parts[2])
c := coords.NewMapBlockCoords(x, y, z) c := types.NewMapBlockCoords(x, y, z)
mb, err := api.Context.MapBlockAccessor.GetMapBlock(c) mb, err := api.Context.MapBlockAccessor.GetMapBlock(c)
if err != nil { if err != nil {