Update README.md

Assorted gameplay improvements from play testing

.github/workflows/docker-image.yml

@@ -1,43 +0,0 @@
-name: Build and Test
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-
-  build:
-    name: Build and Test
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Set up Go 1.x
-      uses: actions/setup-go@v2
-      with:
-        go-version: ^1.13
-      id: go
-
-    - name: Install dict
-      run: sudo apt-get update && sudo apt-get install wamerican
-
-    - name: Check out repo
-      uses: actions/checkout@v2
-
-    - name: Get go dependencies
-      run: |
-        go get -v -t -d ./...
-        if [ -f Gopkg.toml ]; then
-            curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
-            dep ensure
-        fi
-
-    - name: Build and Test
-      run: make test
-
-    - name: Upload test coverage result
-      uses: actions/upload-artifact@v1
-      with:
-        name: Coverage
-        path: /tmp/coverage.html

.github/workflows/docker.yml

@@ -0,0 +1,25 @@
+name: Docker
+
+on:
+  push:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Docker Login
+      uses: azure/docker-login@v1
+      with:
+        login-server: docker.pkg.github.com
+        username: $GITHUB_ACTOR
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Build the Docker image
+      run: |
+        VERSION=$(git describe --always --long --dirty --tags)
+        docker build . --tag docker.pkg.github.com/mdiluz/rove/rove:$VERSION --tag docker.pkg.github.com/mdiluz/rove/rove:latest
+        docker push docker.pkg.github.com/mdiluz/rove/rove:$VERSION
+        docker push docker.pkg.github.com/mdiluz/rove/rove:latest

.github/workflows/tests.yml

@@ -0,0 +1,44 @@
+name: Tests
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+
+  build:
+    name: Build and Test
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Run golangci-lint
+      uses: actions-contrib/golangci-lint@v1
+
+    - name: Set up Go 1.x
+      uses: actions/setup-go@v2
+      with:
+        go-version: ^1.13
+      id: go
+
+    - name: Check generated files
+      run: |
+        PROTOC_ZIP=protoc-3.6.1-linux-x86_64.zip
+        curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v3.6.1/$PROTOC_ZIP
+        sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
+        sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
+        sudo chmod -R o+r /usr/local/include/google/
+        rm -f $PROTOC_ZIP
+        make gen
+        git update-index --refresh || (git diff; exit 1)
+
+    - name: Build and Test
+      run: make test
+
+    - name: Upload test coverage result
+      uses: actions/upload-artifact@v1
+      with:
+        name: Coverage
+        path: /tmp/coverage.html

.vscode/launch.json

@@ -1,28 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Launch Rove Server",
-            "type": "go",
-            "request": "launch",
-            "mode": "auto",
-            "program": "${workspaceFolder}/cmd/rove-server/main.go",
-            "cwd": "${workspaceFolder}",
-            "env": {},
-            "args": [],            
-        },
-        {
-            "name": "Launch Rove",
-            "type": "go",
-            "request": "launch",
-            "mode": "auto",
-            "program": "${workspaceFolder}/cmd/rove/main.go",
-            "cwd": "${workspaceFolder}",
-            "env": {},
-            "args": ["radar"],            
-        }
-    ]
-}

Dockerfile

@@ -5,9 +5,8 @@ WORKDIR /app
 COPY . .
 RUN go mod download
 
-# For /usr/share/dict/words
-RUN apt-get update && apt-get install -y wamerican
-
+# Build the executables
+RUN go build -o rove -ldflags="-X 'github.com/mdiluz/rove/pkg/version.Version=$(git describe --always --long --dirty --tags)'" cmd/rove/main.go
 RUN go build -o rove-server -ldflags="-X 'github.com/mdiluz/rove/pkg/version.Version=$(git describe --always --long --dirty --tags)'" cmd/rove-server/main.go
 
 CMD [ "./rove-server" ]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Marc Di Luzio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -1,24 +1,28 @@
 VERSION := $(shell git describe --always --long --dirty --tags)
 
 build:
+	@echo Running no-output build
 	go mod download
-	go build -ldflags="-X 'github.com/mdiluz/rove/pkg/version.Version=${VERSION}'" ./...
+	go build -ldflags="-X 'github.com/mdiluz/rove/cmd/version.Version=${VERSION}'" ./...
 
 install:
+	@echo Installing to GOPATH
 	go mod download
 	go install -ldflags="-X 'github.com/mdiluz/rove/pkg/version.Version=${VERSION}'" ./...
 
-test:
+gen:
+	@echo Installing go dependencies
+	go install github.com/golang/protobuf/protoc-gen-go
 	go mod download
-	go build ./...
+	@echo Generating rove server gRPC
+	protoc --proto_path proto --go_out=plugins=grpc,paths=source_relative:proto/ proto/roveapi/roveapi.proto
 
-	# Run the server and shut it down again to ensure our docker-compose works
-	ROVE_ARGS="--quit 1" docker-compose up --build --exit-code-from=rove-server --abort-on-container-exit
+test:
+	@echo Run unit and integration tests
+	docker-compose -f docker-compose-test.yml up --build --exit-code-from=rove-tests --abort-on-container-exit rove-tests
+	docker-compose -f docker-compose-test.yml down
+	go tool cover -html=/tmp/coverage-data/c.out -o /tmp/coverage.html
+	
+	@echo Done, coverage data can be found in /tmp/coverage.html
 
-	# Run tests with coverage
-	go test -v ./... -cover -coverprofile=/tmp/c.out -count 1
-
-	# Convert the coverage data to html
-	go tool cover -html=/tmp/c.out -o /tmp/coverage.html
-
-.PHONY: install test
+.PHONY: build install test gen

README.md

@@ -1,13 +1,8 @@
 Rove
 ====
 
+![Rove](data/icon.svg)
+
 Rove is an asynchronous nomadic game about exploring as part of a loose community.
 
