Nick Thomas
3b7cfb6ecc
This is pretty awful, but will let me wire up items more easily without needing to do the big refactor into independent menu handlers
139 lines
3.3 KiB
Go
139 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"log"
|
|
"math"
|
|
"os"
|
|
|
|
"github.com/hajimehoshi/ebiten"
|
|
|
|
"code.ur.gs/lupine/ordoor/internal/assetstore"
|
|
"code.ur.gs/lupine/ordoor/internal/config"
|
|
"code.ur.gs/lupine/ordoor/internal/flow"
|
|
"code.ur.gs/lupine/ordoor/internal/scenario"
|
|
"code.ur.gs/lupine/ordoor/internal/ship"
|
|
"code.ur.gs/lupine/ordoor/internal/ui"
|
|
)
|
|
|
|
var (
|
|
configFile = flag.String("config", "config.toml", "Config file")
|
|
engine = flag.String("engine", "", "Override engine to use")
|
|
|
|
gameMap = flag.String("map", "", "Name of a map, e.g., Chapter01")
|
|
|
|
winX = flag.Int("win-x", 1280, "Pre-scaled window X dimension")
|
|
winY = flag.Int("win-y", 1024, "Pre-scaled window Y dimension")
|
|
)
|
|
|
|
type env struct {
|
|
flow *flow.Flow
|
|
scenario *scenario.Scenario
|
|
}
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
|
|
if *configFile == "" || *gameMap == "" {
|
|
flag.Usage()
|
|
os.Exit(1)
|
|
}
|
|
|
|
cfg, err := config.Load(*configFile, *engine)
|
|
if err != nil {
|
|
log.Fatalf("Failed to load config: %v", err)
|
|
}
|
|
|
|
assets, err := assetstore.New(cfg.DefaultEngine())
|
|
if err != nil {
|
|
log.Fatalf("Failed to scan root directory: %v", err)
|
|
}
|
|
|
|
scenario, err := scenario.NewScenario(assets, *gameMap)
|
|
if err != nil {
|
|
log.Fatalf("Failed to load scenario %v: %v", *gameMap, err)
|
|
}
|
|
|
|
var realEnv *env
|
|
if cfg.DefaultEngineName == "ordoor" {
|
|
ship := &ship.Ship{}
|
|
|
|
flow, err := flow.New(assets, cfg, ship)
|
|
if err != nil {
|
|
log.Fatalf("Failed to setup flow: %v", err)
|
|
}
|
|
flow.SetScenario(scenario)
|
|
realEnv = &env{flow: flow, scenario: scenario}
|
|
} else {
|
|
realEnv = &env{scenario: scenario}
|
|
}
|
|
|
|
win, err := ui.NewWindow(realEnv, "View Map "+*gameMap, *winX, *winY)
|
|
if err != nil {
|
|
log.Fatal("Couldn't create window: %v", err)
|
|
}
|
|
|
|
for i := 0; i <= 6; i++ {
|
|
win.OnKeyUp(ebiten.Key1+ebiten.Key(i), realEnv.setZIdx(i))
|
|
}
|
|
|
|
win.OnMouseClick(realEnv.showCellData)
|
|
win.OnMouseWheel(realEnv.changeZoom)
|
|
|
|
if realEnv.flow == nil {
|
|
step := 32
|
|
win.WhileKeyDown(ebiten.KeyLeft, realEnv.changeOrigin(-step, +0))
|
|
win.WhileKeyDown(ebiten.KeyRight, realEnv.changeOrigin(+step, +0))
|
|
win.WhileKeyDown(ebiten.KeyUp, realEnv.changeOrigin(+0, -step))
|
|
win.WhileKeyDown(ebiten.KeyDown, realEnv.changeOrigin(+0, +step))
|
|
}
|
|
|
|
if err := win.Run(); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func (e *env) Update(screenX, screenY int) error {
|
|
if e.flow != nil {
|
|
return e.flow.Update(screenX, screenY)
|
|
} else {
|
|
return e.scenario.Update(screenX, screenY)
|
|
}
|
|
}
|
|
|
|
func (e *env) Draw(screen *ebiten.Image) error {
|
|
if e.flow != nil {
|
|
return e.flow.Draw(screen)
|
|
} else {
|
|
return e.scenario.Draw(screen)
|
|
}
|
|
}
|
|
|
|
func (e *env) changeOrigin(byX, byY int) func() {
|
|
return func() {
|
|
e.scenario.Viewpoint.X += byX
|
|
e.scenario.Viewpoint.Y += byY
|
|
}
|
|
}
|
|
|
|
func (e *env) changeZoom(_, byY float64) {
|
|
e.scenario.Zoom *= math.Pow(1.2, byY)
|
|
}
|
|
|
|
func (e *env) setZIdx(to int) func() {
|
|
return func() {
|
|
e.scenario.ZIdx = to
|
|
}
|
|
}
|
|
|
|
func (e *env) showCellData() {
|
|
screenX, screenY := ebiten.CursorPosition()
|
|
viewX, viewY := e.scenario.Viewpoint.X+screenX, e.scenario.Viewpoint.Y+screenY
|
|
|
|
log.Printf("Click registered at (%d,%d) screen, (%d,%d) virtual", screenX, screenY, viewX, viewY)
|
|
|
|
cell, pos := e.scenario.CellAtCursor()
|
|
log.Printf("Viewpoint: %#+v z=%v", e.scenario.Viewpoint, e.scenario.ZIdx)
|
|
log.Printf("Cell under cursor: (%.2f,%.2f,%d): %#+v", pos.X, pos.Y, pos.Z, cell)
|
|
}
|