Some more map progress

2018-03-18 13:57:01 +00:00
parent 88acc05085
commit 2f02c7bbf3
5 changed files with 314 additions and 102 deletions
--- a/cmd/view-map/main.go
+++ b/cmd/view-map/main.go
@@ -5,6 +5,7 @@ import (
 	"log"
 	"math"
 	"os"
+	"path/filepath"
 	"time"

 	"github.com/faiface/pixel"
@@ -13,6 +14,7 @@ import (
 	"golang.org/x/image/colornames"

 	"ur.gs/chaos-gate/internal/maps"
+	"ur.gs/chaos-gate/internal/sets"
 )

 var (
@@ -24,6 +26,26 @@ var (
 	winY = flag.Int("win-y", 1024, "height of the view-map window")
 )

+type env struct {
+	gameMap *maps.GameMap
+	set     sets.MapSet
+}
+
+type runState struct {
+	env *env
+
+	autoUpdate bool
+	started    time.Time
+
+	cam    pixel.Matrix
+	camPos pixel.Vec
+
+	zoom float64
+
+	zIdx    int
+	cellIdx int
+}
+
 func main() {
 	flag.Parse()

@@ -37,23 +59,21 @@ func main() {
 		log.Fatalf("Couldn't load map file: %v", err)
 	}

+	setFile := filepath.Join(*gamePath, "Sets", gameMap.MapSetFilename())
+	log.Println(setFile)
+	mapSet, err := sets.LoadSet(setFile)
+	if err != nil {
+		log.Fatalf("Couldn't load set file %s: %v", setFile, err)
+	}
+
+	env := &env{gameMap: gameMap, set: mapSet}
+
 	// The main thread now belongs to pixelgl
-	pixelgl.Run(func() { run(gameMap) })
+	pixelgl.Run(func() { run(env) })
 }

-type runState struct {
-	redraw     bool
-	started    time.Time
-	autoUpdate bool
-	gameMap    *maps.GameMap
-
-	zoom float64
-
-	zIdx    int
-	cellIdx int
-}
-
-func run(gameMap *maps.GameMap) {
+func run(env *env) {
+	// WARE! 0,0 is the *bottom left* of the window
 	cfg := pixelgl.WindowConfig{
 		Title:  "View Map " + *mapFile,
 		Bounds: pixel.R(0, 0, float64(*winX), float64(*winY)),
@@ -66,74 +86,141 @@ func run(gameMap *maps.GameMap) {
 	}

 	state := &runState{
-		redraw:     true,
-		started:    time.Now(),
+		env:        env,
 		autoUpdate: true,
-		gameMap:    gameMap,
-		zoom:       1.0,
+
+		camPos: pixel.V(0, float64(-*winY)),
+
+		zoom: 8.0,
 	}

 	for !win.Closed() {
-		if state.redraw {
-			log.Printf("z=%d cellIdx=%d", state.zIdx, state.cellIdx)
-			presentFull(win, state)
-		}
-
+		oldState := *state
 		state = runStep(win, state)

+		if oldState != *state {
+			log.Printf("z=%d cellIdx=%d", state.zIdx, state.cellIdx)
+			present(win, state)
+		}
+
 		win.Update()
 	}
 }

+// Converts pixel coordinates to cell coordinates
+func vecToCell(vec pixel.Vec) (int, int) {
+	x := int(vec.X)
+	y := int(vec.Y)
+
+	if x < 0 {
+		x = 0
+	}
+
+	if x > maps.MaxWidth-1 {
+		x = maps.MaxWidth - 1
+	}
+
+	if y < 0 {
+		y = 0
+	}
+
+	if y > maps.MaxLength-1 {
+		y = maps.MaxLength - 1
+	}
+
+	return x, y
+}
+
+func cellToVec(x, y int) pixel.Rect {
+	min := pixel.Vec{X: float64(x), Y: float64(y)}
+	max := pixel.Vec{X: min.X + 1, Y: min.Y + 1}
+	return pixel.Rect{Min: min, Max: max}
+}
+
 // TODO: cut this down to showing just the viewport?
 // The naive approach using gameMap.Width() / Height() cuts half the map off :/
-func presentFull(win *pixelgl.Window, state *runState) {
-	gameMap := state.gameMap
-	center := win.Bounds().Center()
-	sz := win.Bounds().Size()
+func present(win *pixelgl.Window, state *runState) {
+	gameMap := state.env.gameMap
 	imd := imdraw.New(nil)

-	// Rotate everything 45' anticlockwise to get an isometric view with the
-	// lowest coordinates at the (now) top corner
-	imd.SetMatrix(pixel.IM.Rotated(center, -math.Pi/4))
-
-	xPerCell := sz.X / float64(maps.MaxWidth)
-	yPerCell := sz.Y / float64(maps.MaxLength)
-
-	for y := 0; y < maps.MaxLength; y++ {
-		for x := 0; x < maps.MaxWidth; x++ {
-			min := pixel.Vec{X: float64(x) * xPerCell, Y: float64(y) * yPerCell}
-			max := pixel.Vec{X: min.X + xPerCell, Y: min.Y + yPerCell}
-
+	for y := gameMap.MinLength; y < gameMap.MaxLength; y++ {
+		for x := gameMap.MinWidth; x < gameMap.MaxWidth; x++ {
+			rect := cellToVec(int(x), int(y))
 			cell := gameMap.Cells.At(int(x), int(y), int(state.zIdx))
+
 			// TODO: represent the state of the cell *sensibly*, using colour.
 			// Need to understand the contents better first, so for now optimize
 			// for exploration
-			//
-			// CellIndex=3 shows walls & elevation changes
-			imd.Color = makeColour(cell, state.cellIdx)
-			imd.Push(min, max)
+			imd.Color = makeColour(&cell, state.cellIdx)
+			imd.Push(rect.Min, rect.Max)
 			imd.Rectangle(0.0)
 		}
 	}

-	cam := pixel.IM.Scaled(center, state.zoom)
-	win.SetMatrix(cam)
+	// Draw the boundary
+	rect := pixel.R(
+		float64(gameMap.MinWidth)-1, float64(gameMap.MinLength)-1,
+		float64(gameMap.MaxWidth)+1, float64(gameMap.MaxLength)+1,
+	)
+
+	imd.Color = pixel.RGB(255, 0, 0)
+	imd.EndShape = imdraw.SharpEndShape
+	imd.Push(rect.Min, rect.Max)
+	imd.Rectangle(1.0)
+
+	center := win.Bounds().Center()
+
+	cam := pixel.IM
+	cam = cam.ScaledXY(pixel.ZV, pixel.Vec{1.0, -1.0})  // invert the Y axis
+	cam = cam.Scaled(pixel.ZV, state.zoom)              // apply current zoom factor
+	cam = cam.Moved(center.Sub(state.camPos))           // Make it central
+	cam = cam.Rotated(center.Sub(state.camPos), -0.785) // Apply isometric angle
+	state.cam = cam
+
+	win.SetMatrix(state.cam)
 	win.Clear(colornames.Black)
 	imd.Draw(win)
 }

-func makeColour(cell maps.Cell, colIdx int) pixel.RGBA {
-	return pixel.RGB(
-		float64(cell[colIdx]),
-		float64(cell[colIdx]),
-		float64(cell[colIdx]),
-	)
+func makeColour(cell *maps.Cell, colIdx int) pixel.RGBA {
+	var scale func(float64) float64
+
+	mult := func(factor float64) func(float64) float64 {
+		return func(in float64) float64 { return in * factor }
+	}
+
+	// Different columns do better with different levels of greyscale.
+
+	switch colIdx {
+	case 0:
+		scale = mult(0.004)
+	case 1:
+		scale = mult(0.1)
+	case 2:
+		scale = mult(1.0)
+	case 3:
+		scale = mult(0.1)
+	case 4:
+		scale = func(in float64) float64 { return mult(0.01)(in - 100) }
+	case 10:
+		scale = func(in float64) float64 { return mult(0.01)(in - 100) }
+	case 12:
+		scale = mult(0.004)
+	case 13:
+		scale = mult(0.004)
+	case 14:
+		scale = mult(0.004)
+	default:
+		scale = mult(0.01) // close to maximum resolution, low-value fields will be lost
+
+	}
+
+	col := scale(float64(cell.At(colIdx)))
+	return pixel.RGB(col, col, col)
 }

 func runStep(win *pixelgl.Window, state *runState) *runState {
 	nextState := *state
-	nextState.redraw = false

 	// Enable / disable auto-update with the enter key
 	if win.JustPressed(pixelgl.KeyEnter) {
@@ -146,8 +233,7 @@ func runStep(win *pixelgl.Window, state *runState) *runState {
 	}

 	// Automatically cycle every second when auto-update is on
-	if nextState.autoUpdate && time.Now().Sub(nextState.started) > time.Second {
-		nextState.redraw = true
+	if nextState.autoUpdate && time.Now().Sub(state.started) > 500*time.Millisecond {
 		nextState.cellIdx = nextState.cellIdx + 1
 		if nextState.cellIdx >= maps.CellSize {
 			nextState.cellIdx = 0
@@ -161,47 +247,61 @@ func runStep(win *pixelgl.Window, state *runState) *runState {
 		nextState.started = time.Now()
 	}

-	if win.JustPressed(pixelgl.KeyDown) {
-		if nextState.zIdx <= 0 {
-			log.Printf("z index is already at minimum")
-		} else {
-			nextState.redraw = true
-			nextState.zIdx = nextState.zIdx - 1
+	if win.Pressed(pixelgl.KeyLeft) {
+		nextState.camPos.X -= 4
+	}
+
+	if win.Pressed(pixelgl.KeyRight) {
+		nextState.camPos.X += 4
+	}
+
+	if win.Pressed(pixelgl.KeyDown) {
+		nextState.camPos.Y -= 4
+	}
+
+	if win.Pressed(pixelgl.KeyUp) {
+		nextState.camPos.Y += 4
+	}
+
+	for i := 0; i <= 6; i++ {
+		if win.JustPressed(pixelgl.Key1 + pixelgl.Button(i)) {
+			nextState.zIdx = i
 		}
 	}

-	if win.JustPressed(pixelgl.KeyUp) {
-		if nextState.zIdx >= maps.MaxHeight-1 {
-			log.Printf("z index is already at maximum")
-		} else {
-			nextState.redraw = true
-			nextState.zIdx = nextState.zIdx + 1
+	// Decrease the cell index
+	if win.JustPressed(pixelgl.KeyMinus) {
+		if nextState.cellIdx > 0 {
+			nextState.cellIdx -= 1
 		}
 	}

-	if win.JustPressed(pixelgl.KeyLeft) {
-		if nextState.cellIdx <= 0 {
-			log.Printf("cell index is already at minimum")
-		} else {
-			nextState.redraw = true
-			nextState.cellIdx = nextState.cellIdx - 1
+	// Increase the cell index
+	if win.JustPressed(pixelgl.KeyEqual) {
+		if nextState.cellIdx < maps.CellSize-1 {
+			nextState.cellIdx += 1
 		}
 	}

-	if win.JustPressed(pixelgl.KeyRight) {
-		if nextState.cellIdx >= maps.CellSize-1 {
-			log.Printf("cell index is already at maximum")
-		} else {
-			nextState.redraw = true
-			nextState.cellIdx = nextState.cellIdx + 1
-		}
+	// Show details of clicked-on cell in termal
+	if win.JustPressed(pixelgl.MouseButtonLeft) {
+		vec := state.cam.Unproject(win.MousePosition())
+		x, y := vecToCell(vec)
+		log.Printf("%#v -> %d,%d", vec, x, y)
+		cell := state.env.gameMap.Cells.At(x, y, state.zIdx)
+		log.Printf(
+			"x=%d y=%d z=%d Object0SurfaceArea=%d Object3CenterArea=%d (%s) SquadRelated=%d",
+			x, y, state.zIdx,
+			cell.Object0SurfaceArea, cell.Object3CenterArea, state.env.set.Palette[int(cell.Object3CenterArea)],
+			cell.SquadRelated,
+		)
+		log.Printf("CellIdx%d=%d. Full cell data: %#v", state.cellIdx, cell.At(state.cellIdx), cell)
 	}

 	// Zoom in and out with the mouse wheel
 	nextState.zoom *= math.Pow(1.2, win.MouseScroll().Y)
 	if nextState.zoom != state.zoom {
 		log.Printf("zoom=%.2f", nextState.zoom)
-		nextState.redraw = true
 	}

 	return &nextState