-This repository is a [living document](https://github.com/mdiluz/rove/tree/master/docs) of current game design, as well as source code for the `rove-server` deployment and the `rove` command line client.
-
-See [api.go](https://github.com/mdiluz/rove/blob/master/pkg/rove/api.go) for the current server-client API.
-
-Build Status
-------------
-![Build and Test](https://github.com/mdiluz/rove/workflows/Build%20and%20Test/badge.svg)
-
+This repository contains the source code for the `rove-server` deployment and the `rove` command line client. See [mdiluz.github.io/rove](https://mdiluz.github.io/rove/) for game details, and [roveapi.proto](proto/roveapi/roveapi.proto) for the current server-client API.

cmd/rove-server/api_test.go

@@ -1,148 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"testing"
-
-	"github.com/google/uuid"
-	"github.com/mdiluz/rove/pkg/game"
-	"github.com/mdiluz/rove/pkg/rove"
-	"github.com/mdiluz/rove/pkg/server"
-	"github.com/stretchr/testify/assert"
-)
-
-// To be set by the main function
-var serv rove.Server
-
-func TestMain(m *testing.M) {
-	s := server.NewServer()
-	if err := s.Initialise(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	serv = rove.Server(s.Addr())
-
-	go s.Run()
-
-	fmt.Printf("Test server hosted on %s", serv)
-	code := m.Run()
-
-	if err := s.StopAndClose(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	os.Exit(code)
-}
-
-func TestServer_Status(t *testing.T) {
-	status, err := serv.Status()
-	assert.NoError(t, err)
-	assert.True(t, status.Ready)
-	assert.NotZero(t, len(status.Version))
-}
-
-func TestServer_Register(t *testing.T) {
-	d1 := rove.RegisterData{
-		Name: uuid.New().String(),
-	}
-	r1, err := serv.Register(d1)
-	assert.NoError(t, err)
-	assert.True(t, r1.Success)
-	assert.NotZero(t, len(r1.Id))
-
-	d2 := rove.RegisterData{
-		Name: uuid.New().String(),
-	}
-	r2, err := serv.Register(d2)
-	assert.NoError(t, err)
-	assert.True(t, r2.Success)
-	assert.NotZero(t, len(r2.Id))
-
-	r3, err := serv.Register(d1)
-	assert.NoError(t, err)
-	assert.False(t, r3.Success)
-}
-
-func TestServer_Spawn(t *testing.T) {
-	d1 := rove.RegisterData{
-		Name: uuid.New().String(),
-	}
-	r1, err := serv.Register(d1)
-	assert.NoError(t, err)
-	assert.True(t, r1.Success)
-	assert.NotZero(t, len(r1.Id))
-
-	s := rove.SpawnData{}
-	r2, err := serv.Spawn(r1.Id, s)
-	assert.NoError(t, err)
-	assert.True(t, r2.Success)
-}
-
-func TestServer_Command(t *testing.T) {
-	d1 := rove.RegisterData{
-		Name: uuid.New().String(),
-	}
-	r1, err := serv.Register(d1)
-	assert.NoError(t, err)
-	assert.True(t, r1.Success)
-	assert.NotZero(t, len(r1.Id))
-
-	s := rove.SpawnData{}
-	r2, err := serv.Spawn(r1.Id, s)
-	assert.NoError(t, err)
-	assert.True(t, r2.Success)
-
-	c := rove.CommandData{
-		Commands: []game.Command{
-			{
-				Command:  game.CommandMove,
-				Bearing:  "N",
-				Duration: 1,
-			},
-		},
-	}
-	r3, err := serv.Command(r1.Id, c)
-	assert.NoError(t, err)
-	assert.True(t, r3.Success)
-}
-
-func TestServer_Radar(t *testing.T) {
-	d1 := rove.RegisterData{
-		Name: uuid.New().String(),
-	}
-	r1, err := serv.Register(d1)
-	assert.NoError(t, err)
-	assert.True(t, r1.Success)
-	assert.NotZero(t, len(r1.Id))
-
-	s := rove.SpawnData{}
-	r2, err := serv.Spawn(r1.Id, s)
-	assert.NoError(t, err)
-	assert.True(t, r2.Success)
-
-	r3, err := serv.Radar(r1.Id)
-	assert.NoError(t, err)
-	assert.True(t, r3.Success)
-}
-
-func TestServer_Rover(t *testing.T) {
-	d1 := rove.RegisterData{
-		Name: uuid.New().String(),
-	}
-	r1, err := serv.Register(d1)
-	assert.NoError(t, err)
-	assert.True(t, r1.Success)
-	assert.NotZero(t, len(r1.Id))
-
-	s := rove.SpawnData{}
-	r2, err := serv.Spawn(r1.Id, s)
-	assert.NoError(t, err)
-	assert.True(t, r2.Success)
-
-	r3, err := serv.Rover(r1.Id)
-	assert.NoError(t, err)
-	assert.True(t, r3.Success)
-}

cmd/rove-server/internal/routes.go

@@ -0,0 +1,169 @@
+package internal
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/mdiluz/rove/pkg/version"
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+// ServerStatus returns the status of the current server to a gRPC request
+func (s *Server) ServerStatus(context.Context, *roveapi.ServerStatusRequest) (*roveapi.ServerStatusResponse, error) {
+	response := &roveapi.ServerStatusResponse{
+		Ready:       true,
+		Version:     version.Version,
+		TickRate:    int32(s.minutesPerTick),
+		CurrentTick: int32(s.world.CurrentTicks),
+	}
+
+	// If there's a schedule, respond with it
+	if len(s.schedule.Entries()) > 0 {
+		response.NextTick = s.schedule.Entries()[0].Next.Format("15:04:05")
+	}
+
+	return response, nil
+}
+
+// Register registers a new account for a gRPC request
+func (s *Server) Register(ctx context.Context, req *roveapi.RegisterRequest) (*roveapi.RegisterResponse, error) {
+	log.Printf("Handling register request: %s\n", req.Name)
+
+	if len(req.Name) == 0 {
+		return nil, fmt.Errorf("empty account name")
+	}
+
+	if acc, err := s.world.Accountant.RegisterAccount(req.Name); err != nil {
+		return nil, err
+
+	} else if _, err := s.SpawnRoverForAccount(req.Name); err != nil {
+		return nil, fmt.Errorf("failed to spawn rover for account: %s", err)
+
+	} else if err := s.SaveWorld(); err != nil {
+		return nil, fmt.Errorf("internal server error when saving world: %s", err)
+
+	} else {
+		return &roveapi.RegisterResponse{
+			Account: &roveapi.Account{
+				Name:   acc.Name,
+				Secret: acc.Data["secret"],
+			},
+		}, nil
+	}
+}
+
+// Status returns rover information for a gRPC request
+func (s *Server) Status(ctx context.Context, req *roveapi.StatusRequest) (response *roveapi.StatusResponse, err error) {
+	log.Printf("Handling status request: %s\n", req.Account.Name)
+
+	if valid, err := s.world.Accountant.VerifySecret(req.Account.Name, req.Account.Secret); err != nil {
+		return nil, err
+
+	} else if !valid {
+		return nil, fmt.Errorf("Secret incorrect for account %s", req.Account.Name)
+
+	} else if resp, err := s.world.Accountant.GetValue(req.Account.Name, "rover"); err != nil {
+		return nil, err
+
+	} else if rover, err := s.world.GetRover(resp); err != nil {
+		return nil, fmt.Errorf("error getting rover: %s", err)
+
+	} else {
+		var inv []byte
+		for _, i := range rover.Inventory {
+			inv = append(inv, byte(i.Type))
+		}
+
+		queued := s.world.RoverCommands(resp)
+		var logs []*roveapi.Log
+		for _, log := range rover.Logs {
+			logs = append(logs, &roveapi.Log{
+				Text: log.Text,
+				Time: fmt.Sprintf("%d", log.Time.Unix()), // proto uses strings under the hood for 64bit ints anyway
+			})
+		}
+
+		response = &roveapi.StatusResponse{
+			Readings: &roveapi.RoverReadings{
+				Position: &roveapi.Vector{
+					X: int32(rover.Pos.X),
+					Y: int32(rover.Pos.Y),
+				},
+				Logs: logs,
+				Wind: s.world.Wind,
+			},
+			Spec: &roveapi.RoverSpecifications{
+				Name:             rover.Name,
+				Range:            int32(rover.Range),
+				Capacity:         int32(rover.Capacity),
+				MaximumIntegrity: int32(rover.MaximumIntegrity),
+				MaximumCharge:    int32(rover.MaximumCharge),
+			},
+			Status: &roveapi.RoverStatus{
+				Bearing:        rover.Bearing,
+				Inventory:      inv,
+				Integrity:      int32(rover.Integrity),
+				Charge:         int32(rover.Charge),
+				QueuedCommands: queued,
+				SailPosition:   rover.SailPosition,
+			},
+		}
+	}
+	return response, nil
+}
+
+// Radar returns the radar information for a rover
+func (s *Server) Radar(ctx context.Context, req *roveapi.RadarRequest) (*roveapi.RadarResponse, error) {
+	log.Printf("Handling radar request: %s\n", req.Account.Name)
+
+	if valid, err := s.world.Accountant.VerifySecret(req.Account.Name, req.Account.Secret); err != nil {
+		return nil, err
+
+	} else if !valid {
+		return nil, fmt.Errorf("Secret incorrect for account %s", req.Account.Name)
+	}
+
+	response := &roveapi.RadarResponse{}
+
+	resp, err := s.world.Accountant.GetValue(req.Account.Name, "rover")
+	if err != nil {
+		return nil, err
+
+	} else if rover, err := s.world.GetRover(resp); err != nil {
+		return nil, fmt.Errorf("error getting rover attributes: %s", err)
+
+	} else if radar, objs, err := s.world.RadarFromRover(resp); err != nil {
+		return nil, fmt.Errorf("error getting radar from rover: %s", err)
+
+	} else {
+		response.Objects = objs
+		response.Tiles = radar
+		response.Range = int32(rover.Range)
+	}
+
+	return response, nil
+}
+
+// Command issues commands to the world based on a gRPC request
+func (s *Server) Command(ctx context.Context, req *roveapi.CommandRequest) (*roveapi.CommandResponse, error) {
+	log.Printf("Handling command request: %s and %+v\n", req.Account.Name, req.Commands)
+
+	if valid, err := s.world.Accountant.VerifySecret(req.Account.Name, req.Account.Secret); err != nil {
+		return nil, err
+
+	} else if !valid {
+		return nil, fmt.Errorf("Secret incorrect for account %s", req.Account.Name)
+	}
+
+	resp, err := s.world.Accountant.GetValue(req.Account.Name, "rover")
+	if err != nil {
+		return nil, err
+	}
+
+	if err := s.world.Enqueue(resp, req.Commands...); err != nil {
+		return nil, err
+	}
+
+	return &roveapi.CommandResponse{}, nil
+}

cmd/rove-server/internal/server.go

@@ -0,0 +1,234 @@
+package internal
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"path"
+	"sync"
+
+	"github.com/mdiluz/rove/pkg/persistence"
+	"github.com/mdiluz/rove/pkg/rove"
+	"github.com/mdiluz/rove/proto/roveapi"
+	"github.com/robfig/cron"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/reflection"
+)
+
+var cert = os.Getenv("CERT_NAME")
+
+const (
+	// PersistentData will allow the server to load and save it's state
+	PersistentData = iota
+
+	// EphemeralData will let the server neither load or save out any of it's data
+	EphemeralData
+)
+
+// Server contains the relevant data to run a game server
+type Server struct {
+
+	// Internal state
+	world *rove.World
+
+	// gRPC server
+	netListener net.Listener
+	grpcServ    *grpc.Server
+
+	// Config settings
+	address        string
+	persistence    int
+	minutesPerTick int
+
+	// sync point for sub-threads
+	sync sync.WaitGroup
+
+	// cron schedule for world ticks
+	schedule *cron.Cron
+}
+
+// ServerOption defines a server creation option
+type ServerOption func(s *Server)
+
+// OptionAddress sets the server address for hosting
+func OptionAddress(address string) ServerOption {
+	return func(s *Server) {
+		s.address = address
+	}
+}
+
+// OptionPersistentData sets the server data to be persistent
+func OptionPersistentData() ServerOption {
+	return func(s *Server) {
+		s.persistence = PersistentData
+	}
+}
+
+// OptionTick defines the number of minutes per tick
+// 0 means no automatic server tick
+func OptionTick(minutes int) ServerOption {
+	return func(s *Server) {
+		s.minutesPerTick = minutes
+	}
+}
+
+// NewServer sets up a new server
+func NewServer(opts ...ServerOption) *Server {
+
+	// Set up the default server
+	s := &Server{
+		address:     "",
+		persistence: EphemeralData,
+		schedule:    cron.New(),
+		world:       rove.NewWorld(32),
+	}
+
+	// Apply all options
+	for _, o := range opts {
+		o(s)
+	}
+
+	return s
+}
+
+// Initialise sets up internal state ready to serve
+func (s *Server) Initialise(fillWorld bool) (err error) {
+
+	// Add to our sync
+	s.sync.Add(1)
+
+	// Load the world file
+	if err := s.LoadWorld(); err != nil {
+		return err
+	}
+
+	// Set up the RPC server and register
+	s.netListener, err = net.Listen("tcp", s.address)
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+
+	// Load TLS
+	var opts []grpc.ServerOption
+	if len(os.Getenv("NO_TLS")) == 0 {
+		pem := path.Join("/etc/letsencrypt/live/", cert, "fullchain.pem")
+		key := path.Join("/etc/letsencrypt/live/", cert, "privkey.pem")
+		creds, err := credentials.NewServerTLSFromFile(pem, key)
+		if err != nil {
+			log.Fatalf("failed to setup TLS: %v", err)
+		}
+		opts = append(opts, grpc.Creds(creds))
+	}
+
+	s.grpcServ = grpc.NewServer(opts...)
+	roveapi.RegisterRoveServer(s.grpcServ, s)
+	reflection.Register(s.grpcServ)
+
+	return nil
+}
+
+// Addr will return the server address set after the listen
+func (s *Server) Addr() string {
+	return s.address
+}
+
+// Run executes the server
+func (s *Server) Run() {
+	defer s.sync.Done()
+
+	// Set up the schedule if requested
+	if s.minutesPerTick != 0 {
+		if err := s.schedule.AddFunc(fmt.Sprintf("0 */%d * * *", s.minutesPerTick), func() {
+			// Ensure we don't quit during this function
+			s.sync.Add(1)
+			defer s.sync.Done()
+
+			log.Println("Executing server tick")
+
+			// Tick the world
+			s.world.Tick()
+
+			// Save out the new world state
+			if err := s.SaveWorld(); err != nil {
+				log.Fatalf("Failed to save the world: %s", err)
+			}
+		}); err != nil {
+			log.Fatal(err)
+		}
+		s.schedule.Start()
+		log.Printf("First server tick scheduled for %s\n", s.schedule.Entries()[0].Next.Format("15:04:05"))
+	}
+
+	// Serve the RPC server
+	log.Printf("Serving gRPC on %s\n", s.address)
+	if err := s.grpcServ.Serve(s.netListener); err != nil && err != grpc.ErrServerStopped {
+		log.Fatalf("failed to serve gRPC: %s", err)
+	}
+}
+
+// Stop will stop the current server
+func (s *Server) Stop() error {
+	// Stop the cron
+	s.schedule.Stop()
+
+	// Stop the gRPC
+	s.grpcServ.Stop()
+
+	return nil
+}
+
+// Close waits until the server is finished and closes up shop
+func (s *Server) Close() error {
+	// Wait until the world has shut down
+	s.sync.Wait()
+
+	// Save and return
+	return s.SaveWorld()
+}
+
+// StopAndClose waits until the server is finished and closes up shop
+func (s *Server) StopAndClose() error {
+	// Stop the server
+	if err := s.Stop(); err != nil {
+		return err
+	}
+
+	// Close and return
+	return s.Close()
+}
+
+// SaveWorld will save out the world file
+func (s *Server) SaveWorld() error {
+	if s.persistence == PersistentData {
+		s.world.RLock()
+		defer s.world.RUnlock()
+		if err := persistence.SaveAll("world", s.world); err != nil {
+			return fmt.Errorf("failed to save out persistent data: %s", err)
+		}
+	}
+	return nil
+}
+
+// LoadWorld will load all persistent data
+func (s *Server) LoadWorld() error {
+	if s.persistence == PersistentData {
+		s.world.Lock()
+		defer s.world.Unlock()
+		if err := persistence.LoadAll("world", &s.world); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// SpawnRoverForAccount spawns the rover rover for an account
+func (s *Server) SpawnRoverForAccount(account string) (string, error) {
+	inst, err := s.world.SpawnRover(account)
+	if err != nil {
+		return "", err
+	}
+
+	return inst, nil
+}

cmd/rove-server/internal/server_test.go

@@ -1,6 +1,7 @@
-package server
+package internal
 
 import (
+	"os"
 	"testing"
 )
 
@@ -30,10 +31,11 @@ func TestNewServer_OptionPersistentData(t *testing.T) {
 }
 
 func TestServer_Run(t *testing.T) {
+	os.Setenv("NO_TLS", "1")
 	server := NewServer()
 	if server == nil {
 		t.Error("Failed to create server")
-	} else if err := server.Initialise(); err != nil {
+	} else if err := server.Initialise(true); err != nil {
 		t.Error(err)
 	}
 
@@ -45,10 +47,11 @@ func TestServer_Run(t *testing.T) {
 }
 
 func TestServer_RunPersistentData(t *testing.T) {
+	os.Setenv("NO_TLS", "1")
 	server := NewServer(OptionPersistentData())
 	if server == nil {
 		t.Error("Failed to create server")
-	} else if err := server.Initialise(); err != nil {
+	} else if err := server.Initialise(true); err != nil {
 		t.Error(err)
 	}
 

cmd/rove-server/main.go

@@ -3,44 +3,79 @@ package main
 import (
 	"flag"
 	"fmt"
+	"log"
+	"math/rand"
 	"os"
 	"os/signal"
+	"strconv"
 	"syscall"
 	"time"
 
+	"github.com/mdiluz/rove/cmd/rove-server/internal"
 	"github.com/mdiluz/rove/pkg/persistence"
-	"github.com/mdiluz/rove/pkg/server"
 	"github.com/mdiluz/rove/pkg/version"
 )
 
 var ver = flag.Bool("version", false, "Display version number")
-var quit = flag.Int("quit", 0, "Quit after n seconds, useful for testing")
-var address = flag.String("address", "", "The address to host on, automatically selected if empty")
-var data = flag.String("data", "", "Directory to store persistant data, no storage if empty")
-var tick = flag.Int("tick", 5, "Number of minutes per server tick (0 for no tick)")
 
+// Path for persistent storage
+var data = os.Getenv("DATA_PATH")
+
+// The tick rate of the server in seconds
+var tick = os.Getenv("TICK_RATE")
+
+// InnerMain is our main function so tests can run it
 func InnerMain() {
+	// Ensure we've seeded rand
+	rand.Seed(time.Now().UTC().UnixNano())
+
 	flag.Parse()
 
 	// Print the version if requested
 	if *ver {
-		fmt.Println(version.Version)
+		log.Println(version.Version)
 		return
 	}
 
-	fmt.Printf("Initialising version %s...\n", version.Version)
+	// Address to host the server on
+	var iport int
+	var port = os.Getenv("PORT")
+	if len(port) == 0 {
+		iport = 9090
+	} else {
+		var err error
+		iport, err = strconv.Atoi(port)
+		if err != nil {
+			log.Fatal("$PORT not valid int")
+		}
+	}
+	log.Printf("Initialising version %s...\n", version.Version)
 
 	// Set the persistence path
-	persistence.SetPath(*data)
+	if len(data) == 0 {
+		log.Fatal("DATA_PATH not set")
+	} else if err := persistence.SetPath(data); err != nil {
+		log.Fatal(err)
+	}
+
+	// Convert the tick rate
+	tickRate := 1
+	if len(tick) > 0 {
+		var err error
+		tickRate, err = strconv.Atoi(tick)
+		if err != nil {
+			log.Fatalf("TICK_RATE not set to valid int: %s", err)
+		}
+	}
 
 	// Create the server data
-	s := server.NewServer(
-		server.OptionAddress(*address),
-		server.OptionPersistentData(),
-		server.OptionTick(*tick))
+	s := internal.NewServer(
+		internal.OptionAddress(fmt.Sprintf(":%d", iport)),
+		internal.OptionPersistentData(),
+		internal.OptionTick(tickRate))
 
 	// Initialise the server
-	if err := s.Initialise(); err != nil {
+	if err := s.Initialise(true); err != nil {
 		panic(err)
 	}
 
@@ -49,22 +84,13 @@ func InnerMain() {
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 	go func() {
 		<-c
-		fmt.Println("Quit requested, exiting...")
+		log.Println("Quit requested, exiting...")
 		if err := s.Stop(); err != nil {
 			panic(err)
 		}
 	}()
 
-	// Quit after a time if requested
-	if *quit != 0 {
-		go func() {
-			time.Sleep(time.Duration(*quit) * time.Second)
-			syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
-		}()
-	}
-
 	// Run the server
-	fmt.Printf("Serving HTTP on %s\n", s.Addr())
 	s.Run()
 
 	// Close the server
@@ -74,6 +100,5 @@ func InnerMain() {
 }
 
 func main() {
-	flag.Parse()
 	InnerMain()
 }

cmd/rove-server/main_test.go

@@ -3,16 +3,12 @@ package main
 import (
 	"flag"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func Test_InnerMain_Version(t *testing.T) {
-	flag.Set("version", "1")
+	assert.NoError(t, flag.Set("version", "1"))
 	InnerMain()
-	flag.Set("version", "0")
-}
-
-func Test_InnerMain_Quit(t *testing.T) {
-	flag.Set("quit", "1")
-	InnerMain()
-	flag.Set("quit", "0")
+	assert.NoError(t, flag.Set("version", "0"))
 }

cmd/rove/internal/glyph.go

@@ -0,0 +1,70 @@
+package internal
+
+import (
+	"log"
+
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+// Glyph represents the text representation of something in the game
+type Glyph byte
+
+const (
+	// GlyphGroundRock is solid rock ground
+	GlyphGroundRock = Glyph('-')
+
+	// GlyphGroundGravel is loose rocks
+	GlyphGroundGravel = Glyph(':')
+
+	// GlyphGroundSand is sand
+	GlyphGroundSand = Glyph('~')
+
+	// GlyphRoverLive represents a live rover
+	GlyphRoverLive = Glyph('R')
+
+	// GlyphRoverDormant represents a dormant rover
+	GlyphRoverDormant = Glyph('r')
+
+	// GlyphRoverParts represents spare rover parts
+	GlyphRoverParts = Glyph('*')
+
+	// GlyphRockSmall is a small stashable rock
+	GlyphRockSmall = Glyph('o')
+
+	// GlyphRockLarge is a large blocking rock
+	GlyphRockLarge = Glyph('O')
+)
+
+// TileGlyph returns the glyph for this tile type
+func TileGlyph(t roveapi.Tile) Glyph {
+	switch t {
+	case roveapi.Tile_Rock:
+		return GlyphGroundRock
+	case roveapi.Tile_Gravel:
+		return GlyphGroundGravel
+	case roveapi.Tile_Sand:
+		return GlyphGroundSand
+	}
+
+	log.Fatalf("Unknown tile type: %c", t)
+	return 0
+}
+
+// ObjectGlyph returns the glyph for this object type
+func ObjectGlyph(o roveapi.Object) Glyph {
+	switch o {
+	case roveapi.Object_RoverLive:
+		return GlyphRoverLive
+	case roveapi.Object_RockSmall:
+		return GlyphRockSmall
+	case roveapi.Object_RoverDormant:
+		return GlyphRoverDormant
+	case roveapi.Object_RockLarge:
+		return GlyphRockLarge
+	case roveapi.Object_RoverParts:
+		return GlyphRoverParts
+	}
+
+	log.Fatalf("Unknown object type: %c", o)
+	return 0
+}

cmd/rove/main.go

@@ -1,238 +1,423 @@
 package main
 
 import (
+	"crypto/tls"
 	"encoding/json"
-	"flag"
 	"fmt"
 	"io/ioutil"
 	"math"
 	"os"
 	"path"
+	"path/filepath"
+	"strconv"
+	"time"
 
-	"github.com/mdiluz/rove/pkg/game"
-	"github.com/mdiluz/rove/pkg/rove"
+	"github.com/mdiluz/rove/cmd/rove/internal"
 	"github.com/mdiluz/rove/pkg/version"
+	"github.com/mdiluz/rove/proto/roveapi"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
 )
 
-var USAGE = ""
+var home = os.Getenv("HOME")
+var defaultDataPath = path.Join(home, ".local/share/")
 
 // Command usage
-// TODO: Allow COMMAND to be used first
-func Usage() {
-	fmt.Printf("Usage: %s [OPTIONS]... COMMAND\n", os.Args[0])
-	fmt.Println("\nCommands:")
-	fmt.Println("\tstatus  \tprints the server status")
-	fmt.Println("\tregister\tregisters an account and stores it (use with -name)")
-	fmt.Println("\tspawn   \tspawns a rover for the current account")
-	fmt.Println("\tmove    \tissues move command to rover")
-	fmt.Println("\tradar   \tgathers radar data for the current rover")
-	fmt.Println("\trover   \tgets data for current rover")
-	fmt.Println("\nOptions:")
-	flag.PrintDefaults()
+func printUsage() {
+	fmt.Fprintln(os.Stderr, "Usage: rove ARG [OPT...]")
+	fmt.Fprintf(os.Stderr, "\n")
+	fmt.Fprintln(os.Stderr, "Arguments:")
+	fmt.Fprintln(os.Stderr, "\tversion                       outputs version")
+	fmt.Fprintln(os.Stderr, "\thelp                          outputs this usage text")
+	fmt.Fprintln(os.Stderr, "\tconfig [HOST]                 outputs the local config, optionally sets host")
+	fmt.Fprintln(os.Stderr, "\tserver-status                 prints the server status")
+	fmt.Fprintln(os.Stderr, "\tregister NAME                 registers an account and spawns a rover")
+	fmt.Fprintln(os.Stderr, "\tradar                         prints radar data in ASCII form")
+	fmt.Fprintln(os.Stderr, "\tstatus                        gets rover status")
+	fmt.Fprintln(os.Stderr, "\tcommand CMD [VAL...] [REPEAT] sets the command queue, accepts multiple in sequence")
+	fmt.Fprintf(os.Stderr, "\n")
+	fmt.Fprintln(os.Stderr, "Rover commands:")
+	fmt.Fprintln(os.Stderr, "\ttoggle         toggles the current sail mode")
+	fmt.Fprintln(os.Stderr, "\tstash          stores the object at the rover location in the inventory")
+	fmt.Fprintln(os.Stderr, "\trepair         repairs the rover using inventory item")
+	fmt.Fprintln(os.Stderr, "\tbroadcast MSG  broadcast a simple ASCII triplet to nearby rovers")
+	fmt.Fprintln(os.Stderr, "\tsalvage        salvages a dormant rover for parts")
+	fmt.Fprintln(os.Stderr, "\ttransfer       transfer's control into a dormant rover")
+	fmt.Fprintln(os.Stderr, "\tupgrade SPEC   spends rover parts to upgrade one rover spec (capacity, range, integrity, charge")
+	fmt.Fprintln(os.Stderr, "\twait           waits before performing the next command")
+	fmt.Fprintf(os.Stderr, "\n")
+	fmt.Fprintln(os.Stderr, "Environment")
+	fmt.Fprintln(os.Stderr, "\tROVE_USER_DATA        path to user data, defaults to "+defaultDataPath)
 }
 
-var home = os.Getenv("HOME")
-var filepath = path.Join(home, ".local/share/rove.json")
+const gRPCport = 9090
 
-// General usage
-var ver = flag.Bool("version", false, "Display version number")
-var host = flag.String("host", "", "path to game host server")
-var data = flag.String("data", filepath, "data file for storage")
-
-// For register command
-var name = flag.String("name", "", "used with status command for the account name")
-
-// For the duration command
-var duration = flag.Int("duration", 1, "used for the move command duration")
-var bearing = flag.String("bearing", "", "used for the move command bearing (compass direction)")
+// Account stores data for an account
+type Account struct {
+	Name   string
+	Secret string
+}
 
 // Config is used to store internal data
 type Config struct {
-	Host     string            `json:"host,omitempty"`
-	Accounts map[string]string `json:"accounts,omitempty"`
+	Host    string
+	Account Account
 }
 
-// verifyId will verify an account ID
-func verifyId(id string) error {
-	if len(id) == 0 {
+// ConfigPath returns the configuration path
+func ConfigPath() string {
+	// Allow overriding the data path
+	var datapath = defaultDataPath
+	var override = os.Getenv("ROVE_USER_DATA")
+	if len(override) > 0 {
+		datapath = override
+	}
+	datapath = path.Join(datapath, "roveapi.json")
+
+	return datapath
+}
+
+// LoadConfig loads the config from a chosen path
+func LoadConfig() (config Config, err error) {
+
+	datapath := ConfigPath()
+
+	// Create the path if needed
+	path := filepath.Dir(datapath)
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		if err := os.MkdirAll(path, os.ModePerm); err != nil {
+			return Config{}, fmt.Errorf("Failed to create data path %s: %s", path, err)
+		}
+	} else {
+		// Read the file
+		_, err = os.Stat(datapath)
+		if !os.IsNotExist(err) {
+			if b, err := ioutil.ReadFile(datapath); err != nil {
+				return Config{}, fmt.Errorf("failed to read file %s error: %s", datapath, err)
+
+			} else if len(b) == 0 {
+				return Config{}, fmt.Errorf("file %s was empty, assumin fresh data", datapath)
+
+			} else if err := json.Unmarshal(b, &config); err != nil {
+				return Config{}, fmt.Errorf("failed to unmarshal file %s error: %s", datapath, err)
+
+			}
+		}
+	}
+
+	return
+}
+
+// SaveConfig saves the config out
+func SaveConfig(config Config) error {
+	// Save out the persistent file
+	datapath := ConfigPath()
+	if b, err := json.MarshalIndent(config, "", "\t"); err != nil {
+		return fmt.Errorf("failed to marshal data error: %s", err)
+	} else if err := ioutil.WriteFile(datapath, b, os.ModePerm); err != nil {
+		return fmt.Errorf("failed to save file %s error: %s", datapath, err)
+	}
+
+	return nil
+}
+
+// checkAccount will verify an account ID
+func checkAccount(a Account) error {
+	if len(a.Name) == 0 {
 		return fmt.Errorf("no account ID set, must register first")
+	} else if len(a.Secret) == 0 {
+		return fmt.Errorf("empty account secret, must register first")
 	}
 	return nil
 }
 
+// BearingFromString converts a string to a bearing
+func BearingFromString(s string) roveapi.Bearing {
+	switch s {
+	case "N":
+		return roveapi.Bearing_North
+	case "NE":
+		return roveapi.Bearing_NorthEast
+	case "E":
+		return roveapi.Bearing_East
+	case "SE":
+		return roveapi.Bearing_SouthEast
+	case "S":
+		return roveapi.Bearing_South
+	case "SW":
+		return roveapi.Bearing_SouthWest
+	case "W":
+		return roveapi.Bearing_West
+	case "NW":
+		return roveapi.Bearing_NorthWest
+	}
+	return roveapi.Bearing_BearingUnknown
+}
+
 // InnerMain wraps the main function so we can test it
-func InnerMain(command string) error {
+func InnerMain(command string, args ...string) error {
+
+	// Early simple bails
+	switch command {
+	case "help":
+		printUsage()
+		return nil
+	case "version":
+		fmt.Println(version.Version)
+		return nil
+	}
 
 	// Load in the persistent file
-	var config = Config{
-		Accounts: make(map[string]string),
+	config, err := LoadConfig()
+	if err != nil {
+		return err
 	}
-	_, err := os.Stat(*data)
-	if !os.IsNotExist(err) {
-		if b, err := ioutil.ReadFile(*data); err != nil {
-			return fmt.Errorf("failed to read file %s error: %s", *data, err)
-
-		} else if len(b) == 0 {
-			return fmt.Errorf("file %s was empty, assumin fresh data", *data)
-
-		} else if err := json.Unmarshal(b, &config); err != nil {
-			return fmt.Errorf("failed to unmarshal file %s error: %s", *data, err)
 
+	// Run config command before server needed
+	if command == "config" {
+		if len(args) > 0 {
+			config.Host = args[0]
 		}
-	}
-
-	// If there's a host set on the command line, override the one in the config
-	if len(*host) != 0 {
-		config.Host = *host
+		fmt.Printf("host: %s\taccount: %s\n", config.Host, config.Account)
+		return SaveConfig(config)
 	}
 
 	// If there's still no host, bail
 	if len(config.Host) == 0 {
-		return fmt.Errorf("no host set, please set one with -host")
+		return fmt.Errorf("no host set in %s, set one with '%s config {HOST}'", ConfigPath(), os.Args[0])
+	}
+
+	var opts []grpc.DialOption
+	if len(os.Getenv("NO_TLS")) == 0 {
+		opts = append(opts, grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
+	} else {
+		opts = append(opts, grpc.WithInsecure())
 	}
 
 	// Set up the server
-	var server = rove.Server(config.Host)
-
-	// Grab the account
-	var account = config.Accounts[config.Host]
-
-	// Print the config info
-	fmt.Printf("host: %s\taccount: %s\n", config.Host, account)
+	clientConn, err := grpc.Dial(fmt.Sprintf("%s:%d", config.Host, gRPCport), opts...)
+	if err != nil {
+		return err
+	}
+	var client = roveapi.NewRoveClient(clientConn)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
 
 	// Handle all the commands
 	switch command {
-	case "status":
-		if response, err := server.Status(); err != nil {
+	case "server-status":
+		response, err := client.ServerStatus(ctx, &roveapi.ServerStatusRequest{})
+		switch {
+		case err != nil:
 			return err
 
-		} else {
+		default:
 			fmt.Printf("Ready: %t\n", response.Ready)
 			fmt.Printf("Version: %s\n", response.Version)
-			fmt.Printf("Tick: %d\n", response.Tick)
+			fmt.Printf("Tick Rate: %d\n", response.TickRate)
+			fmt.Printf("Current Tick: %d\n", response.CurrentTick)
 			fmt.Printf("Next Tick: %s\n", response.NextTick)
 		}
 
 	case "register":
-		d := rove.RegisterData{
-			Name: *name,
-		}
-		if response, err := server.Register(d); err != nil {
-			return err
-
-		} else if !response.Success {
-			return fmt.Errorf("Server returned failure: %s", response.Error)
-
-		} else {
-			fmt.Printf("Registered account with id: %s\n", response.Id)
-			config.Accounts[config.Host] = response.Id
-		}
-	case "spawn":
-		d := rove.SpawnData{}
-		if err := verifyId(account); err != nil {
-			return err
-		} else if response, err := server.Spawn(account, d); err != nil {
-			return err
-
-		} else if !response.Success {
-			return fmt.Errorf("Server returned failure: %s", response.Error)
-
-		} else {
-			fmt.Printf("Spawned rover with attributes %+v\n", response.Attributes)
+		if len(args) == 0 || len(args[0]) == 0 {
+			return fmt.Errorf("must pass name to 'register'")
 		}
 
-	case "move":
-		d := rove.CommandData{
-			Commands: []game.Command{
-				{
-					Command:  game.CommandMove,
-					Duration: *duration,
-					Bearing:  *bearing,
-				},
+		resp, err := client.Register(ctx, &roveapi.RegisterRequest{
+			Name: args[0],
+		})
+		switch {
+		case err != nil:
+			return err
+
+		default:
+			fmt.Printf("Registered account with id: %s\n", resp.Account.Name)
+			config.Account.Name = resp.Account.Name
+			config.Account.Secret = resp.Account.Secret
+		}
+
+	case "command":
+		if err := checkAccount(config.Account); err != nil {
+			return err
+		} else if len(args) == 0 {
+			return fmt.Errorf("must pass commands to 'commands'")
+		}
+
+		// Iterate through each command
+		var commands []*roveapi.Command
+		for i := 0; i < len(args); i++ {
+
+			var cmd *roveapi.Command
+			switch args[i] {
+			case "turn":
+				i++
+				if len(args) == i {
+					return fmt.Errorf("turn command must be passed a compass bearing")
+				}
+				b := BearingFromString(args[i])
+				if b == roveapi.Bearing_BearingUnknown {
+					return fmt.Errorf("turn command must be given a valid bearing %s", args[i])
+				}
+				cmd = &roveapi.Command{
+					Command: roveapi.CommandType_turn,
+					Bearing: b,
+				}
+			case "broadcast":
+				i++
+				if len(args) == i {
+					return fmt.Errorf("broadcast command must be passed an ASCII triplet")
+				} else if len(args[i]) > 3 {
+					return fmt.Errorf("broadcast command must be given ASCII triplet of 3 or less: %s", args[i])
+				}
+				cmd = &roveapi.Command{
+					Command: roveapi.CommandType_broadcast,
+					Data:    []byte(args[i]),
+				}
+			case "upgrade":
+				i++
+				if len(args) == i {
+					return fmt.Errorf("upgrade command must be passed a spec to upgrade")
+				}
+				var u roveapi.RoverUpgrade
+				switch args[i] {
+				case "capacity":
+					u = roveapi.RoverUpgrade_Capacity
+				case "range":
+					u = roveapi.RoverUpgrade_Range
+				case "integrity":
+					u = roveapi.RoverUpgrade_MaximumIntegrity
+				case "charge":
+					u = roveapi.RoverUpgrade_MaximumCharge
+				default:
+					return fmt.Errorf("upgrade command must be passed a known upgrade spec")
+				}
+				cmd = &roveapi.Command{
+					Command: roveapi.CommandType_upgrade,
+					Upgrade: u,
+				}
+			default:
+				// By default just use the command literally
+				cmd = &roveapi.Command{
+					Command: roveapi.CommandType(roveapi.CommandType_value[args[i]]),
+				}
+			}
+
+			// Try and convert the next command to a number
+			number := 0
+			if len(args) > i+1 {
+				num, err := strconv.Atoi(args[i+1])
+				if err == nil {
+					number = num
+					i++
+				}
+			}
+			cmd.Repeat = int32(number)
+
+			commands = append(commands, cmd)
+		}
+
+		_, err := client.Command(ctx, &roveapi.CommandRequest{
+			Account: &roveapi.Account{
+				Name:   config.Account.Name,
+				Secret: config.Account.Secret,
 			},
-		}
+			Commands: commands,
+		})
 
-		if err := verifyId(account); err != nil {
-			return err
-		} else if response, err := server.Command(account, d); err != nil {
+		switch {
+		case err != nil:
 			return err
 
-		} else if !response.Success {
-			return fmt.Errorf("Server returned failure: %s", response.Error)
-
-		} else {
+		default:
 			fmt.Printf("Request succeeded\n")
 		}
 
 	case "radar":
-		if err := verifyId(account); err != nil {
+		if err := checkAccount(config.Account); err != nil {
 			return err
-		} else if response, err := server.Radar(account); err != nil {
+		}
+
+		response, err := client.Radar(ctx, &roveapi.RadarRequest{
+			Account: &roveapi.Account{
+				Name:   config.Account.Name,
+				Secret: config.Account.Secret,
+			},
+		})
+
+		switch {
+		case err != nil:
 			return err
 
-		} else if !response.Success {
-			return fmt.Errorf("Server returned failure: %s", response.Error)
+		default:
 
-		} else {
-			// Print the radar
+			// Print out the radar
 			num := int(math.Sqrt(float64(len(response.Tiles))))
-			for i := 0; i < num; i++ {
-				for j := num - 1; j >= 0; j-- {
-					fmt.Printf("%d", response.Tiles[i+num*j])
+			for j := num - 1; j >= 0; j-- {
+				for i := 0; i < num; i++ {
+					t := response.Tiles[i+num*j]
+					o := response.Objects[i+num*j]
+					if o != roveapi.Object_ObjectUnknown {
+						fmt.Printf("%c", internal.ObjectGlyph(o))
+					} else {
+						fmt.Printf("%c", internal.TileGlyph(t))
+					}
+
 				}
 				fmt.Print("\n")
 			}
 		}
 
-	case "rover":
-		if err := verifyId(account); err != nil {
+	case "status":
+		if err := checkAccount(config.Account); err != nil {
 			return err
-		} else if response, err := server.Rover(account); err != nil {
+		}
+
+		response, err := client.Status(ctx, &roveapi.StatusRequest{
+			Account: &roveapi.Account{
+				Name:   config.Account.Name,
+				Secret: config.Account.Secret,
+			},
+		})
+
+		switch {
+		case err != nil:
 			return err
 
-		} else if !response.Success {
-			return fmt.Errorf("Server returned failure: %s", response.Error)
-
-		} else {
-			fmt.Printf("attributes: %+v\n", response.Attributes)
+		default:
+			fmt.Printf("rover info: %+v\n", response)
 		}
 
 	default:
-		return fmt.Errorf("Unknown command: %s", command)
+		// Print the usage
+		fmt.Fprintf(os.Stderr, "Error: unknown command %s\n", command)
+		printUsage()
+		os.Exit(1)
 	}
 
-	// Save out the persistent file
-	if b, err := json.MarshalIndent(config, "", "\t"); err != nil {
-		return fmt.Errorf("failed to marshal data error: %s", err)
-	} else {
-		if err := ioutil.WriteFile(*data, b, os.ModePerm); err != nil {
-			return fmt.Errorf("failed to save file %s error: %s", *data, err)
-		}
-	}
-
-	return nil
+	return SaveConfig(config)
 }
 
 // Simple main
 func main() {
-	flag.Usage = Usage
-	flag.Parse()
-
-	// Print the version if requested
-	if *ver {
-		fmt.Println(version.Version)
-		return
-	}
-
-	// Verify we have a single command line arg
-	args := flag.Args()
-	if len(args) != 1 {
-		Usage()
+	// Bail without any args
+	if len(os.Args) == 1 {
+		fmt.Fprintf(os.Stderr, "\n")
+		fmt.Fprintln(os.Stderr, "m mm   mmm   m   m   mmm")
+		fmt.Fprintln(os.Stderr, "#\"  \" #\" \"#  \"m m\"  #\"  #")
+		fmt.Fprintln(os.Stderr, "#     #   #   #m#   #\"\"\"\"")
+		fmt.Fprintln(os.Stderr, "#     \"#m#\"    #    \"#mm\"")
+		fmt.Fprintf(os.Stderr, "\n")
+		fmt.Fprintln(os.Stderr, "Rove is an asychronous nomadic game about exploring a planet as part of a loose community.")
+		fmt.Fprintln(os.Stderr, "Visit https://mdiluz.github.io/rove/ for more information.")
+		fmt.Fprintf(os.Stderr, "\n")
+		printUsage()
 		os.Exit(1)
 	}
 
 	// Run the inner main
-	if err := InnerMain(args[0]); err != nil {
+	if err := InnerMain(os.Args[1], os.Args[2:]...); err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %s\n", err)
 		os.Exit(1)
 	}

cmd/rove/main_test.go

@@ -1,83 +1,67 @@
+// +build integration
+
 package main
 
 import (
-	"flag"
-	"fmt"
+	"io/ioutil"
+	"log"
 	"os"
-	"path"
 	"testing"
 
 	"github.com/google/uuid"
-	"github.com/mdiluz/rove/pkg/server"
 	"github.com/stretchr/testify/assert"
 )
 
-var address string
-
-func TestMain(m *testing.M) {
-	s := server.NewServer()
-	if err := s.Initialise(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	address = s.Addr()
-
-	go s.Run()
-
-	fmt.Printf("Test server hosted on %s", address)
-	code := m.Run()
-
-	if err := s.StopAndClose(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	os.Exit(code)
-}
-
 func Test_InnerMain(t *testing.T) {
-	// Set up the flags to act locally and use a temporary file
-	flag.Set("data", path.Join(os.TempDir(), uuid.New().String()))
+	os.Setenv("NO_TLS", "1")
 
-	// First attempt should error
-	assert.Error(t, InnerMain("status"))
+	// Use temporary local user data
+	tmp, err := ioutil.TempDir(os.TempDir(), "rove-")
+	assert.NoError(t, err)
+	os.Setenv("ROVE_USER_DATA", tmp)
 
-	// Now set the host
-	flag.Set("host", address)
+	// Used for configuring this test
+	var address = os.Getenv("ROVE_GRPC")
+	if len(address) == 0 {
+		log.Fatal("Must set $ROVE_GRPC")
+	}
 
-	// No error now as we have a host
-	assert.NoError(t, InnerMain("status"))
+	// First attempt should error without a host
+	assert.Error(t, InnerMain("server-status"))
+
+	// Set the host in the config
+	assert.NoError(t, InnerMain("config", address))
+	assert.NoError(t, InnerMain("server-status"))
 
 	// Register should fail without a name
 	assert.Error(t, InnerMain("register"))
 
 	// These methods should fail without an account
-	assert.Error(t, InnerMain("spawn"))
-	assert.Error(t, InnerMain("move"))
 	assert.Error(t, InnerMain("radar"))
-	assert.Error(t, InnerMain("rover"))
+	assert.Error(t, InnerMain("status"))
 
 	// Now set the name
-	flag.Set("name", uuid.New().String())
-
-	// Perform the register
-	assert.NoError(t, InnerMain("register"))
-
-	// We've not spawned a rover yet so these should fail
-	assert.Error(t, InnerMain("command"))
-	assert.Error(t, InnerMain("radar"))
-	assert.Error(t, InnerMain("rover"))
-
-	// Spawn a rover
-	assert.NoError(t, InnerMain("spawn"))
+	assert.NoError(t, InnerMain("register", uuid.New().String()))
 
 	// These should now work
 	assert.NoError(t, InnerMain("radar"))
-	assert.NoError(t, InnerMain("rover"))
+	assert.NoError(t, InnerMain("status"))
 
-	// Move should work with arguments
-	flag.Set("bearing", "N")
-	flag.Set("duration", "1")
-	assert.NoError(t, InnerMain("move"))
+	// Commands should fail with no commands
+	assert.Error(t, InnerMain("command"))
+
+	// Give it commands
+	assert.NoError(t, InnerMain("command", "toggle"))
+	assert.NoError(t, InnerMain("command", "stash"))
+	assert.NoError(t, InnerMain("command", "repair"))
+	assert.NoError(t, InnerMain("command", "upgrade", "capacity"))
+	assert.NoError(t, InnerMain("command", "broadcast", "abc"))
+	assert.NoError(t, InnerMain("command", "wait", "10"))
+	assert.NoError(t, InnerMain("command", "wait", "1", "turn", "NW", "toggle", "broadcast", "zyx"))
+
+	// Give it malformed commands
+	assert.Error(t, InnerMain("command", "unknown"))
+	assert.Error(t, InnerMain("command", "broadcast"))
+	assert.Error(t, InnerMain("command", "upgrade"))
+	assert.Error(t, InnerMain("command", "1"))
 }

data/io.github.mdiluz.Rove.json

@@ -0,0 +1,36 @@
+{
+    "app-id": "io.github.mdiluz.Rove",
+    "runtime": "org.freedesktop.Platform",
+    "runtime-version": "19.08",
+    "sdk": "org.freedesktop.Sdk",
+    "sdk-extensions" : [
+        "org.freedesktop.Sdk.Extension.golang"  
+    ],
+    "finish-args" : [
+        "--share=network"
+    ],
+    "command": "rove",
+    "modules": [
+        {
+            "name": "rove",
+            "buildsystem": "simple",
+            "build-options": {
+                "env": {
+                    "GOBIN": "/app/bin/"
+                },
+                "build-args": [
+                    "--share=network"
+                ]
+            },
+            "build-commands" : [
+                ". /usr/lib/sdk/golang/enable.sh; make install"
+            ],
+            "sources": [
+                {
+                    "type": "dir",
+                    "path": ".."
+                }
+            ]
+        }
+    ]
+}

docker-compose-test.yml

@@ -0,0 +1,32 @@
+version: '3'
+
+services:
+  rove-test-server:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: rove:latest
+    ports:
+      - "9090:9090"
+    environment:
+      - PORT=9090
+      - DATA_PATH=/tmp/
+      - WORDS_FILE=data/words_alpha.txt
+      - TICK_RATE=10
+      - NO_TLS=1
+    command: [ "./rove-server"]
+
+  rove-tests:
+    depends_on: [ rove-test-server ]
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: rove:latest
+    environment:
+      - ROVE_GRPC=rove-test-server
+    command: [ "./script/wait-for-it.sh", "rove-test-server:9090", "--", "go", "test", "-v", "./...", "--tags=integration", "-cover", "-coverprofile=/mnt/coverage-data/c.out", "-count", "1" ]
+    volumes:
+      - /tmp/coverage-data:/mnt/coverage-data:rw
+
+
+  

docker-compose.yml

@@ -7,10 +7,19 @@ services:
   rove-server:
     build:
       context: .
-      dockerfile: cmd/rove-server/Dockerfile
-    image: rove-server:latest
+      dockerfile: Dockerfile
+    image: rove:latest
     ports:
-      - "80:80"
-    command: ./rove-server --address ":80" --data=/mnt/rove-server ${ROVE_ARGS}
+      - "9090:9090"
+    environment:
+      - PORT=9090
+      - DATA_PATH=/mnt/rove-server
+      - WORDS_FILE=data/words_alpha.txt
+      - TICK_RATE=3
+      - CERT_NAME=${CERT_NAME}
     volumes:
       - persistent-data:/mnt/rove-server:rw
+      - /etc/letsencrypt/:/etc/letsencrypt/
+    command: [ "./rove-server"]
+
+  

docs/README.md

@@ -0,0 +1,61 @@
+Rove
+=====
+
+Rove is an asynchronous nomadic game about exploring a planet as part of a loose community.
+
+-------------------------------------------
+
+## Core gameplay
+
+Remotely explore the surface of a planet with an upgradable and customisable rover. Send commands to be executed asynchronously, view the rover's radar, and communicate and coordinate with other nearby rovers.
+
+### Key Components
+
+* Navigate an expansive world
+* Collect resources to repair and upgrade
+* Keep the rover batteries charged as you explore
+* Help other players on their journey
+* Explore north to discover more
+
+-------------------------------------------
+
+## Installing
+
+On Ubuntu:
+```
+$ snap install rove
+```
+
+Elsewhere (with [go](https://golang.org/doc/install) installed)
+```
+go get github.com/mdiluz/rove
+cd $GOPATH/src/github.com/mdiluz/rove/
+make install
+```
+
+-------------------------------------------
+
+### Implementation Details
+
+`rove-server` hosts the game world and a gRPC server to allow users to interact from any client.
+
+`rove` is a basic example command-line client that allows for simple play, to explore it's usage, see the output of `rove help`
+
+-------------------------------------------
+
+### "Find the fun" issues to solve
+
+* What kinds of progression/upgrades exist?
+* How does the game encourage cooperation?
+* How would the gameplay prevent griefing?
+* What drives the exploration?
+
+-------------------------------------------
+
+### Key ideas left to integrate
+
+* Feeling “known for” something -  the person who did X thing. Limit number of  X things that can be done, possibly over time.
+* A significant aspect of failure - failing must be a focus of the game. Winning the game might actually be failing in some specific way.
+* A clear and well  defined investment vs. payoff curve.
+* Not an infinite game, let the game have a point where you’re done and can move on.
+

docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-merlot

docs/design.md

@@ -1,86 +0,0 @@
-Rove
-=====
-
-An asynchronous nomadic game about exploring a planet as part of a loose 
-community.
-
--------------------------------------------
-
-## The Basics
-
-### Core
-
-Control a rover on the surface of the planet using a remote control interface.
-
-Commands are sent and happen asynchronously, and the rover feeds back information about position and surroundings, as well as photos.
-
-### Goal
-
-To reach the pole.
-
-### General
-
-Movement is slow and sometimes dangerous. Hazards damage the rover.
-
-Resources can be collected to fix and upgrade the rover.
-
-Rovers recharge power during the day.
-
-Enough collected resources allow you to create and fire a new rover a significant distance in any direction, losing control of the current one and leaving it dormant.
-
-Finding a dormant rover gives you a choice - scrap it to gain minor resources, or fire it a distance just like a new rover, taking control of it.
-
-“Dying” triggers a self destruct and fires a new basic rover in a random direction towards the equator
-
-## Multiplayer
-
-The planet itself and things that happen on it are persistent. Players can view each other, and use very rudimentary signals.
-
-Dormant rovers store full history of travel, owners, and keep damage, improvements and resources.
-
-Players have no other forms of direct communication.
-
-Players can view progress of all rovers attached to their name.
-
-Limit too many players in one location with a simple interference mechanic - only a certain density can exist at once to operate properly, additional players can’t move within range.
-
--------------------------------------------
-
-### Implementation
-
-Two functional parts
-
-A server that receives the commands, sends out data, and handles interactions between players.
-
-An app, or apps, that interface with the server to let you control and view rover information
-
--------------------------------------------
-
-### To Solve
-
-#### What kinds of progression/upgrades exist?
-Needs a very simple set of rover internals defined, each of which can be upgraded.
-
-#### How does the game encourage lateral movement?
-Could simply be the terrain is constructed in very lateral ways, blocking progress frequently
-
-#### How does the game encourage cooperation?
-How exactly would a time delay mechanic enhance the experience?
-Currently it’s just to make the multiplayer easier to use, and to make interactions a little more complicated. The game could limit the number of bytes (commands) you can send over time. 
-
-#### How would the gameplay prevent griefing?
-
--------------------------------------------
-
-### Key ideas left to integrate
-
-Feeling “known for” something -  the person who did X thing. Limit number of  X things that can be done, possibly over time.
-
-Build up a certain level of knowledge and ownership of a place, but then destroy it or give it up. Or build up a character and then leave it behind.
-
-A significant aspect of failure - failing must be a focus of the game. Winning the game might actually be failing in some specific way.
-
-A clear and well  defined investment vs. payoff curve.
-
-Not an infinite game, let the game have a point where you’re done and can move on.
-

docs/poc.md

@@ -1,30 +0,0 @@
-Proof Of Concept
-================
-
-For a proof of concept we'll implement a very small subset of the final features
-
-### Core Features (done)
-
-* Create an account
-* Control an rover in a 2D map
-* Query for what the rover can see
-* Persistent accounts and world
-* Multiple users
-* Populate map with locations/objects
-* Commands happen in "real time"
-
-### Stretch goals
-
-* Rover inventory
-* Rover internals
-* Basic time mechanics
-* Basic survival mechanics
-
-### Key missing features
-
-* No token security (very hackable)
-* No time dilation effects
-* No global coordinates
-* No render of rover camera view
-* No rover replacement mechanic
-* No advanced app/interface

go.mod

@@ -3,9 +3,19 @@ module github.com/mdiluz/rove
 go 1.14
 
 require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/golang/protobuf v1.4.2
 	github.com/google/uuid v1.1.1
-	github.com/gorilla/mux v1.7.4
+	github.com/grpc-ecosystem/grpc-gateway v1.14.6
+	github.com/kr/pretty v0.1.0 // indirect
+	github.com/ojrac/opensimplex-go v1.0.1
 	github.com/robfig/cron v1.2.0
 	github.com/stretchr/testify v1.6.0
-	github.com/tjarratt/babble v0.0.0-20191209142150-eecdf8c2339d
+	golang.org/x/net v0.0.0-20200602114024-627f9648deb9
+	golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980 // indirect
+	golang.org/x/text v0.3.3 // indirect
+	google.golang.org/grpc v1.30.0
+	google.golang.org/protobuf v1.25.0
+	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
+	gopkg.in/yaml.v2 v2.3.0 // indirect
 )

go.sum

@@ -1,18 +1,143 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0 h1:eOI3/cP2VTU6uZLDYAoic+eyzzB9YyGmJ7eIjl8rOPg=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f h1:WBZRG4aNOuI15bLRrCgN8fCq8E5Xuty6jGbmSNEvSsU=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4 h1:rEvIZUSZ3fx39WIi3JkQqQBitGwpELBIYWeBVh6wn+E=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/mux v1.7.4 h1:VuZ8uybHlWmqV03+zRzdwKL4tUnIp1MAQtp1mIFE1bc=
-github.com/gorilla/mux v1.7.4/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/grpc-ecosystem/grpc-gateway v1.14.6 h1:8ERzHx8aj1Sc47mu9n/AksaKCSWrMchFtkdrS4BIj5o=
+github.com/grpc-ecosystem/grpc-gateway v1.14.6/go.mod h1:zdiPV4Yse/1gnckTHtghG4GkDEdKCRJduHpTxT3/jcw=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/ojrac/opensimplex-go v1.0.1 h1:XslvpLP6XqQSATUtsOnGBYtFPw7FQ6h6y0ihjVeOLHo=
+github.com/ojrac/opensimplex-go v1.0.1/go.mod h1:MoSgj04tZpH8U0RefZabnHV2AbLgv/2mo3hLJtWqSEs=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/robfig/cron v1.2.0 h1:ZjScXvvxeQ63Dbyxy76Fj3AT3Ut0aKsyd2/tl3DTMuQ=
 github.com/robfig/cron v1.2.0/go.mod h1:JGuDeoQd7Z6yL4zQhZ3OPEVHB7fL6Ka6skscFHfmt2k=
+github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.6.0 h1:jlIyCplCJFULU/01vCkhKuTyc3OorI3bJFuw6obfgho=
 github.com/stretchr/testify v1.6.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/tjarratt/babble v0.0.0-20191209142150-eecdf8c2339d h1:b7oHBI6TgTdCDuqTijsVldzlh+6cfQpdYLz1EKtCAoY=
-github.com/tjarratt/babble v0.0.0-20191209142150-eecdf8c2339d/go.mod h1:O5hBrCGqzfb+8WyY8ico2AyQau7XQwAfEQeEQ5/5V9E=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9 h1:pNX+40auqi2JqRfOP1akLGtYcn15TUbkhwuCO3foqqM=
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980 h1:OjiUf46hAmXblsZdnoSXsEUSKU8r1UEzcL5RVZ4gO9Y=
+golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135 h1:5Beo0mZN8dRzgrMMkDp0jc8YXQKx9DiJ2k1dkvGsn5A=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 h1:gSJIx1SDwno+2ElGhA4+qG2zF97qiUzTM+rQ0klBOcE=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884 h1:fiNLklpBwWK1mth30Hlwk+fcdBmIALlgF5iy77O37Ig=
+google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 h1:+kGHl1aib/qcwaRi1CbqBZ1rk19r85MNUf8HaBghugY=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.29.1 h1:EC2SB8S04d2r73uptxphDSUG+kTKVgjRPF+N3xpxRB4=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0 h1:M5a8xTlYTxwMn5ZFkwhRabsygDY5G8TYLyQDBxJNAxE=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc h1:/hemPrYIhOhy8zYrNj+069zDB68us2sMGsfkFJO0iZs=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

pkg/accounts/accounts.go

@@ -1,85 +1,28 @@
 package accounts
 
-import (
-	"fmt"
+// Accountant decribes something that stores accounts and account values
+type Accountant interface {
+	// RegisterAccount will register a new account and return it's info
+	RegisterAccount(name string) (acc Account, err error)
 
-	"github.com/google/uuid"
-)
+	// AssignData stores a custom account key value pair
+	AssignData(account string, key string, value string) error
 
-const kAccountsFileName = "rove-accounts.json"
+	// GetValue returns custom account data for a specific key
+	GetValue(account string, key string) (string, error)
+
+	// VerifySecret will verify whether the account secret matches with the
+	VerifySecret(account string, secret string) (bool, error)
+
+	// GetSecret gets the secret associated with an account
+	GetSecret(account string) (string, error)
+}
 
 // Account represents a registered user
 type Account struct {
 	// Name simply describes the account and must be unique
-	Name string `json:"name"`
+	Name string
 
-	// Id represents a unique ID per account and is set one registered
-	Id uuid.UUID `json:"id"`
-
-	// Rover represents the rover that this account owns
-	Rover uuid.UUID `json:"rover"`
-}
-
-// Represents the accountant data to store
-type accountantData struct {
-}
-
-// Accountant manages a set of accounts
-type Accountant struct {
-	Accounts map[uuid.UUID]Account `json:"accounts"`
-}
-
-// NewAccountant creates a new accountant
-func NewAccountant() *Accountant {
-	return &Accountant{
-		Accounts: make(map[uuid.UUID]Account),
-	}
-}
-
-// RegisterAccount adds an account to the set of internal accounts
-func (a *Accountant) RegisterAccount(name string) (acc Account, err error) {
-
-	// Set the account ID to a new UUID
-	acc.Id = uuid.New()
-	acc.Name = name
-
-	// Verify this acount isn't already registered
-	for _, a := range a.Accounts {
-		if a.Name == acc.Name {
-			return Account{}, fmt.Errorf("Account name already registered")
-		} else if a.Id == acc.Id {
-			return Account{}, fmt.Errorf("Account ID already registered")
-		}
-	}
-
-	// Simply add the account to the map
-	a.Accounts[acc.Id] = acc
-
-	return
-}
-
-// AssignRover assigns rover ownership of an rover to an account
-func (a *Accountant) AssignRover(account uuid.UUID, rover uuid.UUID) error {
-
-	// Find the account matching the ID
-	if this, ok := a.Accounts[account]; ok {
-		this.Rover = rover
-		a.Accounts[account] = this
-	} else {
-		return fmt.Errorf("no account found for id: %s", account)
-	}
-
-	return nil
-}
-
-// GetRover gets the rover rover for the account
-func (a *Accountant) GetRover(account uuid.UUID) (uuid.UUID, error) {
-	// Find the account matching the ID
-	if this, ok := a.Accounts[account]; !ok {
-		return uuid.UUID{}, fmt.Errorf("no account found for id: %s", account)
-	} else if this.Rover == uuid.Nil {
-		return uuid.UUID{}, fmt.Errorf("no rover spawned for account %s", account)
-	} else {
-		return this.Rover, nil
-	}
+	// Data represents internal account data
+	Data map[string]string
 }

pkg/accounts/accounts_test.go

@@ -8,7 +8,7 @@ import (
 
 func TestNewAccountant(t *testing.T) {
 	// Very basic verify here for now
-	accountant := NewAccountant()
+	accountant := NewSimpleAccountant()
 	if accountant == nil {
 		t.Error("Failed to create accountant")
 	}
@@ -16,7 +16,7 @@ func TestNewAccountant(t *testing.T) {
 
 func TestAccountant_RegisterAccount(t *testing.T) {
 
-	accountant := NewAccountant()
+	accountant := NewSimpleAccountant()
 
 	// Start by making two accounts
 
@@ -36,11 +36,6 @@ func TestAccountant_RegisterAccount(t *testing.T) {
 		t.Errorf("Missmatched account name after register, expected: %s, actual: %s", nameb, acca.Name)
 	}
 
-	// Verify our accounts have differing IDs
-	if acca.Id == accb.Id {
-		t.Error("Duplicate account IDs fo separate accounts")
-	}
-
 	// Verify another request gets rejected
 	_, err = accountant.RegisterAccount(namea)
 	if err == nil {
@@ -48,11 +43,8 @@ func TestAccountant_RegisterAccount(t *testing.T) {
 	}
 }
 
-func TestAccountant_AssignGetRover(t *testing.T) {
-	accountant := NewAccountant()
-	if len(accountant.Accounts) != 0 {
-		t.Error("New accountant created with non-zero account number")
-	}
+func TestAccountant_AssignGetData(t *testing.T) {
+	accountant := NewSimpleAccountant()
 
 	name := uuid.New().String()
 	a, err := accountant.RegisterAccount(name)
@@ -60,16 +52,12 @@ func TestAccountant_AssignGetRover(t *testing.T) {
 		t.Error(err)
 	}
 
-	inst := uuid.New()
-
-	err = accountant.AssignRover(a.Id, inst)
+	err = accountant.AssignData(a.Name, "key", "value")
 	if err != nil {
-		t.Error("Failed to set rover for created account")
-	} else if accountant.Accounts[a.Id].Rover != inst {
-		t.Error("Rover for assigned account is incorrect")
-	} else if id, err := accountant.GetRover(a.Id); err != nil {
-		t.Error("Failed to get rover for account")
-	} else if id != inst {
-		t.Error("Fetched rover is incorrect for account")
+		t.Error("Failed to set data for created account")
+	} else if id, err := accountant.GetValue(a.Name, "key"); err != nil {
+		t.Error("Failed to get data for account")
+	} else if id != "value" {
+		t.Error("Fetched data is incorrect for account")
 	}
 }

pkg/accounts/simpleAccountant.go

@@ -0,0 +1,90 @@
+package accounts
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// SimpleAccountant manages a set of accounts
+type SimpleAccountant struct {
+	Accounts map[string]Account
+}
+
+// NewSimpleAccountant creates a new accountant
+func NewSimpleAccountant() Accountant {
+	return &SimpleAccountant{
+		Accounts: make(map[string]Account),
+	}
+}
+
+// RegisterAccount adds an account to the set of internal accounts
+func (a *SimpleAccountant) RegisterAccount(name string) (acc Account, err error) {
+
+	// Set up the account info
+	acc.Name = name
+	acc.Data = make(map[string]string)
+
+	// Verify this acount isn't already registered
+	for _, a := range a.Accounts {
+		if a.Name == acc.Name {
+			return Account{}, fmt.Errorf("account name already registered: %s", a.Name)
+		}
+	}
+
+	// Set the creation time
+	acc.Data["created"] = time.Now().String()
+
+	// Create a secret
+	acc.Data["secret"] = uuid.New().String()
+
+	// Simply add the account to the map
+	a.Accounts[acc.Name] = acc
+
+	return
+}
+
+// VerifySecret verifies if an account secret is correct
+func (a *SimpleAccountant) VerifySecret(account string, secret string) (bool, error) {
+	// Find the account matching the ID
+	if this, ok := a.Accounts[account]; ok {
+		return this.Data["secret"] == secret, nil
+	}
+
+	return false, fmt.Errorf("no account found for id: %s", account)
+}
+
+// GetSecret gets the internal secret
+func (a *SimpleAccountant) GetSecret(account string) (string, error) {
+	// Find the account matching the ID
+	if this, ok := a.Accounts[account]; ok {
+		return this.Data["secret"], nil
+	}
+
+	return "", fmt.Errorf("no account found for id: %s", account)
+}
+
+// AssignData assigns data to an account
+func (a *SimpleAccountant) AssignData(account string, key string, value string) error {
+
+	// Find the account matching the ID
+	if this, ok := a.Accounts[account]; ok {
+		this.Data[key] = value
+		a.Accounts[account] = this
+	} else {
+		return fmt.Errorf("no account found for id: %s", account)
+	}
+
+	return nil
+}
+
+// GetValue gets the rover rover for the account
+func (a *SimpleAccountant) GetValue(account string, key string) (string, error) {
+	// Find the account matching the ID
+	this, ok := a.Accounts[account]
+	if !ok {
+		return "", fmt.Errorf("no account found for id: %s", account)
+	}
+	return this.Data[key], nil
+}

pkg/game/atlas.go

@@ -1,186 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"log"
-	"math/rand"
-)
-
-// Chunk represents a fixed square grid of tiles
-type Chunk struct {
-	// Tiles represents the tiles within the chunk
-	Tiles []Tile `json:"tiles"`
-}
-
-// Atlas represents a grid of Chunks
-type Atlas struct {
-	// Chunks represents all chunks in the world
-	// This is intentionally not a 2D array so it can be expanded in all directions
-	Chunks []Chunk `json:"chunks"`
-
-	// size is the current width/height of the given atlas
-	Size int `json:"size"`
-
-	// ChunkSize is the dimensions of each chunk
-	ChunkSize int `json:"chunksize"`
-}
-
-// NewAtlas creates a new empty atlas
-func NewAtlas(size int, chunkSize int) Atlas {
-	if size%2 != 0 {
-		log.Fatal("atlas size must always be even")
-	}
-
-	a := Atlas{
-		Size:      size,
-		Chunks:    make([]Chunk, size*size),
-		ChunkSize: chunkSize,
-	}
-
-	// Initialise all the chunks
-	for i := range a.Chunks {
-		a.Chunks[i] = Chunk{
-			Tiles: make([]Tile, chunkSize*chunkSize),
-		}
-	}
-
-	return a
-}
-
-// SpawnWorld spawns the current world
-func (a *Atlas) SpawnWorld() error {
-	extent := a.ChunkSize * (a.Size / 2)
-
-	// Pepper the current world with rocks
-	for i := -extent; i < extent; i++ {
-		for j := -extent; j < extent; j++ {
-			if rand.Intn(16) == 0 {
-				if err := a.SetTile(Vector{i, j}, TileRock); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	// Surround the atlas in walls
-	for i := -extent; i < extent; i++ {
-
-		if err := a.SetTile(Vector{i, extent - 1}, TileWall); err != nil {
-			return err
-		} else if a.SetTile(Vector{extent - 1, i}, TileWall); err != nil {
-			return err
-		} else if a.SetTile(Vector{-extent, i}, TileWall); err != nil {
-			return err
-		} else if a.SetTile(Vector{i, extent - 1}, TileWall); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// SetTile sets an individual tile's kind
-func (a *Atlas) SetTile(v Vector, tile Tile) error {
-	chunk := a.ToChunk(v)
-	if chunk >= len(a.Chunks) {
-		return fmt.Errorf("location outside of allocated atlas")
-	}
-
-	local := a.ToChunkLocal(v)
-	tileId := local.X + local.Y*a.ChunkSize
-	if tileId >= len(a.Chunks[chunk].Tiles) {
-		return fmt.Errorf("location outside of allocated chunk")
-	}
-	a.Chunks[chunk].Tiles[tileId] = tile
-	return nil
-}
-
-// GetTile will return an individual tile
-func (a *Atlas) GetTile(v Vector) (Tile, error) {
-	chunk := a.ToChunk(v)
-	if chunk >= len(a.Chunks) {
-		return 0, fmt.Errorf("location outside of allocated atlas")
-	}
-
-	local := a.ToChunkLocal(v)
-	tileId := local.X + local.Y*a.ChunkSize
-	if tileId >= len(a.Chunks[chunk].Tiles) {
-		return 0, fmt.Errorf("location outside of allocated chunk")
-	}
-
-	return a.Chunks[chunk].Tiles[tileId], nil
-}
-
-// ToChunkLocal gets a chunk local coordinate for a tile
-func (a *Atlas) ToChunkLocal(v Vector) Vector {
-	return Vector{Pmod(v.X, a.ChunkSize), Pmod(v.Y, a.ChunkSize)}
-}
-
-// GetChunkLocal gets a chunk local coordinate for a tile
-func (a *Atlas) ToWorld(local Vector, chunk int) Vector {
-	return a.ChunkOrigin(chunk).Added(local)
-}
-
-// GetChunkID gets the chunk ID for a position in the world
-func (a *Atlas) ToChunk(v Vector) int {
-	local := a.ToChunkLocal(v)
-	// Get the chunk origin itself
-	origin := v.Added(local.Negated())
-	// Divided it by the number of chunks
-	origin = origin.Divided(a.ChunkSize)
-	// Shift it by our size (our origin is in the middle)
-	origin = origin.Added(Vector{a.Size / 2, a.Size / 2})
-	// Get the ID based on the final values
-	return (a.Size * origin.Y) + origin.X
-}
-
-// ChunkOrigin gets the chunk origin for a given chunk index
-func (a *Atlas) ChunkOrigin(chunk int) Vector {
-	v := Vector{
-		X: Pmod(chunk, a.Size) - (a.Size / 2),
-		Y: (chunk / a.Size) - (a.Size / 2),
-	}
-
-	return v.Multiplied(a.ChunkSize)
-}
-
-// GetWorldExtent gets the min and max valid coordinates of world
-func (a *Atlas) GetWorldExtents() (min Vector, max Vector) {
-	min = Vector{
-		-(a.Size / 2) * a.ChunkSize,
-		-(a.Size / 2) * a.ChunkSize,
-	}
-	max = Vector{
-		-min.X - 1,
-		-min.Y - 1,
-	}
-	return
-}
-
-// Grow will return a grown copy of the current atlas
-func (a *Atlas) Grow(size int) error {
-	if size%2 != 0 {
-		return fmt.Errorf("atlas size must always be even")
-	}
-	delta := size - a.Size
-	if delta < 0 {
-		return fmt.Errorf("Cannot shrink an atlas")
-	} else if delta == 0 {
-		return nil
-	}
-
-	// Create a new atlas
-	newAtlas := NewAtlas(size, a.ChunkSize)
-
-	// Copy old chunks into new chunks
-	for index, chunk := range a.Chunks {
-		// Calculate the new chunk location and copy over the data
-		newAtlas.Chunks[newAtlas.ToChunk(a.ChunkOrigin(index))] = chunk
-	}
-
-	// Copy the new atlas data into this one
-	*a = newAtlas
-
-	// Return the new atlas
-	return nil
-}

pkg/game/atlas_test.go

@@ -1,152 +0,0 @@
-package game
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAtlas_NewAtlas(t *testing.T) {
-	a := NewAtlas(2, 1)
-	assert.NotNil(t, a)
-	// Tiles should look like: 2 | 3
-	//  -----
-	//  0 | 1
-	assert.Equal(t, 4, len(a.Chunks))
-
-	a = NewAtlas(4, 1)
-	assert.NotNil(t, a)
-	// Tiles should look like: 2 | 3
-	//  -----
-	//  0 | 1
-	assert.Equal(t, 16, len(a.Chunks))
-}
-
-func TestAtlas_ToChunk(t *testing.T) {
-	a := NewAtlas(2, 1)
-	assert.NotNil(t, a)
-	// Tiles should look like: 2 | 3
-	//  -----
-	//  0 | 1
-	tile := a.ToChunk(Vector{0, 0})
-	assert.Equal(t, 3, tile)
-	tile = a.ToChunk(Vector{0, -1})
-	assert.Equal(t, 1, tile)
-	tile = a.ToChunk(Vector{-1, -1})
-	assert.Equal(t, 0, tile)
-	tile = a.ToChunk(Vector{-1, 0})
-	assert.Equal(t, 2, tile)
-
-	a = NewAtlas(2, 2)
-	assert.NotNil(t, a)
-	// Tiles should look like:
-	// 2 | 3
-	// -----
-	// 0 | 1
-	tile = a.ToChunk(Vector{1, 1})
-	assert.Equal(t, 3, tile)
-	tile = a.ToChunk(Vector{1, -2})
-	assert.Equal(t, 1, tile)
-	tile = a.ToChunk(Vector{-2, -2})
-	assert.Equal(t, 0, tile)
-	tile = a.ToChunk(Vector{-2, 1})
-	assert.Equal(t, 2, tile)
-
-	a = NewAtlas(4, 2)
-	assert.NotNil(t, a)
-	// Tiles should look like:
-	//  12| 13|| 14| 15
-	// ----------------
-	//  8 | 9 || 10| 11
-	// ================
-	//  4 | 5 || 6 | 7
-	// ----------------
-	//  0 | 1 || 2 | 3
-	tile = a.ToChunk(Vector{1, 3})
-	assert.Equal(t, 14, tile)
-	tile = a.ToChunk(Vector{1, -3})
-	assert.Equal(t, 2, tile)
-	tile = a.ToChunk(Vector{-1, -1})
-	assert.Equal(t, 5, tile)
-	tile = a.ToChunk(Vector{-2, 2})
-	assert.Equal(t, 13, tile)
-}
-
-func TestAtlas_GetSetTile(t *testing.T) {
-	a := NewAtlas(4, 10)
-	assert.NotNil(t, a)
-
-	// Set the origin tile to 1 and test it
-	assert.NoError(t, a.SetTile(Vector{0, 0}, 1))
-	tile, err := a.GetTile(Vector{0, 0})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(1), tile)
-
-	// Set another tile to 1 and test it
-	assert.NoError(t, a.SetTile(Vector{5, -2}, 2))
-	tile, err = a.GetTile(Vector{5, -2})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(2), tile)
-}
-
-func TestAtlas_Grown(t *testing.T) {
-	// Start with a small example
-	a := NewAtlas(2, 2)
-	assert.NotNil(t, a)
-	assert.Equal(t, 4, len(a.Chunks))
-
-	// Set a few tiles to values
-	assert.NoError(t, a.SetTile(Vector{0, 0}, 1))
-	assert.NoError(t, a.SetTile(Vector{-1, -1}, 2))
-	assert.NoError(t, a.SetTile(Vector{1, -2}, 3))
-
-	// Grow once to just double it
-	err := a.Grow(4)
-	assert.NoError(t, err)
-	assert.Equal(t, 16, len(a.Chunks))
-
-	tile, err := a.GetTile(Vector{0, 0})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(1), tile)
-
-	tile, err = a.GetTile(Vector{-1, -1})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(2), tile)
-
-	tile, err = a.GetTile(Vector{1, -2})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(3), tile)
-
-	// Grow it again even bigger
-	err = a.Grow(10)
-	assert.NoError(t, err)
-	assert.Equal(t, 100, len(a.Chunks))
-
-	tile, err = a.GetTile(Vector{0, 0})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(1), tile)
-
-	tile, err = a.GetTile(Vector{-1, -1})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(2), tile)
-
-	tile, err = a.GetTile(Vector{1, -2})
-	assert.NoError(t, err)
-	assert.Equal(t, Tile(3), tile)
-}
-
-func TestAtlas_SpawnWorld(t *testing.T) {
-	// Start with a small example
-	a := NewAtlas(2, 2)
-	assert.NotNil(t, a)
-	assert.Equal(t, 4, len(a.Chunks))
-
-	assert.NoError(t, a.SpawnWorld())
-	tile, err := a.GetTile(Vector{1, 1})
-	assert.NoError(t, err)
-	assert.Equal(t, TileWall, tile)
-
-	tile, err = a.GetTile(Vector{-2, -2})
-	assert.NoError(t, err)
-	assert.Equal(t, TileWall, tile)
-}

pkg/game/command.go

@@ -1,17 +0,0 @@
-package game
-
-const (
-	CommandMove = "move"
-)
-
-// Command represends a single command to execute
-type Command struct {
-	Command string `json:"command"`
-
-	// Used in the move command
-	Bearing  string `json:"bearing,omitempty"`
-	Duration int    `json:"duration,omitempty"`
-}
-
-// CommandStream is a list of commands to execute in order
-type CommandStream []Command

pkg/game/command_test.go

@@ -1,37 +0,0 @@
-package game
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCommand_Move(t *testing.T) {
-	world := NewWorld()
-	a, err := world.SpawnRover()
-	assert.NoError(t, err)
-	pos := Vector{
-		X: 1.0,
-		Y: 2.0,
-	}
-
-	attribs, err := world.RoverAttributes(a)
-	assert.NoError(t, err, "Failed to get rover attribs")
-
-	err = world.WarpRover(a, pos)
-	assert.NoError(t, err, "Failed to set position for rover")
-
-	bearing := North
-	duration := 1
-	// Try the move command
-	moveCommand := Command{Command: CommandMove, Bearing: bearing.String(), Duration: duration}
-	assert.NoError(t, world.Enqueue(a, moveCommand), "Failed to execute move command")
-
-	// Tick the world
-	world.ExecuteCommandQueues()
-
-	newatributes, err := world.RoverAttributes(a)
-	assert.NoError(t, err, "Failed to set position for rover")
-	pos.Add(Vector{0.0, duration * attribs.Speed}) // We should have moved duration*speed north
-	assert.Equal(t, pos, newatributes.Pos, "Failed to correctly set position for rover")
-}

pkg/game/math.go

@@ -1,158 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"math"
-	"strings"
-)
-
-// TODO: Pull this out into math package and get more test coverage
-
-// Abs gets the absolute value of an int
-func Abs(x int) int {
-	if x < 0 {
-		return -x
-	}
-	return x
-}
-
-// pmod is a mositive modulo
-// golang's % is a "remainder" function si misbehaves for negative modulus inputs
-func Pmod(x, d int) int {
-	x = x % d
-	if x >= 0 {
-		return x
-	} else if d < 0 {
-		return x - d
-	} else {
-		return x + d
-	}
-}
-
-// Max returns the highest int
-func Max(x int, y int) int {
-	if x < y {
-		return y
-	}
-	return x
-}
-
-// Min returns the lowest int
-func Min(x int, y int) int {
-	if x > y {
-		return y
-	}
-	return x
-}
-
-// Vector desribes a 3D vector
-type Vector struct {
-	X int `json:"x"`
-	Y int `json:"y"`
-}
-
-// Add adds one vector to another
-func (v *Vector) Add(v2 Vector) {
-	v.X += v2.X
-	v.Y += v2.Y
-}
-
-// Added calculates a new vector
-func (v Vector) Added(v2 Vector) Vector {
-	v.Add(v2)
-	return v
-}
-
-// Negated returns a negated vector
-func (v Vector) Negated() Vector {
-	return Vector{-v.X, -v.Y}
-}
-
-// Length returns the length of the vector
-func (v Vector) Length() float64 {
-	return math.Sqrt(float64(v.X*v.X + v.Y*v.Y))
-}
-
-// Distance returns the distance between two vectors
-func (v Vector) Distance(v2 Vector) float64 {
-	// Negate the two vectors and calciate the length
-	return v.Added(v2.Negated()).Length()
-}
-
-// Multiplied returns the vector multiplied by an int
-func (v Vector) Multiplied(val int) Vector {
-	return Vector{v.X * val, v.Y * val}
-}
-
-// Divided returns the vector divided by an int
-func (v Vector) Divided(val int) Vector {
-	return Vector{v.X / val, v.Y / val}
-}
-
-// Direction describes a compass direction
-type Direction int
-
-const (
-	North Direction = iota
-	NorthEast
-	East
-	SouthEast
-	South
-	SouthWest
-	West
-	NorthWest
-)
-
-// DirectionString simply describes the strings associated with a direction
-type DirectionString struct {
-	Long  string
-	Short string
-}
-
-// DirectionStrings is the set of strings for each direction
-var DirectionStrings = []DirectionString{
-	{"North", "N"},
-	{"NorthEast", "NE"},
-	{"East", "E"},
-	{"SouthEast", "SE"},
-	{"South", "S"},
-	{"SouthWest", "SW"},
-	{"West", "W"},
-	{"NorthWest", "NW"},
-}
-
-// String converts a Direction to a String
-func (d Direction) String() string {
-	return DirectionStrings[d].Long
-}
-
-// ShortString converts a Direction to a short string version
-func (d Direction) ShortString() string {
-	return DirectionStrings[d].Short
-}
-
-// DirectionFromString gets the Direction from a string
-func DirectionFromString(s string) (Direction, error) {
-	for i, d := range DirectionStrings {
-		if strings.ToLower(d.Long) == strings.ToLower(s) || strings.ToLower(d.Short) == strings.ToLower(s) {
-			return Direction(i), nil
-		}
-	}
-	return -1, fmt.Errorf("Unknown direction: %s", s)
-}
-
-var DirectionVectors = []Vector{
-	{0, 1},  // N
-	{1, 1},  // NE
-	{1, 0},  // E
-	{1, -1}, // SE
-	{0, -1}, // S
-	{-1, 1}, // SW
-	{-1, 0}, // W
-	{-1, 1}, // NW
-}
-
-// Vector converts a Direction to a Vector
-func (d Direction) Vector() Vector {
-	return DirectionVectors[d]
-}

pkg/game/rover.go

@@ -1,27 +0,0 @@
-package game
-
-import "github.com/google/uuid"
-
-// RoverAttributes contains attributes of a rover
-type RoverAttributes struct {
-	// Speed represents the Speed that the rover will move per second
-	Speed int `json:"speed"`
-
-	// Range represents the distance the unit's radar can see
-	Range int `json:"range"`
-
-	// Name of this rover
-	Name string `json:"name"`
-
-	// Pos represents where this rover is in the world
-	Pos Vector `json:"pos"`
-}
-
-// Rover describes a single rover in the world
-type Rover struct {
-	// Id is a unique ID for this rover
-	Id uuid.UUID `json:"id"`
-
-	// Attributes represents the physical attributes of the rover
-	Attributes RoverAttributes `json:"attributes"`
-}

pkg/game/tile.go

@@ -1,13 +0,0 @@
-package game
-
-// Tile represents the type of a tile on the map
-type Tile byte
-
-const (
-	TileEmpty = Tile(0)
-	TileRover = Tile(1)
-
-	// TODO: Is there even a difference between these two?
-	TileWall = Tile(2)
-	TileRock = Tile(3)
-)

pkg/game/world.go

@@ -1,344 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"math/rand"
-	"sync"
-
-	"github.com/google/uuid"
-	"github.com/tjarratt/babble"
-)
-
-// World describes a self contained universe and everything in it
-type World struct {
-	// Rovers is a id->data map of all the rovers in the game
-	Rovers map[uuid.UUID]Rover `json:"rovers"`
-
-	// Atlas represends the world map of chunks and tiles
-	Atlas Atlas `json:"atlas"`
-
-	// Mutex to lock around all world operations
-	worldMutex sync.RWMutex
-
-	// Commands is the set of currently executing command streams per rover
-	CommandQueue map[uuid.UUID]CommandStream `json:"commands"`
-
-	// Mutex to lock around command operations
-	cmdMutex sync.RWMutex
-}
-
-// NewWorld creates a new world object
-func NewWorld() *World {
-	return &World{
-		Rovers:       make(map[uuid.UUID]Rover),
-		CommandQueue: make(map[uuid.UUID]CommandStream),
-		Atlas:        NewAtlas(4, 8), // TODO: Choose an appropriate world size
-	}
-}
-
-// SpawnWorld spawns a border at the edge of the world atlas
-func (w *World) SpawnWorld() error {
-	return w.Atlas.SpawnWorld()
-}
-
-// SpawnRover adds an rover to the game
-func (w *World) SpawnRover() (uuid.UUID, error) {
-	w.worldMutex.Lock()
-	defer w.worldMutex.Unlock()
-
-	// Initialise the rover
-	rover := Rover{
-		Id: uuid.New(),
-		Attributes: RoverAttributes{
-
-			Speed: 1.0,
-			Range: 5.0,
-
-			// Set the name randomly
-			// TODO: Fix the stupid "'s"
-			Name: babble.NewBabbler().Babble(),
-		},
-	}
-
-	// Spawn in a random place near the origin
-	rover.Attributes.Pos = Vector{
-		w.Atlas.ChunkSize - (rand.Int() % (w.Atlas.ChunkSize * 2)),
-		w.Atlas.ChunkSize - (rand.Int() % (w.Atlas.ChunkSize * 2)),
-	}
-
-	// Seach until we error (run out of world)
-	for {
-		if tile, err := w.Atlas.GetTile(rover.Attributes.Pos); err != nil {
-			return uuid.Nil, err
-		} else {
-			if tile == TileEmpty {
-				break
-			} else {
-				// Try and spawn to the east of the blockage
-				rover.Attributes.Pos.Add(Vector{1, 0})
-			}
-		}
-	}
-
-	// Set the world tile to a rover
-	if err := w.Atlas.SetTile(rover.Attributes.Pos, TileRover); err != nil {
-		return uuid.Nil, err
-	}
-
-	// Append the rover to the list
-	w.Rovers[rover.Id] = rover
-
-	return rover.Id, nil
-}
-
-// Removes an rover from the game
-func (w *World) DestroyRover(id uuid.UUID) error {
-	w.worldMutex.Lock()
-	defer w.worldMutex.Unlock()
-
-	if i, ok := w.Rovers[id]; ok {
-		// Clear the tile
-		if err := w.Atlas.SetTile(i.Attributes.Pos, TileEmpty); err != nil {
-			return fmt.Errorf("coudln't clear old rover tile: %s", err)
-		}
-		delete(w.Rovers, id)
-	} else {
-		return fmt.Errorf("no rover matching id")
-	}
-	return nil
-}
-
-// RoverAttributes returns the attributes of a requested rover
-func (w *World) RoverAttributes(id uuid.UUID) (RoverAttributes, error) {
-	w.worldMutex.RLock()
-	defer w.worldMutex.RUnlock()
-
-	if i, ok := w.Rovers[id]; ok {
-		return i.Attributes, nil
-	} else {
-		return RoverAttributes{}, fmt.Errorf("no rover matching id")
-	}
-}
-
-// WarpRover sets an rovers position
-func (w *World) WarpRover(id uuid.UUID, pos Vector) error {
-	w.worldMutex.Lock()
-	defer w.worldMutex.Unlock()
-
-	if i, ok := w.Rovers[id]; ok {
-		// Update the world tile
-		// TODO: Make this (and other things) transactional
-		// TODO: Check this worldtile is free
-		if err := w.Atlas.SetTile(pos, TileRover); err != nil {
-			return fmt.Errorf("coudln't set rover tile: %s", err)
-		} else if err := w.Atlas.SetTile(i.Attributes.Pos, TileEmpty); err != nil {
-			return fmt.Errorf("coudln't clear old rover tile: %s", err)
-		}
-
-		i.Attributes.Pos = pos
-		w.Rovers[id] = i
-		return nil
-	} else {
-		return fmt.Errorf("no rover matching id")
-	}
-}
-
-// SetPosition sets an rovers position
-func (w *World) MoveRover(id uuid.UUID, bearing Direction) (RoverAttributes, error) {
-	w.worldMutex.Lock()
-	defer w.worldMutex.Unlock()
-
-	if i, ok := w.Rovers[id]; ok {
-		// Calculate the distance
-		distance := i.Attributes.Speed
-
-		// Calculate the full movement based on the bearing
-		move := bearing.Vector().Multiplied(distance)
-
-		// Try the new move position
-		newPos := i.Attributes.Pos.Added(move)
-
-		// Get the tile and verify it's empty
-		if tile, err := w.Atlas.GetTile(newPos); err != nil {
-			return i.Attributes, fmt.Errorf("couldn't get tile for new position: %s", err)
-		} else if tile == TileEmpty {
-			// Set the world tiles
-			// TODO: Make this (and other things) transactional
-			if err := w.Atlas.SetTile(newPos, TileRover); err != nil {
-				return i.Attributes, fmt.Errorf("coudln't set rover tile: %s", err)
-			} else if err := w.Atlas.SetTile(i.Attributes.Pos, TileEmpty); err != nil {
-				return i.Attributes, fmt.Errorf("coudln't clear old rover tile: %s", err)
-			}
-
-			// Perform the move
-			i.Attributes.Pos = newPos
-			w.Rovers[id] = i
-		}
-
-		return i.Attributes, nil
-	} else {
-		return RoverAttributes{}, fmt.Errorf("no rover matching id")
-	}
-}
-
-// RadarFromRover can be used to query what a rover can currently see
-func (w *World) RadarFromRover(id uuid.UUID) ([]Tile, error) {
-	w.worldMutex.RLock()
-	defer w.worldMutex.RUnlock()
-
-	if r, ok := w.Rovers[id]; ok {
-		// The radar should span in range direction on each axis, plus the row/column the rover is currently on
-		radarSpan := (r.Attributes.Range * 2) + 1
-		roverPos := r.Attributes.Pos
-
-		// Get the radar min and max values
-		radarMin := Vector{
-			X: roverPos.X - r.Attributes.Range,
-			Y: roverPos.Y - r.Attributes.Range,
-		}
-		radarMax := Vector{
-			X: roverPos.X + r.Attributes.Range,
-			Y: roverPos.Y + r.Attributes.Range,
-		}
-
-		// Make sure we only query within the actual world
-		worldMin, worldMax := w.Atlas.GetWorldExtents()
-		scanMin := Vector{
-			X: Max(radarMin.X, worldMin.X),
-			Y: Max(radarMin.Y, worldMin.Y),
-		}
-		scanMax := Vector{
-			X: Min(radarMax.X, worldMax.X),
-			Y: Min(radarMax.Y, worldMax.Y),
-		}
-
-		// Gather up all tiles within the range
-		var radar = make([]Tile, radarSpan*radarSpan)
-		for i := scanMin.X; i < scanMax.X; i++ {
-			for j := scanMin.Y; j < scanMax.Y; j++ {
-				q := Vector{i, j}
-
-				if tile, err := w.Atlas.GetTile(q); err != nil {
-					return nil, fmt.Errorf("failed to query tile: %s", err)
-
-				} else {
-					// Get the position relative to the bottom left of the radar
-					relative := q.Added(radarMin.Negated())
-					radar[relative.X+relative.Y*radarSpan] = tile
-				}
-			}
-		}
-
-		return radar, nil
-	} else {
-		return nil, fmt.Errorf("no rover matching id")
-	}
-}
-
-// Enqueue will queue the commands given
-func (w *World) Enqueue(rover uuid.UUID, commands ...Command) error {
-
-	// First validate the commands
-	for _, c := range commands {
-		switch c.Command {
-		case "move":
-			if _, err := DirectionFromString(c.Bearing); err != nil {
-				return fmt.Errorf("unknown direction: %s", c.Bearing)
-			}
-		default:
-			return fmt.Errorf("unknown command: %s", c.Command)
-		}
-	}
-
-	// Lock our commands edit
-	w.cmdMutex.Lock()
-	defer w.cmdMutex.Unlock()
-
-	// Append the commands to the current set
-	cmds := w.CommandQueue[rover]
-	w.CommandQueue[rover] = append(cmds, commands...)
-
-	return nil
-}
-
-// Execute will execute any commands in the current command queue
-func (w *World) ExecuteCommandQueues() {
-	w.cmdMutex.Lock()
-	defer w.cmdMutex.Unlock()
-
-	// Iterate through all commands
-	for rover, cmds := range w.CommandQueue {
-		if len(cmds) != 0 {
-			// Extract the first command in the queue
-			c := cmds[0]
-
-			// Execute the command and clear up if requested
-			if done, err := w.ExecuteCommand(&c, rover); err != nil {
-				w.CommandQueue[rover] = cmds[1:]
-				fmt.Println(err)
-			} else if done {
-				w.CommandQueue[rover] = cmds[1:]
-			} else {
-				w.CommandQueue[rover][0] = c
-			}
-
-			// If there was an error
-
-		} else {
-			// Clean out the empty entry
-			delete(w.CommandQueue, rover)
-		}
-	}
-}
-
-// ExecuteCommand will execute a single command
-func (w *World) ExecuteCommand(c *Command, rover uuid.UUID) (finished bool, err error) {
-	fmt.Printf("Executing command: %+v\n", *c)
-
-	switch c.Command {
-	case "move":
-		if dir, err := DirectionFromString(c.Bearing); err != nil {
-			return true, fmt.Errorf("unknown direction in command %+v, skipping: %s\n", c, err)
-
-		} else if _, err := w.MoveRover(rover, dir); err != nil {
-			return true, fmt.Errorf("error moving rover in command %+v, skipping: %s\n", c, err)
-
-		} else {
-			// If we've successfully moved, reduce the duration by 1
-			c.Duration -= 1
-
-			// If we've used up the full duration, remove it, otherwise update
-			if c.Duration == 0 {
-				finished = true
-			}
-		}
-	default:
-		return true, fmt.Errorf("unknown command: %s", c.Command)
-	}
-
-	return
-}
-
-// RLock read locks the world
-func (w *World) RLock() {
-	w.worldMutex.RLock()
-	w.cmdMutex.RLock()
-}
-
-// RUnlock read unlocks the world
-func (w *World) RUnlock() {
-	w.worldMutex.RUnlock()
-	w.cmdMutex.RUnlock()
-}
-
-// Lock locks the world
-func (w *World) Lock() {
-	w.worldMutex.Lock()
-	w.cmdMutex.Lock()
-}
-
-// Unlock unlocks the world
-func (w *World) Unlock() {
-	w.worldMutex.Unlock()
-	w.cmdMutex.Unlock()
-}

pkg/game/world_test.go

@@ -1,119 +0,0 @@
-package game
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewWorld(t *testing.T) {
-	// Very basic for now, nothing to verify
-	world := NewWorld()
-	if world == nil {
-		t.Error("Failed to create world")
-	}
-}
-
-func TestWorld_CreateRover(t *testing.T) {
-	world := NewWorld()
-	a, err := world.SpawnRover()
-	assert.NoError(t, err)
-	b, err := world.SpawnRover()
-	assert.NoError(t, err)
-
-	// Basic duplicate check
-	if a == b {
-		t.Errorf("Created identical rovers")
-	} else if len(world.Rovers) != 2 {
-		t.Errorf("Incorrect number of rovers created")
-	}
-}
-
-func TestWorld_RoverAttributes(t *testing.T) {
-	world := NewWorld()
-	a, err := world.SpawnRover()
-	assert.NoError(t, err)
-
-	attribs, err := world.RoverAttributes(a)
-	assert.NoError(t, err, "Failed to get rover attribs")
-	assert.NotZero(t, attribs.Range, "Rover should not be spawned blind")
-	assert.NotZero(t, attribs.Speed, "Rover should not be spawned unable to move")
-}
-
-func TestWorld_DestroyRover(t *testing.T) {
-	world := NewWorld()
-	a, err := world.SpawnRover()
-	assert.NoError(t, err)
-	b, err := world.SpawnRover()
-	assert.NoError(t, err)
-
-	err = world.DestroyRover(a)
-	assert.NoError(t, err, "Error returned from rover destroy")
-
-	// Basic duplicate check
-	if len(world.Rovers) != 1 {
-		t.Error("Too many rovers left in world")
-	} else if _, ok := world.Rovers[b]; !ok {
-		t.Error("Remaining rover is incorrect")
-	}
-}
-
-func TestWorld_GetSetMovePosition(t *testing.T) {
-	world := NewWorld()
-	a, err := world.SpawnRover()
-	assert.NoError(t, err)
-	attribs, err := world.RoverAttributes(a)
-	assert.NoError(t, err, "Failed to get rover attribs")
-
-	pos := Vector{
-		X: 0.0,
-		Y: 0.0,
-	}
-
-	err = world.WarpRover(a, pos)
-	assert.NoError(t, err, "Failed to set position for rover")
-
-	newAttribs, err := world.RoverAttributes(a)
-	assert.NoError(t, err, "Failed to set position for rover")
-	assert.Equal(t, pos, newAttribs.Pos, "Failed to correctly set position for rover")
-
-	bearing := North
-	duration := 1
-	newAttribs, err = world.MoveRover(a, bearing)
-	assert.NoError(t, err, "Failed to set position for rover")
-	pos.Add(Vector{0, attribs.Speed * duration}) // We should have move one unit of the speed north
-	assert.Equal(t, pos, newAttribs.Pos, "Failed to correctly move position for rover")
-
-	// Place a tile in front of the rover
-	assert.NoError(t, world.Atlas.SetTile(Vector{0, 2}, TileWall))
-	newAttribs, err = world.MoveRover(a, bearing)
-	assert.Equal(t, pos, newAttribs.Pos, "Failed to correctly not move position for rover into wall")
-}
-
-func TestWorld_RadarFromRover(t *testing.T) {
-	world := NewWorld()
-	a, err := world.SpawnRover()
-	assert.NoError(t, err)
-	b, err := world.SpawnRover()
-	assert.NoError(t, err)
-
-	// Get a's attributes
-	attrib, err := world.RoverAttributes(a)
-	assert.NoError(t, err, "Failed to get rover attribs")
-
-	// Warp the rovers so a can see b
-	bpos := Vector{-attrib.Range, -attrib.Range}
-	assert.NoError(t, world.WarpRover(a, Vector{0, 0}), "Failed to warp rover")
-	assert.NoError(t, world.WarpRover(b, bpos), "Failed to warp rover")
-
-	radar, err := world.RadarFromRover(a)
-	assert.NoError(t, err, "Failed to get radar from rover")
-	fullRange := attrib.Range + attrib.Range + 1
-	assert.Equal(t, fullRange*fullRange, len(radar), "Radar returned wrong number of rovers")
-
-	// bottom left should be a rover (we put one there with bpos)
-	assert.Equal(t, radar[0], TileRover, "Rover not found on radar in expected position")
-	// Centre should be rover
-	assert.Equal(t, radar[fullRange*fullRange/2], TileRover, "Rover not found on radar in expected position")
-
-}

pkg/maths/maths.go

@@ -0,0 +1,57 @@
+package maths
+
+// Abs gets the absolute value of an int
+func Abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+// Pmod is a mositive modulo
+// golang's % is a "remainder" function si misbehaves for negative modulus inputs
+func Pmod(x, d int) int {
+	if x == 0 || d == 0 {
+		return 0
+	}
+	x = x % d
+	if x >= 0 {
+		return x
+	} else if d < 0 {
+		return x - d
+	} else {
+		return x + d
+	}
+}
+
+// Max returns the highest int
+func Max(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}
+
+// Min returns the lowest int
+func Min(x, y int) int {
+	if x > y {
+		return y
+	}
+	return x
+}
+
+// RoundUp rounds a value up to the nearest multiple
+func RoundUp(toRound int, multiple int) int {
+	remainder := Pmod(toRound, multiple)
+	if remainder == 0 {
+		return toRound
+	}
+
+	return (multiple - remainder) + toRound
+}
+
+// RoundDown rounds a value down to the nearest multiple
+func RoundDown(toRound int, multiple int) int {
+	remainder := Pmod(toRound, multiple)
+	return toRound - remainder
+}

pkg/maths/maths_test.go

@@ -0,0 +1,47 @@
+package maths
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAbs(t *testing.T) {
+	assert.Equal(t, 0, Abs(0))
+	assert.Equal(t, 1, Abs(1))
+	assert.Equal(t, 1, Abs(-1))
+}
+
+func TestPmod(t *testing.T) {
+	assert.Equal(t, 0, Pmod(0, 0))
+	assert.Equal(t, 2, Pmod(6, 4))
+	assert.Equal(t, 2, Pmod(-6, 4))
+	assert.Equal(t, 4, Pmod(-6, 10))
+}
+
+func TestMax(t *testing.T) {
+	assert.Equal(t, 500, Max(100, 500))
+	assert.Equal(t, 1, Max(-4, 1))
+	assert.Equal(t, -2, Max(-4, -2))
+}
+
+func TestMin(t *testing.T) {
+	assert.Equal(t, 100, Min(100, 500))
+	assert.Equal(t, -4, Min(-4, 1))
+	assert.Equal(t, -4, Min(-4, -2))
+}
+
+func TestRoundUp(t *testing.T) {
+	assert.Equal(t, 10, RoundUp(10, 5))
+	assert.Equal(t, 12, RoundUp(10, 4))
+	assert.Equal(t, -8, RoundUp(-8, 4))
+	assert.Equal(t, -4, RoundUp(-7, 4))
+}
+
+func TestRoundDown(t *testing.T) {
+	assert.Equal(t, 10, RoundDown(10, 5))
+	assert.Equal(t, 8, RoundDown(10, 4))
+	assert.Equal(t, -8, RoundDown(-8, 4))
+	assert.Equal(t, -8, RoundDown(-7, 4))
+
+}

pkg/maths/vector.go

@@ -0,0 +1,119 @@
+package maths
+
+import (
+	"math"
+
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+// Vector desribes a 3D vector
+type Vector struct {
+	X int
+	Y int
+}
+
+// Add adds one vector to another
+func (v *Vector) Add(v2 Vector) {
+	v.X += v2.X
+	v.Y += v2.Y
+}
+
+// Added calculates a new vector
+func (v Vector) Added(v2 Vector) Vector {
+	v.Add(v2)
+	return v
+}
+
+// Negated returns a negated vector
+func (v Vector) Negated() Vector {
+	return Vector{-v.X, -v.Y}
+}
+
+// Length returns the length of the vector
+func (v Vector) Length() float64 {
+	return math.Sqrt(float64(v.X*v.X + v.Y*v.Y))
+}
+
+// Distance returns the distance between two vectors
+func (v Vector) Distance(v2 Vector) float64 {
+	// Negate the two vectors and calciate the length
+	return v.Added(v2.Negated()).Length()
+}
+
+// Multiplied returns the vector multiplied by an int
+func (v Vector) Multiplied(val int) Vector {
+	return Vector{v.X * val, v.Y * val}
+}
+
+// Divided returns the vector divided by an int
+func (v Vector) Divided(val int) Vector {
+	return Vector{v.X / val, v.Y / val}
+}
+
+// DividedFloor returns the vector divided but floors the value regardless
+func (v Vector) DividedFloor(val int) Vector {
+	x := float64(v.X) / float64(val)
+
+	if x < 0 {
+		x = math.Floor(x)
+	} else {
+		x = math.Floor(x)
+	}
+	y := float64(v.Y) / float64(val)
+	if y < 0 {
+		y = math.Floor(y)
+	} else {
+		y = math.Floor(y)
+	}
+
+	return Vector{X: int(x), Y: int(y)}
+}
+
+// Abs returns an absolute version of the vector
+func (v Vector) Abs() Vector {
+	return Vector{Abs(v.X), Abs(v.Y)}
+}
+
+// Min2 returns the minimum values in both vectors
+func Min2(v1 Vector, v2 Vector) Vector {
+	return Vector{Min(v1.X, v2.X), Min(v1.Y, v2.Y)}
+}
+
+// Max2 returns the max values in both vectors
+func Max2(v1 Vector, v2 Vector) Vector {
+	return Vector{Max(v1.X, v2.X), Max(v1.Y, v2.Y)}
+}
+
+// BearingToVector converts a bearing to a vector
+func BearingToVector(b roveapi.Bearing) Vector {
+	switch b {
+	case roveapi.Bearing_North:
+		return Vector{Y: 1}
+	case roveapi.Bearing_NorthEast:
+		return Vector{X: 1, Y: 1}
+	case roveapi.Bearing_East:
+		return Vector{X: 1}
+	case roveapi.Bearing_SouthEast:
+		return Vector{X: 1, Y: -1}
+	case roveapi.Bearing_South:
+		return Vector{Y: -1}
+	case roveapi.Bearing_SouthWest:
+		return Vector{X: -1, Y: -1}
+	case roveapi.Bearing_West:
+		return Vector{X: -1}
+	case roveapi.Bearing_NorthWest:
+		return Vector{X: -1, Y: 1}
+	}
+
+	return Vector{}
+}
+
+// Dot returns the dot product of two vectors
+func Dot(a Vector, b Vector) int {
+	return a.X*b.X + a.Y*b.Y
+}
+
+// AngleCos returns the cosine of the angle between two vectors
+func AngleCos(a Vector, b Vector) float64 {
+	return float64(Dot(a, b)) / a.Length() * b.Length()
+}

pkg/maths/vector_test.go

@@ -1,4 +1,4 @@
-package game
+package maths
 
 import (
 	"math"
@@ -180,15 +180,15 @@ func TestVector_Multiplied(t *testing.T) {
 	}{
 		{
 			name: "Basic multiply 1",
-			vec:  North.Vector(),
+			vec:  Vector{0, 1},
 			arg:  2,
 			want: Vector{0, 2},
 		},
 		{
 			name: "Basic multiply 2",
-			vec:  NorthWest.Vector(),
+			vec:  Vector{-1, 1},
 			arg:  -1,
-			want: SouthEast.Vector(),
+			want: Vector{1, -1},
 		},
 	}
 	for _, tt := range tests {
@@ -203,27 +203,3 @@ func TestVector_Multiplied(t *testing.T) {
 		})
 	}
 }
-
-func TestDirection(t *testing.T) {
-	dir := North
-
-	assert.Equal(t, "North", dir.String())
-	assert.Equal(t, "N", dir.ShortString())
-	assert.Equal(t, Vector{0, 1}, dir.Vector())
-
-	dir, err := DirectionFromString("N")
-	assert.NoError(t, err)
-	assert.Equal(t, North, dir)
-
-	dir, err = DirectionFromString("n")
-	assert.NoError(t, err)
-	assert.Equal(t, North, dir)
-
-	dir, err = DirectionFromString("north")
-	assert.NoError(t, err)
-	assert.Equal(t, North, dir)
-
-	dir, err = DirectionFromString("NorthWest")
-	assert.NoError(t, err)
-	assert.Equal(t, NorthWest, dir)
-}

pkg/persistence/persistence.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"log"
 	"os"
 	"path"
 )
@@ -12,13 +13,13 @@ import (
 var dataPath = os.TempDir()
 
 // SetPath sets the persistent path for the data storage
-func SetPath(path string) error {
-	if info, err := os.Stat(path); err != nil {
+func SetPath(p string) error {
+	if info, err := os.Stat(p); err != nil {
 		return err
 	} else if !info.IsDir() {
 		return fmt.Errorf("path for persistence is not directory")
 	}
-	dataPath = path
+	dataPath = p
 	return nil
 }
 
@@ -29,40 +30,41 @@ func jsonPath(name string) string {
 
 // Save will serialise the interface into a json file
 func Save(name string, data interface{}) error {
-	path := jsonPath(name)
-	if b, err := json.MarshalIndent(data, "", "  "); err != nil {
+	p := jsonPath(name)
+	b, err := json.MarshalIndent(data, "", "  ")
+	if err != nil {
 		return err
-	} else {
-		if err := ioutil.WriteFile(jsonPath(name), b, os.ModePerm); err != nil {
-			return err
-		}
 	}
 
-	fmt.Printf("Saved %s\n", path)
+	if err := ioutil.WriteFile(p, b, os.ModePerm); err != nil {
+		return err
+	}
+
+	log.Printf("Saved %s\n", p)
 	return nil
 }
 
 // Load will load the interface from the json file
 func Load(name string, data interface{}) error {
-	path := jsonPath(name)
+	p := jsonPath(name)
 	// Don't load anything if the file doesn't exist
-	_, err := os.Stat(path)
+	_, err := os.Stat(p)
 	if os.IsNotExist(err) {
-		fmt.Printf("File %s didn't exist, loading with fresh data\n", path)
+		log.Printf("File %s didn't exist, loading with fresh data\n", p)
 		return nil
 	}
 
 	// Read and unmarshal the json
-	if b, err := ioutil.ReadFile(path); err != nil {
+	if b, err := ioutil.ReadFile(p); err != nil {
 		return err
 	} else if len(b) == 0 {
-		fmt.Printf("File %s was empty, loading with fresh data\n", path)
+		log.Printf("File %s was empty, loading with fresh data\n", p)
 		return nil
 	} else if err := json.Unmarshal(b, data); err != nil {
-		return fmt.Errorf("failed to load file %s error: %s", path, err)
+		return fmt.Errorf("failed to load file %s error: %s", p, err)
 	}
 
-	fmt.Printf("Loaded %s\n", path)
+	log.Printf("Loaded %s\n", p)
 	return nil
 }
 
@@ -76,7 +78,7 @@ func doAll(f saveLoadFunc, args ...interface{}) error {
 			var ok bool
 			name, ok = a.(string)
 			if !ok {
-				return fmt.Errorf("Incorrect args")
+				return fmt.Errorf("incorrect args")
 			}
 		} else {
 			if err := f(name, a); err != nil {

pkg/rove/api.go

@@ -1,130 +0,0 @@
-package rove
-
-import (
-	"path"
-
-	"github.com/mdiluz/rove/pkg/game"
-)
-
-// ==============================
-// API: /status method: GET
-
-// Status queries the status of the server
-func (s Server) Status() (r StatusResponse, err error) {
-	s.GET("status", &r)
-	return
-}
-
-// StatusResponse is a struct that contains information on the status of the server
-type StatusResponse struct {
-	Ready    bool   `json:"ready"`
-	Version  string `json:"version"`
-	Tick     int    `json:"tick"`
-	NextTick string `json:"nexttick,omitempty"`
-
-	// TODO: return more useful info
-}
-
-// ==============================
-// API: /register method: POST
-
-// Register registers a user by name
-// Responds with a unique ID for that user to be used in future requests
-func (s Server) Register(d RegisterData) (r RegisterResponse, err error) {
-	err = s.POST("register", d, &r)
-	return
-}
-
-// RegisterData describes the data to send when registering
-type RegisterData struct {
-	Name string `json:"name"`
-}
-
-// RegisterResponse describes the response to a register request
-type RegisterResponse struct {
-	Success bool   `json:"success"`
-	Error   string `json:"error,omitempty"`
-
-	Id string `json:"id"`
-}
-
-// ==============================
-// API: /{account}/spawn method: POST
-
-// Spawn spawns the rover for an account
-// Responds with the position of said rover
-func (s Server) Spawn(account string, d SpawnData) (r SpawnResponse, err error) {
-	err = s.POST(path.Join(account, "spawn"), d, &r)
-	return
-}
-
-// SpawnData is the data to be sent for the spawn command
-type SpawnData struct {
-	// Empty for now, reserved for data
-}
-
-// SpawnResponse is the data to respond with on a spawn command
-type SpawnResponse struct {
-	Success bool   `json:"success"`
-	Error   string `json:"error,omitempty"`
-
-	// The attributes of the spawned entity
-	Attributes game.RoverAttributes `json:"attributes"`
-}
-
-// ==============================
-// API: /{account}/command method: POST
-
-// Command issues a set of commands from the user
-func (s Server) Command(account string, d CommandData) (r CommandResponse, err error) {
-	err = s.POST(path.Join(account, "command"), d, &r)
-	return
-}
-
-// CommandData is a set of commands to execute in order
-type CommandData struct {
-	Commands []game.Command `json:"commands"`
-}
-
-// CommandResponse is the response to be sent back
-type CommandResponse struct {
-	Success bool   `json:"success"`
-	Error   string `json:"error,omitempty"`
-}
-
-// ================
-// API: /{account}/radar method: GET
-
-// Radar queries the current radar for the user
-func (s Server) Radar(account string) (r RadarResponse, err error) {
-	err = s.GET(path.Join(account, "radar"), &r)
-	return
-}
-
-// RadarResponse describes the response to a /radar call
-type RadarResponse struct {
-	Success bool   `json:"success"`
-	Error   string `json:"error,omitempty"`
-
-	// The set of positions for nearby non-empty tiles
-	Range int         `json:"range"`
-	Tiles []game.Tile `json:"tiles"`
-}
-
-// ================
-// API: /{account}/rover method: GET
-
-// Rover queries the current state of the rover
-func (s Server) Rover(account string) (r RoverResponse, err error) {
-	err = s.GET(path.Join(account, "rover"), &r)
-	return
-}
-
-// RoverResponse includes information about the rover in question
-type RoverResponse struct {
-	Success bool   `json:"success"`
-	Error   string `json:"error,omitempty"`
-
-	// The current position of this rover
-	Attributes game.RoverAttributes `json:"attributes"`
-}

pkg/rove/atlas.go

@@ -0,0 +1,18 @@
+package rove
+
+import (
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+// Atlas represents a 2D world atlas of tiles and objects
+type Atlas interface {
+	// SetTile sets a location on the Atlas to a type of tile
+	SetTile(v maths.Vector, tile roveapi.Tile)
+
+	// SetObject will set a location on the Atlas to contain an object
+	SetObject(v maths.Vector, obj Object)
+
+	// QueryPosition queries a position on the atlas
+	QueryPosition(v maths.Vector) (roveapi.Tile, Object)
+}

pkg/rove/atlas_test.go

@@ -0,0 +1,257 @@
+package rove
+
+import (
+	"testing"
+
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAtlas_NewAtlas(t *testing.T) {
+	a := NewChunkAtlas(1).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	assert.Equal(t, 1, a.ChunkSize)
+	assert.Equal(t, 1, len(a.Chunks)) // Should start empty
+}
+
+func TestAtlas_toChunk(t *testing.T) {
+	a := NewChunkAtlas(1).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+
+	// Get a tile to spawn the chunks
+	a.QueryPosition(maths.Vector{X: -1, Y: -1})
+	a.QueryPosition(maths.Vector{X: 0, Y: 0})
+	assert.Equal(t, 2*2, len(a.Chunks))
+
+	// Chunks should look like:
+	//  2 | 3
+	//  -----
+	//  0 | 1
+	chunkID := a.worldSpaceToChunkIndex(maths.Vector{X: 0, Y: 0})
+	assert.Equal(t, 3, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 0, Y: -1})
+	assert.Equal(t, 1, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: -1, Y: -1})
+	assert.Equal(t, 0, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: -1, Y: 0})
+	assert.Equal(t, 2, chunkID)
+
+	a = NewChunkAtlas(2).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	// Get a tile to spawn the chunks
+	a.QueryPosition(maths.Vector{X: -2, Y: -2})
+	assert.Equal(t, 2*2, len(a.Chunks))
+	a.QueryPosition(maths.Vector{X: 1, Y: 1})
+	assert.Equal(t, 2*2, len(a.Chunks))
+	// Chunks should look like:
+	// 2 | 3
+	// -----
+	// 0 | 1
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 1, Y: 1})
+	assert.Equal(t, 3, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 1, Y: -2})
+	assert.Equal(t, 1, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: -2, Y: -2})
+	assert.Equal(t, 0, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: -2, Y: 1})
+	assert.Equal(t, 2, chunkID)
+
+	a = NewChunkAtlas(2).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	// Get a tile to spawn a 4x4 grid of chunks
+	a.QueryPosition(maths.Vector{X: 3, Y: 3})
+	assert.Equal(t, 2*2, len(a.Chunks))
+	a.QueryPosition(maths.Vector{X: -3, Y: -3})
+	assert.Equal(t, 4*4, len(a.Chunks))
+
+	// Chunks should look like:
+	//  12| 13|| 14| 15
+	// ----------------
+	//  8 | 9 || 10| 11
+	// ================
+	//  4 | 5 || 6 | 7
+	// ----------------
+	//  0 | 1 || 2 | 3
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 1, Y: 3})
+	assert.Equal(t, 14, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 1, Y: -3})
+	assert.Equal(t, 2, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: -1, Y: -1})
+	assert.Equal(t, 5, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: -2, Y: 2})
+	assert.Equal(t, 13, chunkID)
+
+	a = NewChunkAtlas(3).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	// Get a tile to spawn a 4x4 grid of chunks
+	a.QueryPosition(maths.Vector{X: 3, Y: 3})
+	assert.Equal(t, 2*2, len(a.Chunks))
+
+	// Chunks should look like:
+	// || 2| 3
+	// -------
+	// || 0| 1
+	// =======
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 1, Y: 1})
+	assert.Equal(t, 0, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 3, Y: 1})
+	assert.Equal(t, 1, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 1, Y: 4})
+	assert.Equal(t, 2, chunkID)
+	chunkID = a.worldSpaceToChunkIndex(maths.Vector{X: 5, Y: 5})
+	assert.Equal(t, 3, chunkID)
+}
+
+func TestAtlas_toWorld(t *testing.T) {
+	a := NewChunkAtlas(1).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+
+	// Get a tile to spawn some chunks
+	a.QueryPosition(maths.Vector{X: -1, Y: -1})
+	assert.Equal(t, 2*2, len(a.Chunks))
+
+	// Chunks should look like:
+	//  2 | 3
+	//  -----
+	//  0 | 1
+	assert.Equal(t, maths.Vector{X: -1, Y: -1}, a.chunkOriginInWorldSpace(0))
+	assert.Equal(t, maths.Vector{X: 0, Y: -1}, a.chunkOriginInWorldSpace(1))
+
+	a = NewChunkAtlas(2).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	// Get a tile to spawn the chunks
+	a.QueryPosition(maths.Vector{X: -2, Y: -2})
+	assert.Equal(t, 2*2, len(a.Chunks))
+	a.QueryPosition(maths.Vector{X: 1, Y: 1})
+	assert.Equal(t, 2*2, len(a.Chunks))
+	// Chunks should look like:
+	// 2 | 3
+	// -----
+	// 0 | 1
+	assert.Equal(t, maths.Vector{X: -2, Y: -2}, a.chunkOriginInWorldSpace(0))
+	assert.Equal(t, maths.Vector{X: -2, Y: 0}, a.chunkOriginInWorldSpace(2))
+
+	a = NewChunkAtlas(2).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	// Get a tile to spawn a 4x4 grid of chunks
+	a.QueryPosition(maths.Vector{X: 3, Y: 3})
+	assert.Equal(t, 2*2, len(a.Chunks))
+	a.QueryPosition(maths.Vector{X: -3, Y: -3})
+	assert.Equal(t, 4*4, len(a.Chunks))
+
+	// Chunks should look like:
+	//  12| 13|| 14| 15
+	// ----------------
+	//  8 | 9 || 10| 11
+	// ================
+	//  4 | 5 || 6 | 7
+	// ----------------
+	//  0 | 1 || 2 | 3
+	assert.Equal(t, maths.Vector{X: -4, Y: -4}, a.chunkOriginInWorldSpace(0))
+	assert.Equal(t, maths.Vector{X: 2, Y: -2}, a.chunkOriginInWorldSpace(7))
+
+	a = NewChunkAtlas(3).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	// Get a tile to spawn a 4x4 grid of chunks
+	a.QueryPosition(maths.Vector{X: 3, Y: 3})
+	assert.Equal(t, 2*2, len(a.Chunks))
+
+	// Chunks should look like:
+	// || 2| 3
+	// -------
+	// || 0| 1
+	// =======
+	assert.Equal(t, maths.Vector{X: 0, Y: 0}, a.chunkOriginInWorldSpace(0))
+}
+
+func TestAtlas_GetSetTile(t *testing.T) {
+	a := NewChunkAtlas(10)
+	assert.NotNil(t, a)
+
+	// Set the origin tile and test it
+	a.SetTile(maths.Vector{X: 0, Y: 0}, roveapi.Tile_Gravel)
+	tile, _ := a.QueryPosition(maths.Vector{X: 0, Y: 0})
+	assert.Equal(t, roveapi.Tile_Gravel, tile)
+
+	// Set another tile and test it
+	a.SetTile(maths.Vector{X: 5, Y: -2}, roveapi.Tile_Rock)
+	tile, _ = a.QueryPosition(maths.Vector{X: 5, Y: -2})
+	assert.Equal(t, roveapi.Tile_Rock, tile)
+}
+
+func TestAtlas_GetSetObject(t *testing.T) {
+	a := NewChunkAtlas(10)
+	assert.NotNil(t, a)
+
+	// Set the origin tile to 1 and test it
+	a.SetObject(maths.Vector{X: 0, Y: 0}, Object{Type: roveapi.Object_RockLarge})
+	_, obj := a.QueryPosition(maths.Vector{X: 0, Y: 0})
+	assert.Equal(t, Object{Type: roveapi.Object_RockLarge}, obj)
+
+	// Set another tile to 1 and test it
+	a.SetObject(maths.Vector{X: 5, Y: -2}, Object{Type: roveapi.Object_RockSmall})
+	_, obj = a.QueryPosition(maths.Vector{X: 5, Y: -2})
+	assert.Equal(t, Object{Type: roveapi.Object_RockSmall}, obj)
+}
+
+func TestAtlas_Grown(t *testing.T) {
+	// Start with a small example
+	a := NewChunkAtlas(2).(*chunkBasedAtlas)
+	assert.NotNil(t, a)
+	assert.Equal(t, 1, len(a.Chunks))
+
+	// Set a few tiles to values
+	a.SetTile(maths.Vector{X: 0, Y: 0}, roveapi.Tile_Gravel)
+	a.SetTile(maths.Vector{X: -1, Y: -1}, roveapi.Tile_Rock)
+	a.SetTile(maths.Vector{X: 1, Y: -2}, roveapi.Tile_Sand)
+
+	// Check tile values
+	tile, _ := a.QueryPosition(maths.Vector{X: 0, Y: 0})
+	assert.Equal(t, roveapi.Tile_Gravel, tile)
+
+	tile, _ = a.QueryPosition(maths.Vector{X: -1, Y: -1})
+	assert.Equal(t, roveapi.Tile_Rock, tile)
+
+	tile, _ = a.QueryPosition(maths.Vector{X: 1, Y: -2})
+	assert.Equal(t, roveapi.Tile_Sand, tile)
+
+	tile, _ = a.QueryPosition(maths.Vector{X: 0, Y: 0})
+	assert.Equal(t, roveapi.Tile_Gravel, tile)
+
+	tile, _ = a.QueryPosition(maths.Vector{X: -1, Y: -1})
+	assert.Equal(t, roveapi.Tile_Rock, tile)
+
+	tile, _ = a.QueryPosition(maths.Vector{X: 1, Y: -2})
+	assert.Equal(t, roveapi.Tile_Sand, tile)
+}
+
+func TestAtlas_GetSetCorrect(t *testing.T) {
+	// Big stress test to ensure we do actually properly expand for all reasonable values
+	for i := 1; i <= 4; i++ {
+
+		for x := -i * 2; x < i*2; x++ {
+			for y := -i * 2; y < i*2; y++ {
+				a := NewChunkAtlas(i).(*chunkBasedAtlas)
+				assert.NotNil(t, a)
+				assert.Equal(t, 1, len(a.Chunks))
+
+				pos := maths.Vector{X: x, Y: y}
+				a.SetTile(pos, roveapi.Tile_Rock)
+				a.SetObject(pos, Object{Type: roveapi.Object_RockLarge})
+				tile, obj := a.QueryPosition(pos)
+
+				assert.Equal(t, roveapi.Tile_Rock, roveapi.Tile(tile))
+				assert.Equal(t, Object{Type: roveapi.Object_RockLarge}, obj)
+
+			}
+		}
+	}
+}
+
+func TestAtlas_WorldGen(t *testing.T) {
+	a := NewChunkAtlas(8)
+
+	// Spawn a large world
+	_, _ = a.QueryPosition(maths.Vector{X: 20, Y: 20})
+}

pkg/rove/chunkAtlas.go

@@ -0,0 +1,231 @@
+package rove
+
+import (
+	"log"
+
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+// chunk represents a fixed square grid of tiles
+type chunk struct {
+	// Tiles represents the tiles within the chunk
+	Tiles []byte
+
+	// Objects represents the objects within the chunk
+	// only one possible object per tile for now
+	Objects map[int]Object
+}
+
+// chunkBasedAtlas represents a grid of Chunks
+type chunkBasedAtlas struct {
+	// Chunks represents all chunks in the world
+	// This is intentionally not a 2D array so it can be expanded in all directions
+	Chunks []chunk
+
+	// LowerBound is the origin of the bottom left corner of the current chunks in world space (current chunks cover >= this value)
+	LowerBound maths.Vector
+
+	// UpperBound is the top left corner of the current chunks (curent chunks cover < this value)
+	UpperBound maths.Vector
+
+	// ChunkSize is the x/y dimensions of each square chunk
+	ChunkSize int
+
+	// worldGen is the internal world generator
+	worldGen WorldGen
+}
+
+const (
+	noiseSeed = 1024
+)
+
+// NewChunkAtlas creates a new empty atlas
+func NewChunkAtlas(chunkSize int) Atlas {
+	// Start up with one chunk
+	a := chunkBasedAtlas{
+		ChunkSize:  chunkSize,
+		Chunks:     make([]chunk, 1),
+		LowerBound: maths.Vector{X: 0, Y: 0},
+		UpperBound: maths.Vector{X: chunkSize, Y: chunkSize},
+		worldGen:   NewNoiseWorldGen(noiseSeed),
+	}
+	// Initialise the first chunk
+	a.populate(0)
+	return &a
+}
+
+// SetTile sets an individual tile's kind
+func (a *chunkBasedAtlas) SetTile(v maths.Vector, tile roveapi.Tile) {
+	c := a.worldSpaceToChunkWithGrow(v)
+	local := a.worldSpaceToChunkLocal(v)
+	a.setTile(c, local, byte(tile))
+}
+
+// SetObject sets the object on a tile
+func (a *chunkBasedAtlas) SetObject(v maths.Vector, obj Object) {
+	c := a.worldSpaceToChunkWithGrow(v)
+	local := a.worldSpaceToChunkLocal(v)
+	a.setObject(c, local, obj)
+}
+
+// QueryPosition will return information for a specific position
+func (a *chunkBasedAtlas) QueryPosition(v maths.Vector) (roveapi.Tile, Object) {
+	c := a.worldSpaceToChunkWithGrow(v)
+	local := a.worldSpaceToChunkLocal(v)
+	a.populate(c)
+	chunk := a.Chunks[c]
+	i := a.chunkTileIndex(local)
+	return roveapi.Tile(chunk.Tiles[i]), chunk.Objects[i]
+}
+
+// chunkTileID returns the tile index within a chunk
+func (a *chunkBasedAtlas) chunkTileIndex(local maths.Vector) int {
+	return local.X + local.Y*a.ChunkSize
+}
+
+// populate will fill a chunk with data
+func (a *chunkBasedAtlas) populate(chunk int) {
+	c := a.Chunks[chunk]
+	if c.Tiles != nil {
+		return
+	}
+
+	c.Tiles = make([]byte, a.ChunkSize*a.ChunkSize)
+	c.Objects = make(map[int]Object)
+
+	origin := a.chunkOriginInWorldSpace(chunk)
+	for i := 0; i < a.ChunkSize; i++ {
+		for j := 0; j < a.ChunkSize; j++ {
+			loc := maths.Vector{X: origin.X + i, Y: origin.Y + j}
+
+			// Set the tile
+			c.Tiles[j*a.ChunkSize+i] = byte(a.worldGen.GetTile(loc))
+
+			// Set the object
+			obj := a.worldGen.GetObject(loc)
+			if obj.Type != roveapi.Object_ObjectUnknown {
+				c.Objects[j*a.ChunkSize+i] = obj
+			}
+		}
+	}
+
+	a.Chunks[chunk] = c
+}
+
+// setTile sets a tile in a specific chunk
+func (a *chunkBasedAtlas) setTile(chunk int, local maths.Vector, tile byte) {
+	a.populate(chunk)
+	c := a.Chunks[chunk]
+	c.Tiles[a.chunkTileIndex(local)] = tile
+	a.Chunks[chunk] = c
+}
+
+// setObject sets an object in a specific chunk
+func (a *chunkBasedAtlas) setObject(chunk int, local maths.Vector, object Object) {
+	a.populate(chunk)
+
+	c := a.Chunks[chunk]
+	i := a.chunkTileIndex(local)
+	if object.Type != roveapi.Object_ObjectUnknown {
+		c.Objects[i] = object
+	} else {
+		delete(c.Objects, i)
+	}
+	a.Chunks[chunk] = c
+}
+
+// worldSpaceToChunkLocal gets a chunk local coordinate for a tile
+func (a *chunkBasedAtlas) worldSpaceToChunkLocal(v maths.Vector) maths.Vector {
+	return maths.Vector{X: maths.Pmod(v.X, a.ChunkSize), Y: maths.Pmod(v.Y, a.ChunkSize)}
+}
+
+// worldSpaceToChunkID gets the current chunk ID for a position in the world
+func (a *chunkBasedAtlas) worldSpaceToChunkIndex(v maths.Vector) int {
+	// Shift the vector by our current min
+	v = v.Added(a.LowerBound.Negated())
+
+	// Divide by the current size and floor, to get chunk-scaled vector from the lower bound
+	v = v.DividedFloor(a.ChunkSize)
+
+	// Calculate the width
+	width := a.UpperBound.X - a.LowerBound.X
+	widthInChunks := width / a.ChunkSize
+
+	// Along the corridor and up the stairs
+	return (v.Y * widthInChunks) + v.X
+}
+
+// chunkOriginInWorldSpace returns the origin of the chunk in world space
+func (a *chunkBasedAtlas) chunkOriginInWorldSpace(chunk int) maths.Vector {
+	// Calculate the width
+	width := a.UpperBound.X - a.LowerBound.X
+	widthInChunks := width / a.ChunkSize
+
+	// Reverse the along the corridor and up the stairs
+	v := maths.Vector{
+		X: chunk % widthInChunks,
+		Y: chunk / widthInChunks,
+	}
+	// Multiply up to world scale
+	v = v.Multiplied(a.ChunkSize)
+	// Shift by the lower bound
+	return v.Added(a.LowerBound)
+}
+
+// getNewBounds gets new lower and upper bounds for the world space given a vector
+func (a *chunkBasedAtlas) getNewBounds(v maths.Vector) (lower maths.Vector, upper maths.Vector) {
+	lower = maths.Min2(v, a.LowerBound)
+	upper = maths.Max2(v.Added(maths.Vector{X: 1, Y: 1}), a.UpperBound)
+
+	lower = maths.Vector{
+		X: maths.RoundDown(lower.X, a.ChunkSize),
+		Y: maths.RoundDown(lower.Y, a.ChunkSize),
+	}
+	upper = maths.Vector{
+		X: maths.RoundUp(upper.X, a.ChunkSize),
+		Y: maths.RoundUp(upper.Y, a.ChunkSize),
+	}
+	return
+}
+
+// worldSpaceToTrunkWithGrow will expand the current atlas for a given world space position if needed
+func (a *chunkBasedAtlas) worldSpaceToChunkWithGrow(v maths.Vector) int {
+	// If we're within bounds, just return the current chunk
+	if v.X >= a.LowerBound.X && v.Y >= a.LowerBound.Y && v.X < a.UpperBound.X && v.Y < a.UpperBound.Y {
+		return a.worldSpaceToChunkIndex(v)
+	}
+
+	// Calculate the new bounds
+	lower, upper := a.getNewBounds(v)
+	size := upper.Added(lower.Negated())
+	size = size.Divided(a.ChunkSize)
+
+	// Create the new empty atlas
+	newAtlas := chunkBasedAtlas{
+		ChunkSize:  a.ChunkSize,
+		LowerBound: lower,
+		UpperBound: upper,
+		Chunks:     make([]chunk, size.X*size.Y),
+		worldGen:   a.worldGen,
+	}
+
+	// Log that we're resizing
+	log.Printf("Re-allocating world, old: %+v,%+v new: %+v,%+v\n", a.LowerBound, a.UpperBound, newAtlas.LowerBound, newAtlas.UpperBound)
+
+	// Copy all old chunks into the new atlas
+	for chunk, chunkData := range a.Chunks {
+
+		// Calculate the chunk ID in the new atlas
+		origin := a.chunkOriginInWorldSpace(chunk)
+		newChunk := newAtlas.worldSpaceToChunkIndex(origin)
+
+		// Copy over the old chunk to the new atlas
+		newAtlas.Chunks[newChunk] = chunkData
+	}
+
+	// Overwrite the old atlas with this one
+	*a = newAtlas
+
+	return a.worldSpaceToChunkIndex(v)
+}

pkg/rove/command_test.go

@@ -0,0 +1,305 @@
+package rove
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCommand_Invalid(t *testing.T) {
+	w := NewWorld(8)
+	name, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_none})
+	assert.Error(t, err)
+}
+
+func TestCommand_Toggle(t *testing.T) {
+	w := NewWorld(8)
+	a, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	r, err := w.GetRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.SailPosition_SolarCharging, r.SailPosition)
+
+	err = w.Enqueue(a, &roveapi.Command{Command: roveapi.CommandType_toggle})
+	assert.NoError(t, err)
+	w.Tick()
+
+	r, err = w.GetRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.SailPosition_CatchingWind, r.SailPosition)
+
+	err = w.Enqueue(a, &roveapi.Command{Command: roveapi.CommandType_toggle})
+	assert.NoError(t, err)
+	w.Tick()
+
+	r, err = w.GetRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.SailPosition_SolarCharging, r.SailPosition)
+}
+
+func TestCommand_Turn(t *testing.T) {
+	w := NewWorld(8)
+	a, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	err = w.Enqueue(a, &roveapi.Command{Command: roveapi.CommandType_turn, Bearing: roveapi.Bearing_NorthWest})
+	assert.NoError(t, err)
+	w.Tick()
+
+	r, err := w.GetRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.Bearing_NorthWest, r.Bearing)
+}
+
+func TestCommand_Stash(t *testing.T) {
+	w := NewWorld(8)
+	name, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	info, err := w.GetRover(name)
+	assert.NoError(t, err)
+	assert.Empty(t, info.Inventory)
+
+	// Drop a pickup below us
+	w.Atlas.SetObject(info.Pos, Object{Type: roveapi.Object_RockSmall})
+
+	// Try and stash it
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_stash})
+	assert.NoError(t, err)
+	w.Tick()
+
+	// Check we now have it in the inventory
+	info, err = w.GetRover(name)
+	assert.NoError(t, err)
+	assert.Equal(t, 1, len(info.Inventory))
+	assert.Equal(t, Object{Type: roveapi.Object_RockSmall}, info.Inventory[0])
+
+	// Check it's no longer on the atlas
+	_, obj := w.Atlas.QueryPosition(info.Pos)
+	assert.Equal(t, Object{Type: roveapi.Object_ObjectUnknown}, obj)
+}
+
+func TestCommand_Repair(t *testing.T) {
+	w := NewWorld(8)
+	name, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	info, err := w.GetRover(name)
+	assert.NoError(t, err)
+	assert.Equal(t, info.MaximumIntegrity, info.Integrity)
+
+	// Put a blocking rock to the north
+	w.Atlas.SetObject(info.Pos.Added(maths.Vector{X: 0, Y: 1}), Object{Type: roveapi.Object_RockLarge})
+
+	// Try and move and make sure we're blocked
+	newpos, err := w.TryMoveRover(name, roveapi.Bearing_North)
+	assert.NoError(t, err)
+	assert.Equal(t, info.Pos, newpos)
+
+	// Check we're damaged
+	info, err = w.GetRover(name)
+	assert.NoError(t, err)
+	assert.Equal(t, info.MaximumIntegrity-1, info.Integrity)
+
+	// Stash a repair object
+	w.Atlas.SetObject(info.Pos, Object{Type: roveapi.Object_RoverParts})
+	obj, err := w.RoverStash(name)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.Object_RoverParts, obj)
+
+	// Enqueue the repair and tick
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_repair})
+	assert.NoError(t, err)
+	w.Tick()
+
+	// Check we're repaired
+	info, err = w.GetRover(name)
+	assert.NoError(t, err)
+	assert.Equal(t, info.MaximumIntegrity, info.Integrity)
+	assert.Equal(t, 0, len(info.Inventory))
+}
+
+func TestCommand_Broadcast(t *testing.T) {
+	w := NewWorld(8)
+	name, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	// Enqueue the broadcast and tick
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_broadcast, Data: []byte("ABC")})
+	assert.NoError(t, err)
+	w.Tick()
+
+	info, err := w.GetRover(name)
+	assert.NoError(t, err)
+	assert.Contains(t, info.Logs[len(info.Logs)-1].Text, "ABC")
+}
+
+func TestCommand_Salvage(t *testing.T) {
+	w := NewWorld(8)
+	name, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	info, err := w.GetRover(name)
+	assert.NoError(t, err)
+
+	w.Atlas.SetObject(info.Pos, Object{Type: roveapi.Object_RoverDormant})
+
+	// Enqueue the broadcast and tick
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_salvage})
+	assert.NoError(t, err)
+	w.Tick()
+
+	// Check we now have some rover parts
+	info, err = w.GetRover(name)
+	assert.NoError(t, err)
+	assert.NotEmpty(t, info.Inventory)
+	for _, i := range info.Inventory {
+		assert.Equal(t, roveapi.Object_RoverParts, i.Type)
+	}
+
+	// Check the dormant rover is gone
+	_, obj := w.Atlas.QueryPosition(info.Pos)
+	assert.Equal(t, roveapi.Object_ObjectUnknown, obj.Type)
+}
+
+func TestCommand_Transfer(t *testing.T) {
+	w := NewWorld(8)
+	acc, err := w.Accountant.RegisterAccount("tmp")
+	assert.NoError(t, err)
+	nameA, err := w.SpawnRover(acc.Name)
+	assert.NoError(t, err)
+
+	infoA, err := w.GetRover(nameA)
+	assert.NoError(t, err)
+
+	// Drop a dormant rover on the current position
+	infoB := DefaultRover()
+	infoB.Name = "abc"
+	infoB.Pos = infoA.Pos
+	data, err := json.Marshal(infoB)
+	assert.NoError(t, err)
+	w.Atlas.SetObject(infoA.Pos, Object{Type: roveapi.Object_RoverDormant, Data: data})
+
+	// Enqueue a transfer as well as a dud command
+	err = w.Enqueue(nameA,
+		&roveapi.Command{Command: roveapi.CommandType_transfer},
+		&roveapi.Command{Command: roveapi.CommandType_broadcast, Data: []byte("xyz")})
+	assert.NoError(t, err)
+	w.Tick()
+
+	// Ensure both command queues are empty
+	assert.Empty(t, w.CommandQueue[nameA])
+	assert.Empty(t, w.CommandQueue[infoB.Name])
+
+	// Verify the account now controls the new rover
+	accountRover, err := w.Accountant.GetValue(acc.Name, "rover")
+	assert.NoError(t, err)
+	assert.Equal(t, infoB.Name, accountRover)
+
+	// Verify the position now has a dormant rover
+	_, obj := w.Atlas.QueryPosition(infoA.Pos)
+	assert.Equal(t, roveapi.Object_RoverDormant, obj.Type)
+
+	// Verify the stored data matches
+	var stored Rover
+	err = json.Unmarshal(obj.Data, &stored)
+	assert.NoError(t, err)
+	assert.Equal(t, infoA.Name, stored.Name)
+
+	// Verify the new rover data matches what we put in
+	infoB2, err := w.GetRover(infoB.Name)
+	assert.NoError(t, err)
+	assert.Equal(t, infoB.Name, infoB2.Name)
+
+}
+
+func TestCommand_Wait(t *testing.T) {
+	w := NewWorld(8)
+	a, err := w.SpawnRover("")
+	assert.NoError(t, err)
+
+	r, err := w.GetRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.SailPosition_SolarCharging, r.SailPosition)
+
+	err = w.Enqueue(a, &roveapi.Command{Command: roveapi.CommandType_wait, Repeat: 4}, &roveapi.Command{Command: roveapi.CommandType_toggle})
+	assert.NoError(t, err)
+
+	// Tick 5 times during the wait (1 normal execute + 4)
+	for i := 0; i < 5; i++ {
+		w.Tick()
+
+		r, err = w.GetRover(a)
+		assert.NoError(t, err)
+		assert.Equal(t, roveapi.SailPosition_SolarCharging, r.SailPosition)
+	}
+
+	// One last tick to do the toggle
+	w.Tick()
+
+	r, err = w.GetRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.SailPosition_CatchingWind, r.SailPosition)
+}
+
+func TestCommand_Upgrade(t *testing.T) {
+	w := NewWorld(8)
+	name, err := w.SpawnRover("")
+	assert.NoError(t, err)
+	rover, ok := w.Rovers[name]
+	assert.True(t, ok)
+
+	// Try an invalid upgrade
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_upgrade})
+	assert.Error(t, err)
+
+	// Try a valid command but without the parts
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_upgrade, Upgrade: roveapi.RoverUpgrade_Capacity})
+	assert.NoError(t, err)
+
+	// Ensure nothing changed and we logged the attempt
+	pre := rover.Capacity
+	w.Tick()
+	assert.Equal(t, pre, rover.Capacity)
+	assert.Contains(t, rover.Logs[len(rover.Logs)-1].Text, "tried")
+
+	// One non-part item
+	rover.Inventory = []Object{
+		{
+			Type: roveapi.Object_RoverParts,
+		},
+		{
+			Type: roveapi.Object_RoverParts,
+		},
+		{
+			Type: roveapi.Object_RockSmall,
+		},
+		{
+			Type: roveapi.Object_RoverParts,
+		},
+		{
+			Type: roveapi.Object_RoverParts,
+		},
+		{
+			Type: roveapi.Object_RoverParts,
+		},
+	}
+
+	// Try a valid command again
+	err = w.Enqueue(name, &roveapi.Command{Command: roveapi.CommandType_upgrade, Upgrade: roveapi.RoverUpgrade_Capacity})
+	assert.NoError(t, err)
+
+	// Check that the capacity increases on the tick and all the parts are used
+	pre = rover.Capacity
+	w.Tick()
+	assert.Equal(t, pre+1, rover.Capacity)
+	assert.Equal(t, 1, len(rover.Inventory))
+	assert.Equal(t, roveapi.Object_RockSmall, rover.Inventory[0].Type)
+}

pkg/rove/http.go

@@ -1,64 +0,0 @@
-package rove
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-)
-
-// Server is a simple wrapper to a server path
-type Server string
-
-// GET performs a GET request
-func (s Server) GET(path string, out interface{}) error {
-	url := url.URL{
-		Scheme: "http",
-		Host:   string(s),
-		Path:   path,
-	}
-	if resp, err := http.Get(url.String()); err != nil {
-		return err
-
-	} else if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("http.Get returned status %d: %s", resp.StatusCode, resp.Status)
-
-	} else {
-		return json.NewDecoder(resp.Body).Decode(out)
-	}
-}
-
-// POST performs a POST request
-func (s Server) POST(path string, in interface{}, out interface{}) error {
-	url := url.URL{
-		Scheme: "http",
-		Host:   string(s),
-		Path:   path,
-	}
-	client := &http.Client{}
-
-	// Marshal the input
-	marshalled, err := json.Marshal(in)
-	if err != nil {
-		return err
-	}
-
-	// Set up the request
-	req, err := http.NewRequest("POST", url.String(), bytes.NewReader(marshalled))
-	if err != nil {
-		return err
-	}
-
-	// Do the POST
-	req.Header.Set("Content-Type", "application/json")
-	if resp, err := client.Do(req); err != nil {
-		return err
-
-	} else if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("http returned status %d", resp.StatusCode)
-
-	} else {
-		return json.NewDecoder(resp.Body).Decode(out)
-	}
-}

pkg/rove/objects.go

@@ -0,0 +1,44 @@
+package rove
+
+import (
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+// Object represents an object in the world
+type Object struct {
+	// The type of the object
+	Type roveapi.Object
+
+	// Data is an internal type used for certain types of object
+	Data []byte
+}
+
+// IsBlocking checks if an object is a blocking object
+func (o *Object) IsBlocking() bool {
+	var blocking = [...]roveapi.Object{
+		roveapi.Object_RoverLive,
+		roveapi.Object_RockLarge,
+	}
+
+	for _, t := range blocking {
+		if o.Type == t {
+			return true
+		}
+	}
+	return false
+}
+
+// IsStashable checks if an object is stashable
+func (o *Object) IsStashable() bool {
+	var stashable = [...]roveapi.Object{
+		roveapi.Object_RockSmall,
+		roveapi.Object_RoverParts,
+	}
+
+	for _, t := range stashable {
+		if o.Type == t {
+			return true
+		}
+	}
+	return false
+}

pkg/rove/rover.go

@@ -0,0 +1,137 @@
+package rove
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+const (
+	maxLogEntries = 16
+)
+
+// RoverLogEntry describes a single log entry for the rover
+type RoverLogEntry struct {
+	// Time is the timestamp of the entry
+	Time time.Time
+
+	// Text contains the information in this log entry
+	Text string
+}
+
+// Rover describes a single rover in the world
+type Rover struct {
+	// Unique name of this rover
+	Name string
+
+	// Pos represents where this rover is in the world
+	Pos maths.Vector
+
+	// Bearing is the current direction the rover is facing
+	Bearing roveapi.Bearing
+
+	// Range represents the distance the unit's radar can see
+	Range int
+
+	// Inventory represents any items the rover is carrying
+	Inventory []Object
+
+	// Capacity is the maximum number of inventory items
+	Capacity int
+
+	// Integrity represents current rover health
+	Integrity int
+
+	// MaximumIntegrity is the full integrity of the rover
+	MaximumIntegrity int
+
+	// Charge is the amount of energy the rover has
+	Charge int
+
+	// MaximumCharge is the maximum charge able to be stored
+	MaximumCharge int
+
+	// SailPosition is the current position of the sails
+	SailPosition roveapi.SailPosition
+
+	// Current number of ticks in this move, used for sailing speeds
+	MoveTicks int
+
+	// Logs Stores log of information
+	Logs []RoverLogEntry
+
+	// The account that owns this rover
+	Owner string
+}
+
+// DefaultRover returns a default rover object with default settings
+func DefaultRover() *Rover {
+	return &Rover{
+		Range:            10,
+		Integrity:        10,
+		MaximumIntegrity: 10,
+		Capacity:         10,
+		Charge:           10,
+		MaximumCharge:    10,
+		Bearing:          roveapi.Bearing_North,
+		SailPosition:     roveapi.SailPosition_SolarCharging,
+		Name:             GenerateRoverName(),
+	}
+}
+
+// AddLogEntryf adds an entry to the rovers log
+func (r *Rover) AddLogEntryf(format string, args ...interface{}) {
+	text := fmt.Sprintf(format, args...)
+	log.Printf("%s log entry: %s", r.Name, text)
+	r.Logs = append(r.Logs,
+		RoverLogEntry{
+			Time: time.Now(),
+			Text: text,
+		},
+	)
+
+	// Limit the number of logs
+	if len(r.Logs) > maxLogEntries {
+		r.Logs = r.Logs[len(r.Logs)-maxLogEntries:]
+	}
+}
+
+var wordsFile = os.Getenv("WORDS_FILE")
+var roverWords []string
+
+// GenerateRoverName generates a new rover name
+func GenerateRoverName() string {
+
+	// Try and load the rover words file
+	if len(roverWords) == 0 {
+		// Try and load the words file
+		if file, err := os.Open(wordsFile); err != nil {
+			log.Printf("Couldn't read words file [%s], running without words: %s\n", wordsFile, err)
+		} else {
+			defer file.Close()
+			scanner := bufio.NewScanner(file)
+			for scanner.Scan() {
+				roverWords = append(roverWords, scanner.Text())
+			}
+			if scanner.Err() != nil {
+				log.Printf("Failure during word file scan: %s\n", scanner.Err())
+			}
+		}
+	}
+
+	// Assign a random name if we have words
+	if len(roverWords) > 0 {
+		// Loop until we find a unique name
+		return fmt.Sprintf("%s-%s", roverWords[rand.Intn(len(roverWords))], roverWords[rand.Intn(len(roverWords))])
+	}
+
+	// Default to a unique string
+	return uuid.New().String()
+}

pkg/rove/world.go

@@ -0,0 +1,840 @@
+package rove
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"math/rand"
+	"sync"
+
+	"github.com/mdiluz/rove/pkg/accounts"
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+)
+
+const (
+	// ticksPerNormalMove defines the number of ticks it should take for a "normal" speed move
+	ticksPerNormalMove = 4
+
+	// upgradeCost is the cost in rover parts needed to upgrade a rover specification
+	upgradeCost = 5
+)
+
+// CommandStream is a list of commands to execute in order
+type CommandStream []*roveapi.Command
+
+// World describes a self contained universe and everything in it
+type World struct {
+
+	// TicksPerDay is the amount of ticks in a single day
+	TicksPerDay int
+
+	// Current number of ticks from the start
+	CurrentTicks int
+
+	// Rovers is a id->data map of all the rovers in the game
+	Rovers map[string]*Rover
+
+	// Atlas represends the world map of chunks and tiles
+	Atlas Atlas
+
+	// Wind is the current wind direction
+	Wind roveapi.Bearing
+
+	// Commands is the set of currently executing command streams per rover
+	CommandQueue map[string]CommandStream
+
+	// Accountant
+	Accountant accounts.Accountant
+
+	// Mutex to lock around all world operations
+	worldMutex sync.RWMutex
+	// Mutex to lock around command operations
+	cmdMutex sync.RWMutex
+}
+
+// NewWorld creates a new world object
+func NewWorld(chunkSize int) *World {
+	return &World{
+		Rovers:       make(map[string]*Rover),
+		CommandQueue: make(map[string]CommandStream),
+		Atlas:        NewChunkAtlas(chunkSize),
+		TicksPerDay:  24,
+		CurrentTicks: 0,
+		Accountant:   accounts.NewSimpleAccountant(),
+		Wind:         roveapi.Bearing_North,
+	}
+}
+
+// SpawnRover adds an rover to the game (without lock)
+func (w *World) SpawnRover(account string) (string, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	// Initialise the rover
+	rover := DefaultRover()
+
+	// Assign the owner
+	rover.Owner = account
+
+	// Spawn in a random place near the origin
+	rover.Pos = maths.Vector{
+		X: 10 - rand.Intn(20),
+		Y: 10 - rand.Intn(20),
+	}
+
+	// Seach until we error (run out of world)
+	for {
+		_, obj := w.Atlas.QueryPosition(rover.Pos)
+		if !obj.IsBlocking() {
+			break
+		} else {
+			// Try and spawn to the east of the blockage
+			rover.Pos.Add(maths.Vector{X: 1, Y: 0})
+		}
+
+	}
+
+	// Add a log entry for robot creation
+	rover.AddLogEntryf("created at %+v", rover.Pos)
+
+	// Append the rover to the list
+	w.Rovers[rover.Name] = rover
+
+	var err error
+	// Only assign if we've been given an account
+	if len(account) > 0 {
+		err = w.Accountant.AssignData(account, "rover", rover.Name)
+	}
+
+	return rover.Name, err
+}
+
+// GetRover gets a specific rover by name
+func (w *World) GetRover(rover string) (Rover, error) {
+	w.worldMutex.RLock()
+	defer w.worldMutex.RUnlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return Rover{}, fmt.Errorf("Failed to find rover with name: %s", rover)
+	}
+	return *i, nil
+}
+
+// RoverRecharge charges up a rover
+func (w *World) RoverRecharge(rover string) (int, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return 0, fmt.Errorf("Failed to find rover with name: %s", rover)
+	}
+
+	// We can only recharge during the day
+	if !w.Daytime() {
+		return i.Charge, nil
+	}
+
+	// Add one charge
+	if i.Charge < i.MaximumCharge {
+		i.Charge++
+		i.AddLogEntryf("recharged to %d", i.Charge)
+	}
+
+	return i.Charge, nil
+}
+
+// RoverBroadcast broadcasts a message to nearby rovers
+func (w *World) RoverBroadcast(rover string, message []byte) (err error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return fmt.Errorf("Failed to find rover with name: %s", rover)
+	}
+
+	// Use up a charge as needed, if available
+	if i.Charge == 0 {
+		return
+	}
+	i.Charge--
+
+	// Check all rovers
+	for r, rover := range w.Rovers {
+		if rover.Name == i.Name {
+			continue
+		}
+
+		// Check if this rover is within range
+		if i.Pos.Distance(rover.Pos) < float64(i.Range) {
+			rover.AddLogEntryf("recieved %s from %s", string(message), i.Name)
+			w.Rovers[r] = rover
+		}
+	}
+
+	i.AddLogEntryf("broadcasted %s", string(message))
+	return
+}
+
+// DestroyRover Removes an rover from the game
+func (w *World) DestroyRover(rover string) error {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		return fmt.Errorf("no rover matching id")
+	}
+
+	// Remove this rover from tracked rovers
+	delete(w.Rovers, rover)
+
+	r.Owner = ""
+	r.AddLogEntryf("rover destroyed")
+
+	// Marshal the rover data
+	data, err := json.Marshal(r)
+	if err != nil {
+		return err
+	}
+
+	// Place the dormant rover down
+	w.Atlas.SetObject(r.Pos, Object{Type: roveapi.Object_RoverDormant, Data: data})
+
+	return nil
+}
+
+// RoverPosition returns the position of the rover
+func (w *World) RoverPosition(rover string) (maths.Vector, error) {
+	w.worldMutex.RLock()
+	defer w.worldMutex.RUnlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return maths.Vector{}, fmt.Errorf("no rover matching id")
+	}
+	return i.Pos, nil
+}
+
+// SetRoverPosition sets the position of the rover
+func (w *World) SetRoverPosition(rover string, pos maths.Vector) error {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return fmt.Errorf("no rover matching id")
+	}
+
+	i.Pos = pos
+	return nil
+}
+
+// RoverInventory returns the inventory of a requested rover
+func (w *World) RoverInventory(rover string) ([]Object, error) {
+	w.worldMutex.RLock()
+	defer w.worldMutex.RUnlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return nil, fmt.Errorf("no rover matching id")
+	}
+	return i.Inventory, nil
+}
+
+// WarpRover sets an rovers position
+func (w *World) WarpRover(rover string, pos maths.Vector) error {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return fmt.Errorf("no rover matching id")
+	}
+	// Nothing to do if these positions match
+	if i.Pos == pos {
+		return nil
+	}
+
+	// Check the tile is not blocked
+	_, obj := w.Atlas.QueryPosition(pos)
+	if obj.IsBlocking() {
+		return fmt.Errorf("can't warp rover to occupied tile, check before warping")
+	}
+
+	i.Pos = pos
+	return nil
+}
+
+// TryMoveRover attempts to move a rover in a specific direction
+func (w *World) TryMoveRover(rover string, b roveapi.Bearing) (maths.Vector, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	i, ok := w.Rovers[rover]
+	if !ok {
+		return maths.Vector{}, fmt.Errorf("no rover matching id")
+	}
+
+	// Try the new move position
+	newPos := i.Pos.Added(maths.BearingToVector(b))
+
+	// Get the tile and verify it's empty
+	_, obj := w.Atlas.QueryPosition(newPos)
+	if !obj.IsBlocking() {
+		i.AddLogEntryf("moved %s to %+v", b.String(), newPos)
+		// Perform the move
+		i.Pos = newPos
+	} else {
+		// If it is a blocking tile, reduce the rover integrity
+		i.AddLogEntryf("tried to move %s to %+v", b.String(), newPos)
+		i.Integrity = i.Integrity - 1
+		i.AddLogEntryf("had a collision, new integrity %d", i.Integrity)
+	}
+
+	return i.Pos, nil
+}
+
+// RoverStash will stash an item at the current rovers position
+func (w *World) RoverStash(rover string) (roveapi.Object, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		return roveapi.Object_ObjectUnknown, fmt.Errorf("no rover matching id")
+	}
+
+	// Can't pick up when full
+	if len(r.Inventory) >= r.Capacity {
+		r.AddLogEntryf("tried to stash object but inventory was full")
+		return roveapi.Object_ObjectUnknown, nil
+	}
+
+	// Ensure the rover has energy
+	if r.Charge <= 0 {
+		r.AddLogEntryf("tried to stash object but had no charge")
+		return roveapi.Object_ObjectUnknown, nil
+	}
+	r.Charge--
+
+	_, obj := w.Atlas.QueryPosition(r.Pos)
+	if !obj.IsStashable() {
+		return roveapi.Object_ObjectUnknown, nil
+	}
+
+	r.AddLogEntryf("stashed %c", obj.Type)
+	r.Inventory = append(r.Inventory, obj)
+	w.Atlas.SetObject(r.Pos, Object{Type: roveapi.Object_ObjectUnknown})
+	return obj.Type, nil
+}
+
+// RoverSalvage will salvage a rover for parts
+func (w *World) RoverSalvage(rover string) (roveapi.Object, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		return roveapi.Object_ObjectUnknown, fmt.Errorf("no rover matching id")
+	}
+
+	// Can't pick up when full
+	if len(r.Inventory) >= r.Capacity {
+		r.AddLogEntryf("tried to salvage dormant rover but inventory was full")
+		return roveapi.Object_ObjectUnknown, nil
+	}
+
+	// Ensure the rover has energy
+	if r.Charge <= 0 {
+		r.AddLogEntryf("tried to salvage dormant rover but had no charge")
+		return roveapi.Object_ObjectUnknown, nil
+	}
+	r.Charge--
+
+	_, obj := w.Atlas.QueryPosition(r.Pos)
+	if obj.Type != roveapi.Object_RoverDormant {
+		r.AddLogEntryf("tried to salvage dormant rover but found no rover to salvage")
+		return roveapi.Object_ObjectUnknown, nil
+	}
+
+	r.AddLogEntryf("salvaged dormant rover")
+	for i := 0; i < 5; i++ {
+		if len(r.Inventory) == r.Capacity {
+			break
+		}
+		r.Inventory = append(r.Inventory, Object{Type: roveapi.Object_RoverParts})
+	}
+	w.Atlas.SetObject(r.Pos, Object{Type: roveapi.Object_ObjectUnknown})
+	return obj.Type, nil
+}
+
+// RoverTransfer will transfer rover control to dormant rover
+func (w *World) RoverTransfer(rover string) (string, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	oldRover, ok := w.Rovers[rover]
+	if !ok {
+		return "", fmt.Errorf("no rover matching id")
+	}
+
+	_, obj := w.Atlas.QueryPosition(oldRover.Pos)
+	if obj.Type != roveapi.Object_RoverDormant {
+		oldRover.AddLogEntryf("tried to transfer to dormant rover but found no rover")
+		return "", nil
+	}
+
+	// Unmarshal the dormant rover
+	var newRover Rover
+	err := json.Unmarshal(obj.Data, &newRover)
+	if err != nil {
+		return "", err
+	}
+
+	// Add logs
+	oldRover.AddLogEntryf("transferring to dormant rover %s", newRover.Name)
+	newRover.AddLogEntryf("transferred from rover %s", oldRover.Name)
+
+	// Transfer the ownership
+	err = w.Accountant.AssignData(oldRover.Owner, "rover", newRover.Name)
+	if err != nil {
+		return "", err
+	}
+	newRover.Owner = oldRover.Owner
+	oldRover.Owner = ""
+
+	// Place the old rover in the world
+	oldRoverData, err := json.Marshal(oldRover)
+	if err != nil {
+		return "", err
+	}
+	w.Atlas.SetObject(oldRover.Pos, Object{Type: roveapi.Object_RoverDormant, Data: oldRoverData})
+
+	// Swap the rovers in the tracking
+	w.Rovers[newRover.Name] = &newRover
+	delete(w.Rovers, oldRover.Name)
+
+	// Clear the command queues for both rovers
+	delete(w.CommandQueue, oldRover.Name)
+	delete(w.CommandQueue, newRover.Name)
+
+	return newRover.Name, nil
+}
+
+// RoverToggle will toggle the sail position
+func (w *World) RoverToggle(rover string) (roveapi.SailPosition, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		return roveapi.SailPosition_UnknownSailPosition, fmt.Errorf("no rover matching id")
+	}
+
+	// Swap the sail position
+	switch r.SailPosition {
+	case roveapi.SailPosition_CatchingWind:
+		r.SailPosition = roveapi.SailPosition_SolarCharging
+	case roveapi.SailPosition_SolarCharging:
+		r.SailPosition = roveapi.SailPosition_CatchingWind
+	}
+
+	// Reset the movement ticks
+	r.MoveTicks = 0
+
+	return r.SailPosition, nil
+}
+
+// RoverUpgrade will try to upgrade the rover
+func (w *World) RoverUpgrade(rover string, upgrade roveapi.RoverUpgrade) (int, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		return 0, fmt.Errorf("no rover matching id")
+	}
+
+	cost := upgradeCost
+	num := 0
+	for i := range r.Inventory {
+		if r.Inventory[i].Type == roveapi.Object_RoverParts {
+			num++
+		}
+	}
+
+	if num < cost {
+		r.AddLogEntryf("tried to upgrade but lacked rover parts")
+		return 0, nil
+	}
+
+	// Apply the upgrade
+	var ret int
+	switch upgrade {
+	case roveapi.RoverUpgrade_Capacity:
+		r.Capacity++
+		ret = r.Capacity
+	case roveapi.RoverUpgrade_Range:
+		r.Range++
+		ret = r.Range
+	case roveapi.RoverUpgrade_MaximumCharge:
+		r.MaximumCharge++
+		ret = r.MaximumCharge
+	case roveapi.RoverUpgrade_MaximumIntegrity:
+		r.MaximumIntegrity++
+		ret = r.MaximumIntegrity
+	default:
+		return 0, fmt.Errorf("unknown upgrade: %s", upgrade)
+	}
+
+	// Remove the cost in rover parts
+	var n []Object
+	for _, o := range r.Inventory {
+		if o.Type == roveapi.Object_RoverParts && cost > 0 {
+			cost--
+		} else {
+			n = append(n, o)
+		}
+	}
+	// Assign back the inventory
+	r.Inventory = n
+
+	r.AddLogEntryf("upgraded %s to %d", upgrade, ret)
+
+	return ret, nil
+}
+
+// RoverTurn will turn the rover
+func (w *World) RoverTurn(rover string, bearing roveapi.Bearing) (roveapi.Bearing, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		return roveapi.Bearing_BearingUnknown, fmt.Errorf("no rover matching id")
+	}
+
+	// Set the new bearing
+	r.Bearing = bearing
+	// Reset the movement ticks
+	r.MoveTicks = 0
+
+	return r.Bearing, nil
+}
+
+// RoverRepair will turn the rover
+func (w *World) RoverRepair(rover string) (int, error) {
+	w.worldMutex.Lock()
+	defer w.worldMutex.Unlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		return 0, fmt.Errorf("no rover matching id")
+	}
+
+	// Can't repair past max
+	if r.Integrity >= r.MaximumIntegrity {
+		return r.Integrity, nil
+	}
+
+	// Find rover parts in inventory
+	for i, o := range r.Inventory {
+		if o.Type == roveapi.Object_RoverParts {
+
+			// Copy-erase from slice
+			r.Inventory[i] = r.Inventory[len(r.Inventory)-1]
+			r.Inventory = r.Inventory[:len(r.Inventory)-1]
+
+			// Repair
+			r.Integrity = r.Integrity + 1
+			r.AddLogEntryf("repaired self to %d", r.Integrity)
+			break
+		}
+	}
+
+	return r.Integrity, nil
+}
+
+// RadarFromRover can be used to query what a rover can currently see
+func (w *World) RadarFromRover(rover string) (radar []roveapi.Tile, objs []roveapi.Object, err error) {
+	w.worldMutex.RLock()
+	defer w.worldMutex.RUnlock()
+
+	r, ok := w.Rovers[rover]
+	if !ok {
+		err = fmt.Errorf("no rover matching id")
+		return
+	}
+
+	// The radar should span in range direction on each axis, plus the row/column the rover is currently on
+	radarSpan := (r.Range * 2) + 1
+	roverPos := r.Pos
+
+	// Get the radar min and max values
+	radarMin := maths.Vector{
+		X: roverPos.X - r.Range,
+		Y: roverPos.Y - r.Range,
+	}
+	radarMax := maths.Vector{
+		X: roverPos.X + r.Range,
+		Y: roverPos.Y + r.Range,
+	}
+
+	// Gather up all tiles within the range
+	radar = make([]roveapi.Tile, radarSpan*radarSpan)
+	objs = make([]roveapi.Object, radarSpan*radarSpan)
+	for j := radarMin.Y; j <= radarMax.Y; j++ {
+		for i := radarMin.X; i <= radarMax.X; i++ {
+			q := maths.Vector{X: i, Y: j}
+
+			tile, obj := w.Atlas.QueryPosition(q)
+
+			// Get the position relative to the bottom left of the radar
+			relative := q.Added(radarMin.Negated())
+			index := relative.X + relative.Y*radarSpan
+			radar[index] = tile
+			objs[index] = obj.Type
+		}
+	}
+
+	// Add all rovers to the radar
+	for _, r := range w.Rovers {
+		// If the rover is in range
+		dist := r.Pos.Added(roverPos.Negated())
+		dist = dist.Abs()
+
+		if dist.X <= r.Range && dist.Y <= r.Range {
+			relative := r.Pos.Added(radarMin.Negated())
+			index := relative.X + relative.Y*radarSpan
+			objs[index] = roveapi.Object_RoverLive
+		}
+	}
+
+	return radar, objs, nil
+}
+
+// RoverCommands returns current commands for the given rover
+func (w *World) RoverCommands(rover string) (queued CommandStream) {
+	if c, ok := w.CommandQueue[rover]; ok {
+		queued = c
+	}
+	return
+}
+
+// Enqueue will queue the commands given
+func (w *World) Enqueue(rover string, commands ...*roveapi.Command) error {
+
+	// First validate the commands
+	for _, c := range commands {
+		switch c.Command {
+		case roveapi.CommandType_broadcast:
+			if len(c.GetData()) > 3 {
+				return fmt.Errorf("too many characters in message (limit 3): %d", len(c.GetData()))
+			}
+			for _, b := range c.GetData() {
+				if b < 37 || b > 126 {
+					return fmt.Errorf("invalid message character: %c", b)
+				}
+			}
+		case roveapi.CommandType_turn:
+			if c.GetBearing() == roveapi.Bearing_BearingUnknown {
+				return fmt.Errorf("turn command given unknown bearing")
+			}
+		case roveapi.CommandType_upgrade:
+			if c.GetUpgrade() == roveapi.RoverUpgrade_RoverUpgradeUnknown {
+				return fmt.Errorf("upgrade command given unknown upgrade")
+			}
+		case roveapi.CommandType_wait:
+		case roveapi.CommandType_toggle:
+		case roveapi.CommandType_stash:
+		case roveapi.CommandType_repair:
+		case roveapi.CommandType_salvage:
+		case roveapi.CommandType_transfer:
+			// Nothing to verify
+		default:
+			return fmt.Errorf("unknown command: %s", c.Command)
+		}
+	}
+
+	// Lock our commands edit
+	w.cmdMutex.Lock()
+	defer w.cmdMutex.Unlock()
+
+	w.CommandQueue[rover] = commands
+
+	return nil
+}
+
+// Tick will execute any commands in the current command queue and tick the world
+func (w *World) Tick() {
+	w.cmdMutex.Lock()
+	defer w.cmdMutex.Unlock()
+
+	// Iterate through all the current commands
+	for rover, cmds := range w.CommandQueue {
+		if len(cmds) != 0 {
+
+			// Execute the command
+			if done, err := w.ExecuteCommand(cmds[0], rover); err != nil {
+				log.Println(err)
+				// TODO: Report this error somehow
+
+			} else if done {
+				// Extract the first command in the queue
+				// Only if the command queue still has entries (the command may have modified this queue)
+				if _, ok := w.CommandQueue[rover]; ok {
+					w.CommandQueue[rover] = cmds[1:]
+				}
+			}
+
+		} else {
+			// Clean out the empty entry
+			delete(w.CommandQueue, rover)
+		}
+	}
+
+	// Move all the rovers based on current wind and sails
+	for n, r := range w.Rovers {
+		// Skip if we're not catching the wind
+		if r.SailPosition != roveapi.SailPosition_CatchingWind {
+			continue
+		}
+
+		// Increment the current move ticks
+		r.MoveTicks++
+
+		// Get the difference between the two bearings
+		// Normalise, we don't care about clockwise/anticlockwise
+		diff := maths.Abs(int(w.Wind - r.Bearing))
+		if diff > 4 {
+			diff = 8 - diff
+		}
+
+		// Calculate the travel "ticks"
+		var ticksToMove int
+		switch diff {
+		case 0:
+			// Going with the wind, travel at base speed of once every 4 ticks
+			ticksToMove = ticksPerNormalMove
+		case 1:
+			// At a slight angle, we can go a little faster
+			ticksToMove = ticksPerNormalMove / 2
+		case 2:
+			// Perpendicular to wind, max speed
+			ticksToMove = 1
+		case 3:
+			// Heading at 45 degrees into the wind, back to min speed
+			ticksToMove = ticksPerNormalMove
+		case 4:
+			// Heading durectly into the wind, no movement at all
+		default:
+			log.Fatalf("bearing difference of %d should be impossible", diff)
+		}
+
+		// If we've incremented over the current move ticks on the rover, we can try and make the move
+		if ticksToMove != 0 && r.MoveTicks >= ticksToMove {
+			_, err := w.TryMoveRover(n, r.Bearing)
+			if err != nil {
+				log.Println(err)
+				// TODO: Report this error somehow
+			}
+
+			// Reset the move ticks
+			r.MoveTicks = 0
+		}
+	}
+
+	// Check all rover integrities
+	for _, r := range w.Rovers {
+		if r.Integrity <= 0 {
+			// The rover has died destroy it
+			err := w.DestroyRover(r.Name)
+			if err != nil {
+				log.Println(err)
+				// TODO: Report this error somehow
+			}
+
+			// Spawn a new one for this account
+			_, err = w.SpawnRover(r.Owner)
+			if err != nil {
+				log.Println(err)
+				// TODO: Report this error somehow
+			}
+		}
+	}
+
+	// Increment the current tick count
+	w.CurrentTicks++
+
+	// Change the wind every day
+	if (w.CurrentTicks % w.TicksPerDay) == 0 {
+		w.Wind = roveapi.Bearing((rand.Int() % 8) + 1) // Random cardinal bearing
+	}
+}
+
+// ExecuteCommand will execute a single command
+func (w *World) ExecuteCommand(c *roveapi.Command, rover string) (done bool, err error) {
+	log.Printf("Executing command: %+v for %s\n", c.Command, rover)
+
+	switch c.Command {
+	case roveapi.CommandType_toggle:
+		_, err = w.RoverToggle(rover)
+	case roveapi.CommandType_stash:
+		_, err = w.RoverStash(rover)
+	case roveapi.CommandType_repair:
+		_, err = w.RoverRepair(rover)
+	case roveapi.CommandType_broadcast:
+		err = w.RoverBroadcast(rover, c.GetData())
+	case roveapi.CommandType_turn:
+		_, err = w.RoverTurn(rover, c.GetBearing())
+	case roveapi.CommandType_salvage:
+		_, err = w.RoverSalvage(rover)
+	case roveapi.CommandType_transfer:
+		_, err = w.RoverTransfer(rover)
+	case roveapi.CommandType_upgrade:
+		_, err = w.RoverUpgrade(rover, c.GetUpgrade())
+	case roveapi.CommandType_wait:
+		// Nothing to do
+	default:
+		return true, fmt.Errorf("unknown command: %s", c.Command)
+	}
+
+	// Decrement the repeat number
+	c.Repeat--
+	return c.Repeat < 0, err
+}
+
+// Daytime returns if it's currently daytime
+// for simplicity this uses the 1st half of the day as daytime, the 2nd half as nighttime
+func (w *World) Daytime() bool {
+	tickInDay := w.CurrentTicks % w.TicksPerDay
+	return tickInDay < w.TicksPerDay/2
+}
+
+// RLock read locks the world
+func (w *World) RLock() {
+	w.worldMutex.RLock()
+	w.cmdMutex.RLock()
+}
+
+// RUnlock read unlocks the world
+func (w *World) RUnlock() {
+	w.worldMutex.RUnlock()
+	w.cmdMutex.RUnlock()
+}
+
+// Lock locks the world
+func (w *World) Lock() {
+	w.worldMutex.Lock()
+	w.cmdMutex.Lock()
+}
+
+// Unlock unlocks the world
+func (w *World) Unlock() {
+	w.worldMutex.Unlock()
+	w.cmdMutex.Unlock()
+}

pkg/rove/world_test.go

@@ -0,0 +1,359 @@
+package rove
+
+import (
+	"testing"
+
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewWorld(t *testing.T) {
+	// Very basic for now, nothing to verify
+	world := NewWorld(4)
+	if world == nil {
+		t.Error("Failed to create world")
+	}
+}
+
+func TestWorld_CreateRover(t *testing.T) {
+	world := NewWorld(8)
+	a, err := world.SpawnRover("")
+	assert.NoError(t, err)
+	b, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	// Basic duplicate check
+	if a == b {
+		t.Errorf("Created identical rovers")
+	} else if len(world.Rovers) != 2 {
+		t.Errorf("Incorrect number of rovers created")
+	}
+}
+
+func TestWorld_GetRover(t *testing.T) {
+	world := NewWorld(4)
+	a, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	rover, err := world.GetRover(a)
+	assert.NoError(t, err, "Failed to get rover attribs")
+	assert.NotZero(t, rover.Range, "Rover should not be spawned blind")
+	assert.Contains(t, rover.Logs[len(rover.Logs)-1].Text, "created", "Rover logs should contain the creation")
+}
+
+func TestWorld_DestroyRover(t *testing.T) {
+	world := NewWorld(1)
+	a, err := world.SpawnRover("")
+	assert.NoError(t, err)
+	b, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	err = world.DestroyRover(a)
+	assert.NoError(t, err, "Error returned from rover destroy")
+
+	// Basic duplicate check
+	if len(world.Rovers) != 1 {
+		t.Error("Too many rovers left in world")
+	} else if _, ok := world.Rovers[b]; !ok {
+		t.Error("Remaining rover is incorrect")
+	}
+}
+
+func TestWorld_GetSetMovePosition(t *testing.T) {
+	world := NewWorld(4)
+	a, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	pos := maths.Vector{
+		X: 0.0,
+		Y: 0.0,
+	}
+
+	err = world.WarpRover(a, pos)
+	assert.NoError(t, err, "Failed to set position for rover")
+
+	newPos, err := world.RoverPosition(a)
+	assert.NoError(t, err, "Failed to set position for rover")
+	assert.Equal(t, pos, newPos, "Failed to correctly set position for rover")
+
+	b := roveapi.Bearing_North
+	newPos, err = world.TryMoveRover(a, b)
+	assert.NoError(t, err, "Failed to set position for rover")
+	pos.Add(maths.Vector{X: 0, Y: 1})
+	assert.Equal(t, pos, newPos, "Failed to correctly move position for rover")
+
+	rover, err := world.GetRover(a)
+	assert.NoError(t, err, "Failed to get rover information")
+	assert.Contains(t, rover.Logs[len(rover.Logs)-1].Text, "moved", "Rover logs should contain the move")
+
+	// Place a tile in front of the rover
+	world.Atlas.SetObject(maths.Vector{X: 0, Y: 2}, Object{Type: roveapi.Object_RockLarge})
+	newPos, err = world.TryMoveRover(a, b)
+	assert.NoError(t, err, "Failed to move rover")
+	assert.Equal(t, pos, newPos, "Failed to correctly not move position for rover into wall")
+}
+
+func TestWorld_RadarFromRover(t *testing.T) {
+	// Create world that should have visible walls on the radar
+	world := NewWorld(2)
+	a, err := world.SpawnRover("")
+	assert.NoError(t, err)
+	b, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	// Warp the rovers into position
+	bpos := maths.Vector{X: -3, Y: -3}
+	world.Atlas.SetObject(bpos, Object{Type: roveapi.Object_ObjectUnknown})
+	assert.NoError(t, world.WarpRover(b, bpos), "Failed to warp rover")
+	world.Atlas.SetObject(maths.Vector{X: 0, Y: 0}, Object{Type: roveapi.Object_ObjectUnknown})
+	assert.NoError(t, world.WarpRover(a, maths.Vector{X: 0, Y: 0}), "Failed to warp rover")
+
+	r, err := world.GetRover(a)
+	assert.NoError(t, err)
+
+	radar, objs, err := world.RadarFromRover(a)
+	assert.NoError(t, err, "Failed to get radar from rover")
+	fullRange := r.Range + r.Range + 1
+	assert.Equal(t, fullRange*fullRange, len(radar), "Radar returned wrong length")
+	assert.Equal(t, fullRange*fullRange, len(objs), "Radar returned wrong length")
+
+	// TODO: Verify the other rover is on the radar
+
+	// Check the radar results are stable
+	radar1, objs1, err := world.RadarFromRover(a)
+	assert.NoError(t, err)
+	radar2, objs2, err := world.RadarFromRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, radar1, radar2)
+	assert.Equal(t, objs1, objs2)
+}
+
+func TestWorld_RoverDamage(t *testing.T) {
+	world := NewWorld(2)
+	acc, err := world.Accountant.RegisterAccount("tmp")
+	assert.NoError(t, err)
+	a, err := world.SpawnRover(acc.Name)
+	assert.NoError(t, err)
+
+	pos := maths.Vector{
+		X: 0.0,
+		Y: 0.0,
+	}
+
+	world.Atlas.SetObject(pos, Object{Type: roveapi.Object_ObjectUnknown})
+	err = world.WarpRover(a, pos)
+	assert.NoError(t, err, "Failed to set position for rover")
+
+	info, err := world.GetRover(a)
+	assert.NoError(t, err, "couldn't get rover info")
+
+	world.Atlas.SetObject(maths.Vector{X: 0.0, Y: 1.0}, Object{Type: roveapi.Object_RockLarge})
+
+	vec, err := world.TryMoveRover(a, roveapi.Bearing_North)
+	assert.NoError(t, err, "Failed to move rover")
+	assert.Equal(t, pos, vec, "Rover managed to move into large rock")
+
+	newinfo, err := world.GetRover(a)
+	assert.NoError(t, err, "couldn't get rover info")
+	assert.Equal(t, info.Integrity-1, newinfo.Integrity, "rover should have lost integrity")
+	assert.Contains(t, newinfo.Logs[len(newinfo.Logs)-1].Text, "collision", "Rover logs should contain the collision")
+
+	// Keep moving to damage the rover
+	for i := 0; i < info.Integrity-1; i++ {
+		vec, err := world.TryMoveRover(a, roveapi.Bearing_North)
+		assert.NoError(t, err, "Failed to move rover")
+		assert.Equal(t, pos, vec, "Rover managed to move into large rock")
+	}
+
+	// Tick the world to check for rover deaths
+	world.Tick()
+
+	// Rover should have been destroyed now
+	_, err = world.GetRover(a)
+	assert.Error(t, err)
+
+	_, obj := world.Atlas.QueryPosition(info.Pos)
+	assert.Equal(t, roveapi.Object_RoverDormant, obj.Type)
+}
+
+func TestWorld_Daytime(t *testing.T) {
+	world := NewWorld(1)
+
+	a, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	// Remove rover charge
+	rover := world.Rovers[a]
+	rover.Charge = 0
+	world.Rovers[a] = rover
+
+	// Try and recharge, should work
+	_, err = world.RoverRecharge(a)
+	assert.NoError(t, err)
+	assert.Equal(t, 1, world.Rovers[a].Charge)
+
+	// Loop for half the day
+	for i := 0; i < world.TicksPerDay/2; i++ {
+		assert.True(t, world.Daytime())
+		world.Tick()
+	}
+
+	// Remove rover charge again
+	rover = world.Rovers[a]
+	rover.Charge = 0
+	world.Rovers[a] = rover
+
+	// Try and recharge, should fail
+	_, err = world.RoverRecharge(a)
+	assert.NoError(t, err)
+	assert.Equal(t, 0, world.Rovers[a].Charge)
+
+	// Loop for half the day
+	for i := 0; i < world.TicksPerDay/2; i++ {
+		assert.False(t, world.Daytime())
+		world.Tick()
+	}
+}
+
+func TestWorld_Broadcast(t *testing.T) {
+	world := NewWorld(8)
+
+	a, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	b, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	// Warp rovers near to eachother
+	world.Atlas.SetObject(maths.Vector{X: 0, Y: 0}, Object{Type: roveapi.Object_ObjectUnknown})
+	world.Atlas.SetObject(maths.Vector{X: 1, Y: 0}, Object{Type: roveapi.Object_ObjectUnknown})
+	assert.NoError(t, world.WarpRover(a, maths.Vector{X: 0, Y: 0}))
+	assert.NoError(t, world.WarpRover(b, maths.Vector{X: 1, Y: 0}))
+
+	// Broadcast from a
+	assert.NoError(t, world.RoverBroadcast(a, []byte{'A', 'B', 'C'}))
+
+	// Check if b heard it
+	ra, err := world.GetRover(a)
+	assert.NoError(t, err)
+	assert.Equal(t, ra.MaximumCharge-1, ra.Charge, "A should have used a charge to broadcast")
+	assert.Contains(t, ra.Logs[len(ra.Logs)-1].Text, "ABC", "Rover B should have heard the broadcast")
+
+	// Check if a logged it
+	rb, err := world.GetRover(b)
+	assert.NoError(t, err)
+	assert.Contains(t, rb.Logs[len(rb.Logs)-1].Text, "ABC", "Rover A should have logged it's broadcast")
+
+	// Warp B outside of the range of A
+	world.Atlas.SetObject(maths.Vector{X: ra.Range, Y: 0}, Object{Type: roveapi.Object_ObjectUnknown})
+	assert.NoError(t, world.WarpRover(b, maths.Vector{X: ra.Range, Y: 0}))
+
+	// Broadcast from a again
+	assert.NoError(t, world.RoverBroadcast(a, []byte{'X', 'Y', 'Z'}))
+
+	// Check if b heard it
+	ra, err = world.GetRover(b)
+	assert.NoError(t, err)
+	assert.NotContains(t, ra.Logs[len(ra.Logs)-1].Text, "XYZ", "Rover B should not have heard the broadcast")
+
+	// Check if a logged it
+	rb, err = world.GetRover(a)
+	assert.NoError(t, err)
+	assert.Contains(t, rb.Logs[len(rb.Logs)-1].Text, "XYZ", "Rover A should have logged it's broadcast")
+
+	// Warp B outside of the range of A
+	world.Atlas.SetObject(maths.Vector{X: ra.Range + 1, Y: 0}, Object{Type: roveapi.Object_ObjectUnknown})
+	assert.NoError(t, world.WarpRover(b, maths.Vector{X: ra.Range + 1, Y: 0}))
+
+	// Broadcast from a again
+	assert.NoError(t, world.RoverBroadcast(a, []byte{'H', 'J', 'K'}))
+
+	// Check if b heard it
+	ra, err = world.GetRover(b)
+	assert.NoError(t, err)
+	assert.NotContains(t, ra.Logs[len(ra.Logs)-1].Text, "HJK", "Rover B should have heard the broadcast")
+
+	// Check if a logged it
+	rb, err = world.GetRover(a)
+	assert.NoError(t, err)
+	assert.Contains(t, rb.Logs[len(rb.Logs)-1].Text, "HJK", "Rover A should have logged it's broadcast")
+}
+
+func TestWorld_Sailing(t *testing.T) {
+	world := NewWorld(8)
+	world.Tick()                       // One initial tick to set the wind direction the first time
+	world.Wind = roveapi.Bearing_North // Set the wind direction to north
+
+	name, err := world.SpawnRover("")
+	assert.NoError(t, err)
+
+	// Warp the rover to 0,0 after clearing it
+	world.Atlas.SetObject(maths.Vector{X: 0, Y: 0}, Object{Type: roveapi.Object_ObjectUnknown})
+	assert.NoError(t, world.WarpRover(name, maths.Vector{X: 0, Y: 0}))
+
+	s, err := world.RoverToggle(name)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.SailPosition_CatchingWind, s)
+
+	b, err := world.RoverTurn(name, roveapi.Bearing_North)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.Bearing_North, b)
+
+	// Clear the space to the north
+	world.Atlas.SetObject(maths.Vector{X: 0, Y: 1}, Object{Type: roveapi.Object_ObjectUnknown})
+
+	// Tick the world and check we've moved not moved
+	world.Tick()
+	info, err := world.GetRover(name)
+	assert.NoError(t, err)
+	assert.Equal(t, maths.Vector{Y: 0}, info.Pos)
+
+	// Loop a few more times
+	for i := 0; i < ticksPerNormalMove-2; i++ {
+		world.Tick()
+		info, err := world.GetRover(name)
+		assert.NoError(t, err)
+		assert.Equal(t, maths.Vector{Y: 0}, info.Pos)
+	}
+
+	// Now check we've moved (after the TicksPerNormalMove number of ticks)
+	world.Tick()
+	info, err = world.GetRover(name)
+	assert.NoError(t, err)
+	assert.Equal(t, maths.Vector{Y: 1}, info.Pos)
+
+	// Reset the world ticks back to stop any wind changes etc.
+	world.CurrentTicks = 1
+
+	// Face the rover south, into the wind
+	b, err = world.RoverTurn(name, roveapi.Bearing_South)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.Bearing_South, b)
+
+	// Tick a bunch, we should never move
+	for i := 0; i < ticksPerNormalMove*2; i++ {
+		world.Tick()
+		info, err := world.GetRover(name)
+		assert.NoError(t, err)
+		assert.Equal(t, maths.Vector{Y: 1}, info.Pos)
+	}
+
+	// Reset the world ticks back to stop any wind changes etc.
+	world.CurrentTicks = 1
+	world.Wind = roveapi.Bearing_SouthEast // Set up a south easternly wind
+
+	// Turn the rover perpendicular
+	b, err = world.RoverTurn(name, roveapi.Bearing_NorthEast)
+	assert.NoError(t, err)
+	assert.Equal(t, roveapi.Bearing_NorthEast, b)
+
+	// Clear a space
+	world.Atlas.SetObject(maths.Vector{X: 1, Y: 2}, Object{Type: roveapi.Object_ObjectUnknown})
+
+	// Now check we've moved immediately
+	world.Tick()
+	info, err = world.GetRover(name)
+	assert.NoError(t, err)
+	assert.Equal(t, maths.Vector{X: 1, Y: 2}, info.Pos)
+}

pkg/rove/worldgen.go

@@ -0,0 +1,70 @@
+package rove
+
+import (
+	"github.com/mdiluz/rove/pkg/maths"
+	"github.com/mdiluz/rove/proto/roveapi"
+	"github.com/ojrac/opensimplex-go"
+)
+
+// WorldGen describes a world gen algorythm
+type WorldGen interface {
+	// GetTile generates a tile for a location
+	GetTile(v maths.Vector) roveapi.Tile
+
+	// GetObject generates an object for a location
+	GetObject(v maths.Vector) Object
+}
+
+// NoiseWorldGen returns a noise based world generator
+type NoiseWorldGen struct {
+	// noise describes the noise function
+	noise opensimplex.Noise
+}
+
+// NewNoiseWorldGen creates a new noise based world generator
+func NewNoiseWorldGen(seed int64) WorldGen {
+	return &NoiseWorldGen{
+		noise: opensimplex.New(seed),
+	}
+}
+
+const (
+	terrainNoiseScale = 15
+	rockNoiseScale    = 3
+	partsNoiseScale   = 2
+)
+
+// GetTile returns the chosen tile at a location
+func (g *NoiseWorldGen) GetTile(v maths.Vector) roveapi.Tile {
+	t := g.noise.Eval2(float64(v.X)/terrainNoiseScale, float64(v.Y)/terrainNoiseScale)
+	switch {
+	case t > 0.5:
+		return roveapi.Tile_Gravel
+	case t > 0.05:
+		return roveapi.Tile_Sand
+	default:
+		return roveapi.Tile_Rock
+	}
+}
+
+// GetObject returns the chosen object at a location
+func (g *NoiseWorldGen) GetObject(v maths.Vector) (obj Object) {
+	r := g.noise.Eval2(float64(v.X)/rockNoiseScale, float64(v.Y)/rockNoiseScale)
+	switch {
+	// Prioritise rocks
+	case r > 0.6:
+		obj.Type = roveapi.Object_RockLarge
+	case r > 0.5:
+		obj.Type = roveapi.Object_RockSmall
+
+	default:
+		// Otherwise, try some rover parts
+		p := g.noise.Eval2(float64(v.X)/partsNoiseScale, float64(v.Y)/partsNoiseScale)
+		switch {
+		case p > 0.7:
+			obj.Type = roveapi.Object_RoverParts
+		}
+	}
+
+	return obj
+}

pkg/server/routes.go

@@ -1,235 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-
-	"github.com/google/uuid"
-	"github.com/mdiluz/rove/pkg/rove"
-	"github.com/mdiluz/rove/pkg/version"
-)
-
-// Handler describes a function that handles any incoming request and can respond
-type Handler func(*Server, map[string]string, io.ReadCloser, io.Writer) (interface{}, error)
-
-// Route defines the information for a single path->function route
-type Route struct {
-	path    string
-	method  string
-	handler Handler
-}
-
-// Routes is an array of all the Routes
-var Routes = []Route{
-	{
-		path:    "/status",
-		method:  http.MethodGet,
-		handler: HandleStatus,
-	},
-	{
-		path:    "/register",
-		method:  http.MethodPost,
-		handler: HandleRegister,
-	},
-	{
-		path:    "/{account}/spawn",
-		method:  http.MethodPost,
-		handler: HandleSpawn,
-	},
-	{
-		path:    "/{account}/command",
-		method:  http.MethodPost,
-		handler: HandleCommand,
-	},
-	{
-		path:    "/{account}/radar",
-		method:  http.MethodGet,
-		handler: HandleRadar,
-	},
-	{
-		path:    "/{account}/rover",
-		method:  http.MethodGet,
-		handler: HandleRover,
-	},
-}
-
-// HandleStatus handles the /status request
-func HandleStatus(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer) (interface{}, error) {
-
-	// Simply return the current server status
-	response := rove.StatusResponse{
-		Ready:   true,
-		Version: version.Version,
-		Tick:    s.tick,
-	}
-
-	// If there's a schedule, respond with it
-	if len(s.schedule.Entries()) > 0 {
-		response.NextTick = s.schedule.Entries()[0].Next.Format("15:04:05")
-	}
-
-	return response, nil
-}
-
-// HandleRegister handles /register endpoint
-func HandleRegister(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer) (interface{}, error) {
-	var response = rove.RegisterResponse{
-		Success: false,
-	}
-
-	// Decode the registration info, verify it and register the account
-	var data rove.RegisterData
-	err := json.NewDecoder(b).Decode(&data)
-	if err != nil {
-		fmt.Printf("Failed to decode json: %s\n", err)
-		response.Error = err.Error()
-
-	} else if len(data.Name) == 0 {
-		response.Error = "Cannot register empty name"
-
-	} else if acc, err := s.accountant.RegisterAccount(data.Name); err != nil {
-		response.Error = err.Error()
-
-	} else if err := s.SaveAll(); err != nil {
-		response.Error = fmt.Sprintf("Internal server error when saving accounts: %s", err)
-
-	} else {
-		// Save out the new accounts
-		response.Id = acc.Id.String()
-		response.Success = true
-	}
-
-	fmt.Printf("register response:%+v\n", response)
-	return response, nil
-}
-
-// HandleSpawn will spawn the player entity for the associated account
-func HandleSpawn(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer) (interface{}, error) {
-	var response = rove.SpawnResponse{
-		Success: false,
-	}
-
-	id := vars["account"]
-
-	// Decode the spawn info, verify it and spawn the rover for this account
-	var data rove.SpawnData
-	if err := json.NewDecoder(b).Decode(&data); err != nil {
-		fmt.Printf("Failed to decode json: %s\n", err)
-		response.Error = err.Error()
-
-	} else if len(id) == 0 {
-		response.Error = "No account ID provided"
-
-	} else if id, err := uuid.Parse(id); err != nil {
-		response.Error = "Provided account ID was invalid"
-
-	} else if attribs, _, err := s.SpawnRoverForAccount(id); err != nil {
-		response.Error = err.Error()
-
-	} else if err := s.SaveWorld(); err != nil {
-		response.Error = fmt.Sprintf("Internal server error when saving world: %s", err)
-
-	} else {
-		response.Success = true
-		response.Attributes = attribs
-	}
-
-	fmt.Printf("spawn response \taccount:%s\tresponse:%+v\n", id, response)
-	return response, nil
-}
-
-// HandleSpawn will spawn the player entity for the associated account
-func HandleCommand(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer) (interface{}, error) {
-	var response = rove.CommandResponse{
-		Success: false,
-	}
-
-	id := vars["account"]
-
-	// Decode the commands, verify them and the account, and execute the commands
-	var data rove.CommandData
-	if err := json.NewDecoder(b).Decode(&data); err != nil {
-		fmt.Printf("Failed to decode json: %s\n", err)
-		response.Error = err.Error()
-
-	} else if len(id) == 0 {
-		response.Error = "No account ID provided"
-
-	} else if id, err := uuid.Parse(id); err != nil {
-		response.Error = fmt.Sprintf("Provided account ID was invalid: %s", err)
-
-	} else if inst, err := s.accountant.GetRover(id); err != nil {
-		response.Error = fmt.Sprintf("Provided account has no rover: %s", err)
-
-	} else if err := s.world.Enqueue(inst, data.Commands...); err != nil {
-		response.Error = fmt.Sprintf("Failed to execute commands: %s", err)
-
-	} else {
-		response.Success = true
-	}
-
-	fmt.Printf("command response \taccount:%s\tresponse:%+v\n", id, response)
-	return response, nil
-}
-
-// HandleRadar handles the radar request
-func HandleRadar(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer) (interface{}, error) {
-	var response = rove.RadarResponse{
-		Success: false,
-	}
-
-	id := vars["account"]
-	if len(id) == 0 {
-		response.Error = "No account ID provided"
-
-	} else if id, err := uuid.Parse(id); err != nil {
-		response.Error = fmt.Sprintf("Provided account ID was invalid: %s", err)
-
-	} else if inst, err := s.accountant.GetRover(id); err != nil {
-		response.Error = fmt.Sprintf("Provided account has no rover: %s", err)
-
-	} else if attrib, err := s.world.RoverAttributes(inst); err != nil {
-		response.Error = fmt.Sprintf("Error getting rover attributes: %s", err)
-
-	} else if radar, err := s.world.RadarFromRover(inst); err != nil {
-		response.Error = fmt.Sprintf("Error getting radar from rover: %s", err)
-
-	} else {
-		response.Tiles = radar
-		response.Range = attrib.Range
-		response.Success = true
-	}
-
-	fmt.Printf("radar response \taccount:%s\tresponse:%+v\n", id, response)
-	return response, nil
-}
-
-// HandleRover handles the rover request
-func HandleRover(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer) (interface{}, error) {
-	var response = rove.RoverResponse{
-		Success: false,
-	}
-
-	id := vars["account"]
-	if len(id) == 0 {
-		response.Error = "No account ID provided"
-
-	} else if id, err := uuid.Parse(id); err != nil {
-		response.Error = fmt.Sprintf("Provided account ID was invalid: %s", err)
-
-	} else if inst, err := s.accountant.GetRover(id); err != nil {
-		response.Error = fmt.Sprintf("Provided account has no rover: %s", err)
-
-	} else if attribs, err := s.world.RoverAttributes(inst); err != nil {
-		response.Error = fmt.Sprintf("Error getting radar from rover: %s", err)
-
-	} else {
-		response.Attributes = attribs
-		response.Success = true
-	}
-
-	fmt.Printf("rover response \taccount:%s\tresponse:%+v\n", id, response)
-	return response, nil
-}

pkg/server/routes_test.go

@@ -1,193 +0,0 @@
-package server
-
-import (
-	"bytes"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"path"
-	"testing"
-
-	"github.com/mdiluz/rove/pkg/game"
-	"github.com/mdiluz/rove/pkg/rove"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestHandleStatus(t *testing.T) {
-
-	request, _ := http.NewRequest(http.MethodGet, "/status", nil)
-	response := httptest.NewRecorder()
-
-	s := NewServer()
-	s.Initialise()
-	s.router.ServeHTTP(response, request)
-	assert.Equal(t, http.StatusOK, response.Code)
-
-	var status rove.StatusResponse
-	json.NewDecoder(response.Body).Decode(&status)
-
-	if status.Ready != true {
-		t.Errorf("got false for /status")
-	}
-
-	if len(status.Version) == 0 {
-		t.Errorf("got empty version info")
-	}
-}
-
-func TestHandleRegister(t *testing.T) {
-	data := rove.RegisterData{Name: "one"}
-	b, err := json.Marshal(data)
-	if err != nil {
-		t.Error(err)
-	}
-
-	request, _ := http.NewRequest(http.MethodPost, "/register", bytes.NewReader(b))
-	response := httptest.NewRecorder()
-
-	s := NewServer()
-	s.Initialise()
-	s.router.ServeHTTP(response, request)
-	assert.Equal(t, http.StatusOK, response.Code)
-
-	var status rove.RegisterResponse
-	json.NewDecoder(response.Body).Decode(&status)
-
-	if status.Success != true {
-		t.Errorf("got false for /register")
-	}
-}
-
-func TestHandleSpawn(t *testing.T) {
-	s := NewServer()
-	s.Initialise()
-	a, err := s.accountant.RegisterAccount("test")
-	assert.NoError(t, err, "Error registering account")
-	data := rove.SpawnData{}
-
-	b, err := json.Marshal(data)
-	assert.NoError(t, err, "Error marshalling data")
-
-	request, _ := http.NewRequest(http.MethodPost, path.Join("/", a.Id.String(), "/spawn"), bytes.NewReader(b))
-	response := httptest.NewRecorder()
-
-	s.router.ServeHTTP(response, request)
-	assert.Equal(t, http.StatusOK, response.Code)
-
-	var status rove.SpawnResponse
-	json.NewDecoder(response.Body).Decode(&status)
-	assert.Equal(t, http.StatusOK, response.Code)
-
-	if status.Success != true {
-		t.Errorf("got false for /spawn: %s", status.Error)
-	}
-}
-
-func TestHandleCommand(t *testing.T) {
-	s := NewServer()
-	s.Initialise()
-	a, err := s.accountant.RegisterAccount("test")
-	assert.NoError(t, err, "Error registering account")
-
-	// Spawn the rover rover for the account
-	_, inst, err := s.SpawnRoverForAccount(a.Id)
-
-	attribs, err := s.world.RoverAttributes(inst)
-	assert.NoError(t, err, "Couldn't get rover position")
-
-	data := rove.CommandData{
-		Commands: []game.Command{
-			{
-				Command:  game.CommandMove,
-				Bearing:  "N",
-				Duration: 1,
-			},
-		},
-	}
-
-	b, err := json.Marshal(data)
-	assert.NoError(t, err, "Error marshalling data")
-
-	request, _ := http.NewRequest(http.MethodPost, path.Join("/", a.Id.String(), "/command"), bytes.NewReader(b))
-	response := httptest.NewRecorder()
-
-	s.router.ServeHTTP(response, request)
-	assert.Equal(t, http.StatusOK, response.Code)
-
-	var status rove.CommandResponse
-	json.NewDecoder(response.Body).Decode(&status)
-
-	if status.Success != true {
-		t.Errorf("got false for /command: %s", status.Error)
-	}
-
-	attrib, err := s.world.RoverAttributes(inst)
-	assert.NoError(t, err, "Couldn't get rover attribs")
-
-	// Tick the command queues to progress the move command
-	s.world.ExecuteCommandQueues()
-
-	attribs2, err := s.world.RoverAttributes(inst)
-	assert.NoError(t, err, "Couldn't get rover position")
-	attribs.Pos.Add(game.Vector{X: 0.0, Y: attrib.Speed * 1}) // Should have moved north by the speed and duration
-	assert.Equal(t, attribs.Pos, attribs2.Pos, "Rover should have moved by bearing")
-}
-
-func TestHandleRadar(t *testing.T) {
-	s := NewServer()
-	s.Initialise()
-	a, err := s.accountant.RegisterAccount("test")
-	assert.NoError(t, err, "Error registering account")
-
-	// Spawn the rover rover for the account
-	_, id, err := s.SpawnRoverForAccount(a.Id)
-	assert.NoError(t, err)
-
-	// Warp this rover to 0
-	assert.NoError(t, s.world.WarpRover(id, game.Vector{}))
-
-	// Set a tile to wall below this rover
-	wallPos := game.Vector{X: 0, Y: -1}
-	assert.NoError(t, s.world.Atlas.SetTile(wallPos, game.TileWall))
-
-	request, _ := http.NewRequest(http.MethodGet, path.Join("/", a.Id.String(), "/radar"), nil)
-	response := httptest.NewRecorder()
-
-	s.router.ServeHTTP(response, request)
-	assert.Equal(t, http.StatusOK, response.Code)
-
-	var status rove.RadarResponse
-	json.NewDecoder(response.Body).Decode(&status)
-
-	if status.Success != true {
-		t.Errorf("got false for /radar: %s", status.Error)
-	}
-
-	assert.Equal(t, game.TileRover, status.Tiles[len(status.Tiles)/2])
-}
-
-func TestHandleRover(t *testing.T) {
-	s := NewServer()
-	s.Initialise()
-	a, err := s.accountant.RegisterAccount("test")
-	assert.NoError(t, err, "Error registering account")
-
-	// Spawn one rover for the account
-	attribs, _, err := s.SpawnRoverForAccount(a.Id)
-	assert.NoError(t, err)
-
-	request, _ := http.NewRequest(http.MethodGet, path.Join("/", a.Id.String(), "/rover"), nil)
-	response := httptest.NewRecorder()
-
-	s.router.ServeHTTP(response, request)
-	assert.Equal(t, http.StatusOK, response.Code)
-
-	var status rove.RoverResponse
-	json.NewDecoder(response.Body).Decode(&status)
-
-	if status.Success != true {
-		t.Errorf("got false for /rover: %s", status.Error)
-	} else if attribs != status.Attributes {
-		t.Errorf("Missmatched attributes: %+v, !=%+v", attribs, status.Attributes)
-	}
-}

pkg/server/server.go

@@ -1,301 +0,0 @@
-package server
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/gorilla/mux"
-	"github.com/mdiluz/rove/pkg/accounts"
-	"github.com/mdiluz/rove/pkg/game"
-	"github.com/mdiluz/rove/pkg/persistence"
-	"github.com/robfig/cron"
-)
-
-const (
-	// PersistentData will allow the server to load and save it's state
-	PersistentData = iota
-
-	// EphemeralData will let the server neither load or save out any of it's data
-	EphemeralData
-)
-
-// Server contains the relevant data to run a game server
-type Server struct {
-
-	// Internal state
-	accountant *accounts.Accountant
-	world      *game.World
-
-	// HTTP server
-	listener net.Listener
-	server   *http.Server
-	router   *mux.Router
-
-	// Config settings
-	address     string
-	persistence int
-	tick        int
-
-	// sync point for sub-threads
-	sync sync.WaitGroup
-
-	// cron schedule for world ticks
-	schedule *cron.Cron
-}
-
-// ServerOption defines a server creation option
-type ServerOption func(s *Server)
-
-// OptionAddress sets the server address for hosting
-func OptionAddress(address string) ServerOption {
-	return func(s *Server) {
-		s.address = address
-	}
-}
-
-// OptionPersistentData sets the server data to be persistent
-func OptionPersistentData() ServerOption {
-	return func(s *Server) {
-		s.persistence = PersistentData
-	}
-}
-
-// OptionTick defines the number of minutes per tick
-// 0 means no automatic server tick
-func OptionTick(minutes int) ServerOption {
-	return func(s *Server) {
-		s.tick = minutes
-	}
-}
-
-// NewServer sets up a new server
-func NewServer(opts ...ServerOption) *Server {
-
-	router := mux.NewRouter().StrictSlash(true)
-
-	// Set up the default server
-	s := &Server{
-		address:     "",
-		persistence: EphemeralData,
-		router:      router,
-		schedule:    cron.New(),
-	}
-
-	// Apply all options
-	for _, o := range opts {
-		o(s)
-	}
-
-	// Set up the server object
-	s.server = &http.Server{Addr: s.address, Handler: s.router}
-
-	// Create the accountant
-	s.accountant = accounts.NewAccountant()
-	s.world = game.NewWorld()
-
-	return s
-}
-
-// Initialise sets up internal state ready to serve
-func (s *Server) Initialise() (err error) {
-
-	// Add to our sync
-	s.sync.Add(1)
-
-	// Spawn a border on the default world
-	if err := s.world.SpawnWorld(); err != nil {
-		return err
-	}
-
-	// Load the accounts if requested
-	if err := s.LoadAll(); err != nil {
-		return err
-	}
-
-	// Set up the handlers
-	for _, route := range Routes {
-		s.router.HandleFunc(route.path, s.wrapHandler(route.method, route.handler))
-	}
-
-	// Start the listen
-	if s.listener, err = net.Listen("tcp", s.server.Addr); err != nil {
-		return err
-	}
-
-	s.address = s.listener.Addr().String()
-	return nil
-}
-
-// Addr will return the server address set after the listen
-func (s *Server) Addr() string {
-	return s.address
-}
-
-// Run executes the server
-func (s *Server) Run() {
-	defer s.sync.Done()
-
-	// Set up the schedule if requested
-	if s.tick != 0 {
-		if err := s.schedule.AddFunc(fmt.Sprintf("0 */%d * * *", s.tick), func() {
-			// Ensure we don't quit during this function
-			s.sync.Add(1)
-			defer s.sync.Done()
-
-			fmt.Println("Executing server tick")
-
-			// Run the command queues
-			s.world.ExecuteCommandQueues()
-
-			// Save out the new world state
-			s.SaveWorld()
-		}); err != nil {
-			log.Fatal(err)
-		}
-		s.schedule.Start()
-		fmt.Printf("First server tick scheduled for %s\n", s.schedule.Entries()[0].Next.Format("15:04:05"))
-	}
-
-	// Serve the http requests
-	if err := s.server.Serve(s.listener); err != nil && err != http.ErrServerClosed {
-		log.Fatal(err)
-	}
-}
-
-// Stop will stop the current server
-func (s *Server) Stop() error {
-	// Stop the cron
-	s.schedule.Stop()
-
-	// Try and shut down the http server
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	if err := s.server.Shutdown(ctx); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Close waits until the server is finished and closes up shop
-func (s *Server) Close() error {
-	// Wait until the server has shut down
-	s.sync.Wait()
-
-	// Save and return
-	return s.SaveAll()
-}
-
-// Close waits until the server is finished and closes up shop
-func (s *Server) StopAndClose() error {
-	// Stop the server
-	if err := s.Stop(); err != nil {
-		return err
-	}
-
-	// Close and return
-	return s.Close()
-}
-
-// SaveWorld will save out the world file
-func (s *Server) SaveWorld() error {
-	if s.persistence == PersistentData {
-		s.world.RLock()
-		defer s.world.RUnlock()
-		if err := persistence.SaveAll("world", s.world); err != nil {
-			return fmt.Errorf("failed to save out persistent data: %s", err)
-		}
-	}
-	return nil
-}
-
-// SaveAccounts will save out the accounts file
-func (s *Server) SaveAccounts() error {
-	if s.persistence == PersistentData {
-		if err := persistence.SaveAll("accounts", s.accountant); err != nil {
-			return fmt.Errorf("failed to save out persistent data: %s", err)
-		}
-	}
-	return nil
-}
-
-// SaveAll will save out all server files
-func (s *Server) SaveAll() error {
-	// Save the accounts if requested
-	if s.persistence == PersistentData {
-		s.world.RLock()
-		defer s.world.RUnlock()
-
-		if err := persistence.SaveAll("accounts", s.accountant, "world", s.world); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// LoadAll will load all persistent data
-func (s *Server) LoadAll() error {
-	if s.persistence == PersistentData {
-		s.world.Lock()
-		defer s.world.Unlock()
-		if err := persistence.LoadAll("accounts", &s.accountant, "world", &s.world); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// wrapHandler wraps a request handler in http checks
-func (s *Server) wrapHandler(method string, handler Handler) func(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-		// Log the request
-		fmt.Printf("%s\t%s\n", r.Method, r.RequestURI)
-
-		vars := mux.Vars(r)
-
-		// Verify the method, call the handler, and encode the return
-		if r.Method != method {
-			w.WriteHeader(http.StatusMethodNotAllowed)
-
-		} else if val, err := handler(s, vars, r.Body, w); err != nil {
-			fmt.Printf("Failed to handle http request: %s", err)
-			w.WriteHeader(http.StatusInternalServerError)
-
-		} else if err := json.NewEncoder(w).Encode(val); err != nil {
-			fmt.Printf("Failed to encode reply to json: %s", err)
-			w.WriteHeader(http.StatusInternalServerError)
-
-		} else {
-			w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-		}
-	}
-}
-
-// SpawnRoverForAccount spawns the rover rover for an account
-func (s *Server) SpawnRoverForAccount(accountid uuid.UUID) (game.RoverAttributes, uuid.UUID, error) {
-	if inst, err := s.world.SpawnRover(); err != nil {
-		return game.RoverAttributes{}, uuid.UUID{}, err
-
-	} else if attribs, err := s.world.RoverAttributes(inst); err != nil {
-		return game.RoverAttributes{}, uuid.UUID{}, fmt.Errorf("No attributes found for created rover: %s", err)
-
-	} else {
-		if err := s.accountant.AssignRover(accountid, inst); err != nil {
-			// Try and clear up the rover
-			if err := s.world.DestroyRover(inst); err != nil {
-				fmt.Printf("Failed to destroy rover after failed rover assign: %s", err)
-			}
-
-			return game.RoverAttributes{}, uuid.UUID{}, err
-		} else {
-			return attribs, inst, nil
-		}
-	}
-}

pkg/version/version.go

@@ -1,3 +1,4 @@
 package version
 
+// Version represents a version to be overrided with -ldflags
 var Version = "undefined"

proto/roveapi/roveapi.proto

@@ -0,0 +1,322 @@
+syntax = "proto3";
+
+// Rove
+//
+// Rove is an asychronous nomadic game about exploring a planet as part of a
+// loose community
+package roveapi;
+option go_package = "github.com/mdiluz/rove/proto/roveapi";
+
+// The Rove server hosts a single game session and world with multiple players
+service Rove {
+  // Server status
+  // Responds with various details about the current server status
+  rpc ServerStatus(ServerStatusRequest) returns (ServerStatusResponse) {}
+
+  // Register an account
+  // Tries to register an account with the given name
+  rpc Register(RegisterRequest) returns (RegisterResponse) {}
+
+  // Send commands to rover
+  // Sending commands to this endpoint will queue them to be executed during the
+  // following ticks, in the order sent. Commands sent within the same tick will
+  // overwrite until the tick has finished and the commands are queued
+  rpc Command(CommandRequest) returns (CommandResponse) {}
+
+  // Get radar information
+  // Gets the radar output for the given rover
+  rpc Radar(RadarRequest) returns (RadarResponse) {}
+
+  // Get rover information
+  // Gets information for the account's rover
+  rpc Status(StatusRequest) returns (StatusResponse) {}
+}
+
+//
+// ServerStatus
+//
+
+// ServerStatusRequest is an empty placeholder
+message ServerStatusRequest {}
+
+// ServerStatusResponse is a response with useful server information
+message ServerStatusResponse {
+  // The version of the server in v{major}.{minor}-{delta}-{sha} form
+  string version = 1;
+
+  // Whether the server is ready to accept requests
+  bool ready = 2;
+
+  // The tick rate of the server in minutes (how many minutes per tick)
+  int32 tickRate = 3;
+
+  // The current tick of the server
+  int32 currentTick = 4;
+
+  // The time the next tick will occur
+  string next_tick = 5;
+}
+
+//
+// Register
+//
+
+// RegisterRequest contains data to register an account
+message RegisterRequest {
+  // The desired account name
+  string name = 1;
+}
+
+// Account describes a registered account
+message Account {
+  // The account name
+  string name = 1;
+
+  // The account secret value, given when creating the account
+  string secret = 2;
+}
+
+// RegisterResponse is the response given to registering an account
+message RegisterResponse {
+  // The registered account information
+  Account account = 1;
+}
+
+//
+// Command
+//
+
+// CommandType defines the type of a command to give to the rover
+enum CommandType {
+  none = 0;
+  // Waits before performing the next command
+  wait = 1;
+  // Toggles the sails, either catching the wind, or charging from the sun
+  toggle = 2;
+  // Turns the rover in the specified bearing (requires bearing)
+  turn = 3;
+  // Stashes item at current location in rover inventory
+  stash = 4;
+  // Repairs the rover using an inventory object
+  repair = 5;
+  // Broadcasts a message to nearby rovers (requires data)
+  broadcast = 6;
+  // Salvages a neighboring dormant rover for parts
+  salvage = 7;
+  // Transfers remote control into dormant rover
+  transfer = 8;
+  // Upgrades a chosen rover specification using 5 rover parts
+  upgrade = 9;
+}
+
+// Bearing represents a compass direction
+enum Bearing {
+  // BearingUnknown an unknown invalid bearing
+  BearingUnknown = 0;
+  North = 1;
+  NorthEast = 2;
+  East = 3;
+  SouthEast = 4;
+  South = 5;
+  SouthWest = 6;
+  West = 7;
+  NorthWest = 8;
+}
+
+// Describes the type of upgrade
+enum RoverUpgrade {
+  RoverUpgradeUnknown = 0;
+  Range = 1;
+  Capacity = 2;
+  MaximumIntegrity = 3;
+  MaximumCharge = 4;
+}
+
+// Command is a single command for a rover
+message Command {
+  // The command type
+  CommandType command = 1;
+
+  // The number of times to repeat the command after the first
+  int32 repeat = 2;
+
+  // broadcast - a simple message, must be composed of up to 3 printable ASCII
+  // glyphs (32-126)
+  bytes data = 3;
+
+  // move - the bearing for the rover to turn to
+  Bearing bearing = 4;
+
+  // upgrade - the upgrade to apply to the rover
+  RoverUpgrade upgrade = 5;
+}
+
+// CommandRequest describes a set of commands to be requested for the rover
+message CommandRequest {
+  // The account to execute these commands
+  Account account = 1;
+
+  // The set of desired commands
+  repeated Command commands = 2;
+}
+
+// CommandResponse is an empty placeholder
+message CommandResponse {}
+
+//
+// Radar
+//
+
+// Types of objects
+enum Object {
+  // ObjectUnknown represents no object at all
+  ObjectUnknown = 0;
+
+  // RoverLive represents a live rover
+  RoverLive = 1;
+
+  // RoverDormant describes a dormant rover
+  RoverDormant = 2;
+
+  // RockSmall is a small stashable rock
+  RockSmall = 3;
+
+  // RockLarge is a large blocking rock
+  RockLarge = 4;
+
+  // RoverParts is one unit of rover parts, used for repairing and fixing the
+  // rover
+  RoverParts = 5;
+}
+
+enum Tile {
+  // TileUnknown is a keyword for nothing
+  TileUnknown = 0;
+
+  // Rock is solid rock ground
+  Rock = 1;
+
+  // Gravel is loose rocks
+  Gravel = 2;
+
+  // Sand is sand
+  Sand = 3;
+}
+
+// RadarRequest is the data needed to request the radar for a rover
+message RadarRequest {
+  // The account for this request
+  Account account = 1;
+}
+
+// RadarResponse describes radar information
+message RadarResponse {
+  // The range in tiles from the rover of the radar data
+  int32 range = 1;
+
+  // A 1D array representing range*2 + 1 squared set of tiles, origin bottom
+  // left and in row->column order
+  repeated Tile tiles = 2;
+
+  // A similar array to the tile array, but containing objects
+  repeated Object objects = 3;
+}
+
+//
+// Status
+//
+
+// StatusRequest is information needed to request rover status
+message StatusRequest {
+  // The account for this request
+  Account account = 1;
+}
+
+// Log is a single log item
+message Log {
+  // The unix timestamp of the log
+  string time = 1;
+
+  // The text of the log
+  string text = 2;
+}
+
+// Vector describes a point or vector in 2D space
+message Vector {
+  int32 x = 1;
+  int32 y = 2;
+}
+
+// SailPosition represents the position of the sola sail
+enum SailPosition {
+  UnknownSailPosition = 0;
+
+  // CatchingWind means the sail is catching the wind and moving the rover
+  CatchingWind = 1;
+
+  // SolarCharging means the sail is facing the sun and charging
+  SolarCharging = 2;
+}
+
+message RoverSpecifications {
+
+  // The name of the rover
+  string name = 1;
+
+  // The range of this rover's radar and broadcasting
+  int32 range = 2;
+
+  // The capacity of the inventory
+  int32 capacity = 3;
+
+  // The maximum health of the rover
+  int32 maximumIntegrity = 4;
+
+  // The max energy the rover can store
+  int32 maximumCharge = 5;
+}
+
+message RoverStatus {
+
+  // The current direction of the rover
+  Bearing bearing = 1;
+
+  // The current position of the sails
+  SailPosition sailPosition = 2;
+
+  // The items in the rover inventory
+  bytes inventory = 3;
+
+  // The current health of the rover
+  int32 integrity = 4;
+
+  // The energy stored in the rover
+  int32 charge = 5;
+
+  // The set of currently queued commands
+  repeated Command queuedCommands = 6;
+}
+
+message RoverReadings {
+  // Position of the rover in world coordinates
+  Vector position = 1;
+
+  // The current wind direction
+  Bearing wind = 2;
+
+  // The most recent logs
+  repeated Log logs = 3;
+}
+
+// StatusResponse is the response given to a status request
+message StatusResponse {
+
+  // The static rover information
+  RoverSpecifications spec = 1;
+
+  // Current rover status
+  RoverStatus status = 2;
+
+  // Current rover readings
+  RoverReadings readings = 3;
+}

script/wait-for-it.sh

@@ -0,0 +1,202 @@
+#!/usr/bin/env bash
+# The MIT License (MIT)
+# Copyright (c) 2016 Giles Hall
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+# of the Software, and to permit persons to whom the Software is furnished to do
+# so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# Use this script to test if a given TCP host/port are available
+
+WAITFORIT_cmdname=${0##*/}
+
+echoerr() { if [[ $WAITFORIT_QUIET -ne 1 ]]; then echo "$@" 1>&2; fi }
+
+usage()
+{
+    cat << USAGE >&2
+Usage:
+    $WAITFORIT_cmdname host:port [-s] [-t timeout] [-- command args]
+    -h HOST | --host=HOST       Host or IP under test
+    -p PORT | --port=PORT       TCP port under test
+                                Alternatively, you specify the host and port as host:port
+    -s | --strict               Only execute subcommand if the test succeeds
+    -q | --quiet                Don't output any status messages
+    -t TIMEOUT | --timeout=TIMEOUT
+                                Timeout in seconds, zero for no timeout
+    -- COMMAND ARGS             Execute command with args after the test finishes
+USAGE
+    exit 1
+}
+
+wait_for()
+{
+    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
+        echoerr "$WAITFORIT_cmdname: waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
+    else
+        echoerr "$WAITFORIT_cmdname: waiting for $WAITFORIT_HOST:$WAITFORIT_PORT without a timeout"
+    fi
+    WAITFORIT_start_ts=$(date +%s)
+    while :
+    do
+        if [[ $WAITFORIT_ISBUSY -eq 1 ]]; then
+            nc -z $WAITFORIT_HOST $WAITFORIT_PORT
+            WAITFORIT_result=$?
+        else
+            (echo > /dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT) >/dev/null 2>&1
+            WAITFORIT_result=$?
+        fi
+        if [[ $WAITFORIT_result -eq 0 ]]; then
+            WAITFORIT_end_ts=$(date +%s)
+            echoerr "$WAITFORIT_cmdname: $WAITFORIT_HOST:$WAITFORIT_PORT is available after $((WAITFORIT_end_ts - WAITFORIT_start_ts)) seconds"
+            break
+        fi
+        sleep 1
+    done
+    return $WAITFORIT_result
+}
+
+wait_for_wrapper()
+{
+    # In order to support SIGINT during timeout: http://unix.stackexchange.com/a/57692
+    if [[ $WAITFORIT_QUIET -eq 1 ]]; then
+        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --quiet --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
+    else
+        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
+    fi
+    WAITFORIT_PID=$!
+    trap "kill -INT -$WAITFORIT_PID" INT
+    wait $WAITFORIT_PID
+    WAITFORIT_RESULT=$?
+    if [[ $WAITFORIT_RESULT -ne 0 ]]; then
+        echoerr "$WAITFORIT_cmdname: timeout occurred after waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
+    fi
+    return $WAITFORIT_RESULT
+}
+
+# process arguments
+while [[ $# -gt 0 ]]
+do
+    case "$1" in
+        *:* )
+        WAITFORIT_hostport=(${1//:/ })
+        WAITFORIT_HOST=${WAITFORIT_hostport[0]}
+        WAITFORIT_PORT=${WAITFORIT_hostport[1]}
+        shift 1
+        ;;
+        --child)
+        WAITFORIT_CHILD=1
+        shift 1
+        ;;
+        -q | --quiet)
+        WAITFORIT_QUIET=1
+        shift 1
+        ;;
+        -s | --strict)
+        WAITFORIT_STRICT=1
+        shift 1
+        ;;
+        -h)
+        WAITFORIT_HOST="$2"
+        if [[ $WAITFORIT_HOST == "" ]]; then break; fi
+        shift 2
+        ;;
+        --host=*)
+        WAITFORIT_HOST="${1#*=}"
+        shift 1
+        ;;
+        -p)
+        WAITFORIT_PORT="$2"
+        if [[ $WAITFORIT_PORT == "" ]]; then break; fi
+        shift 2
+        ;;
+        --port=*)
+        WAITFORIT_PORT="${1#*=}"
+        shift 1
+        ;;
+        -t)
+        WAITFORIT_TIMEOUT="$2"
+        if [[ $WAITFORIT_TIMEOUT == "" ]]; then break; fi
+        shift 2
+        ;;
+        --timeout=*)
+        WAITFORIT_TIMEOUT="${1#*=}"
+        shift 1
+        ;;
+        --)
+        shift
+        WAITFORIT_CLI=("$@")
+        break
+        ;;
+        --help)
+        usage
+        ;;
+        *)
+        echoerr "Unknown argument: $1"
+        usage
+        ;;
+    esac
+done
+
+if [[ "$WAITFORIT_HOST" == "" || "$WAITFORIT_PORT" == "" ]]; then
+    echoerr "Error: you need to provide a host and port to test."
+    usage
+fi
+
+WAITFORIT_TIMEOUT=${WAITFORIT_TIMEOUT:-15}
+WAITFORIT_STRICT=${WAITFORIT_STRICT:-0}
+WAITFORIT_CHILD=${WAITFORIT_CHILD:-0}
+WAITFORIT_QUIET=${WAITFORIT_QUIET:-0}
+
+# Check to see if timeout is from busybox?
+WAITFORIT_TIMEOUT_PATH=$(type -p timeout)
+WAITFORIT_TIMEOUT_PATH=$(realpath $WAITFORIT_TIMEOUT_PATH 2>/dev/null || readlink -f $WAITFORIT_TIMEOUT_PATH)
+
+WAITFORIT_BUSYTIMEFLAG=""
+if [[ $WAITFORIT_TIMEOUT_PATH =~ "busybox" ]]; then
+    WAITFORIT_ISBUSY=1
+    # Check if busybox timeout uses -t flag
+    # (recent Alpine versions don't support -t anymore)
+    if timeout &>/dev/stdout | grep -q -e '-t '; then
+        WAITFORIT_BUSYTIMEFLAG="-t"
+    fi
+else
+    WAITFORIT_ISBUSY=0
+fi
+
+if [[ $WAITFORIT_CHILD -gt 0 ]]; then
+    wait_for
+    WAITFORIT_RESULT=$?
+    exit $WAITFORIT_RESULT
+else
+    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
+        wait_for_wrapper
+        WAITFORIT_RESULT=$?
+    else
+        wait_for
+        WAITFORIT_RESULT=$?
+    fi
+fi
+
+if [[ $WAITFORIT_CLI != "" ]]; then
+    if [[ $WAITFORIT_RESULT -ne 0 && $WAITFORIT_STRICT -eq 1 ]]; then
+        echoerr "$WAITFORIT_cmdname: strict mode, refusing to execute subprocess"
+        exit $WAITFORIT_RESULT
+    fi
+    exec "${WAITFORIT_CLI[@]}"
+else
+    exit $WAITFORIT_RESULT
+fi

snap/snapcraft.yaml

@@ -0,0 +1,50 @@
+name: rove
+title: Rove
+base: core20
+license: MIT
+architectures: [ amd64 ]
+icon: data/icon.svg
+summary: An asynchronous nomadic game about exploring as part of a loose community.
+# TODO: Add more to the description
+description: |
+  An asynchronous nomadic game about exploring as part of a loose community.
+confinement: strict
+adopt-info: go-rove
+
+apps:
+  rove:
+    command: bin/rove
+    plugs: 
+      - network
+    environment:
+      ROVE_USER_DATA: $SNAP_USER_DATA
+      
+  rove-server:
+    command: bin/rove-server
+    plugs:
+      - network
+      - network-bind
+    environment:
+      WORDS_FILE : "$SNAP/data/words_alpha.txt"
+      DATA_PATH : $SNAP_USER_DATA
+      
+parts:
+  go-rove:
+    plugin: go
+    source-type: local
+    source: .
+    build-packages:
+      - gcc-multilib
+    override-pull: |
+      snapcraftctl pull
+      version=$(git describe --always --long --dirty --tags)
+      sed -i "s/undefined/$version/" pkg/version/version.go
+      snapcraftctl set-version $version
+      git describe --exact-match --tags HEAD 2> /dev/null && snapcraftctl set-grade "stable" || snapcraftctl set-grade "devel"
+
+  copy-data:
+    plugin: dump
+    source-type: local
+    source: data
+    organize:
+      '*.txt' : data/

tools/tools.go

@@ -0,0 +1,9 @@
+// +build tools
+
+package tools
+
+import (
+	_ "github.com/golang/protobuf/protoc-gen-go"
+	_ "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway"
+	_ "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger"
+)