Noah Petherbridge
f8ca9a0921
* Update code for recent changes in UI toolkit around event handlers for buttons. * Add tooltips to various buttons in the Editor Mode. The left toolbar shows the names of each tool, the Doodad Palette shows the title of each doodad and the Color Palette shows the swatch attributes (solid, fire, water, etc.)
535 lines
12 KiB
Go
535 lines
12 KiB
Go
package doodle
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"git.kirsle.net/apps/doodle/pkg/balance"
|
|
"git.kirsle.net/apps/doodle/pkg/enum"
|
|
"git.kirsle.net/apps/doodle/pkg/level"
|
|
"git.kirsle.net/apps/doodle/pkg/log"
|
|
"git.kirsle.net/apps/doodle/pkg/uix"
|
|
"git.kirsle.net/apps/doodle/pkg/userdir"
|
|
"git.kirsle.net/go/render"
|
|
"git.kirsle.net/go/render/event"
|
|
"git.kirsle.net/go/ui"
|
|
)
|
|
|
|
/*
|
|
MenuScene holds the main dialog menu UIs for:
|
|
|
|
* New Level
|
|
* Open Level
|
|
* Settings
|
|
*/
|
|
type MenuScene struct {
|
|
// Configuration.
|
|
StartupMenu string
|
|
|
|
Supervisor *ui.Supervisor
|
|
|
|
// Private widgets.
|
|
window *ui.Window
|
|
|
|
// Background wallpaper canvas.
|
|
canvas *uix.Canvas
|
|
|
|
// Values for the New menu
|
|
newPageType string
|
|
newWallpaper string
|
|
|
|
// Values for the Load/Play menu.
|
|
loadForPlay bool // false = load for edit
|
|
}
|
|
|
|
// Name of the scene.
|
|
func (s *MenuScene) Name() string {
|
|
return "Menu"
|
|
}
|
|
|
|
// GotoNewMenu loads the MenuScene and shows the "New" window.
|
|
func (d *Doodle) GotoNewMenu() {
|
|
log.Info("Loading the MenuScene to the New window")
|
|
scene := &MenuScene{
|
|
StartupMenu: "new",
|
|
}
|
|
d.Goto(scene)
|
|
}
|
|
|
|
// GotoLoadMenu loads the MenuScene and shows the "Load" window.
|
|
func (d *Doodle) GotoLoadMenu() {
|
|
log.Info("Loading the MenuScene to the Load window for Edit Mode")
|
|
scene := &MenuScene{
|
|
StartupMenu: "load",
|
|
}
|
|
d.Goto(scene)
|
|
}
|
|
|
|
// GotoPlayMenu loads the MenuScene and shows the "Load" window for playing a
|
|
// level, not editing it.
|
|
func (d *Doodle) GotoPlayMenu() {
|
|
log.Info("Loading the MenuScene to the Load window for Play Mode")
|
|
scene := &MenuScene{
|
|
StartupMenu: "load",
|
|
loadForPlay: true,
|
|
}
|
|
d.Goto(scene)
|
|
}
|
|
|
|
// Setup the scene.
|
|
func (s *MenuScene) Setup(d *Doodle) error {
|
|
s.Supervisor = ui.NewSupervisor()
|
|
|
|
// Set up the background wallpaper canvas.
|
|
s.canvas = uix.NewCanvas(100, false)
|
|
s.canvas.Resize(render.Rect{
|
|
W: d.width,
|
|
H: d.height,
|
|
})
|
|
s.canvas.LoadLevel(d.Engine, &level.Level{
|
|
Chunker: level.NewChunker(100),
|
|
Palette: level.NewPalette(),
|
|
PageType: level.Bounded,
|
|
Wallpaper: "notebook.png",
|
|
})
|
|
|
|
switch s.StartupMenu {
|
|
case "new":
|
|
if err := s.setupNewWindow(d); err != nil {
|
|
return err
|
|
}
|
|
case "load":
|
|
if err := s.setupLoadWindow(d); err != nil {
|
|
return err
|
|
}
|
|
default:
|
|
d.Flash("No Valid StartupMenu Given to MenuScene")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// configureCanvas updates the settings of the background canvas, so a live
|
|
// preview of the wallpaper and wrapping type can be shown.
|
|
func (s *MenuScene) configureCanvas(e render.Engine, pageType level.PageType, wallpaper string) {
|
|
s.canvas.LoadLevel(e, &level.Level{
|
|
Chunker: level.NewChunker(100),
|
|
Palette: level.NewPalette(),
|
|
PageType: pageType,
|
|
Wallpaper: wallpaper,
|
|
})
|
|
}
|
|
|
|
// setupNewWindow sets up the UI for the "New" window.
|
|
func (s *MenuScene) setupNewWindow(d *Doodle) error {
|
|
// Default scene options.
|
|
s.newPageType = level.Bounded.String()
|
|
s.newWallpaper = "notebook.png"
|
|
|
|
window := ui.NewWindow("New Drawing")
|
|
window.Configure(ui.Config{
|
|
Width: int(float64(d.width) * 0.75),
|
|
Height: int(float64(d.height) * 0.75),
|
|
Background: render.Grey,
|
|
})
|
|
window.Compute(d.Engine)
|
|
|
|
{
|
|
frame := ui.NewFrame("New Level Frame")
|
|
window.Pack(frame, ui.Pack{
|
|
Side: ui.N,
|
|
Fill: true,
|
|
Expand: true,
|
|
})
|
|
|
|
/******************
|
|
* Frame for selecting Page Type
|
|
******************/
|
|
|
|
label1 := ui.NewLabel(ui.Label{
|
|
Text: "Page Type",
|
|
Font: balance.LabelFont,
|
|
})
|
|
frame.Pack(label1, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
})
|
|
|
|
typeFrame := ui.NewFrame("Page Type Options Frame")
|
|
frame.Pack(typeFrame, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
})
|
|
|
|
type typeObj struct {
|
|
Name string
|
|
Value level.PageType
|
|
}
|
|
var types = []typeObj{
|
|
{"Unbounded", level.Unbounded},
|
|
{"Bounded", level.Bounded},
|
|
{"No Negative Space", level.NoNegativeSpace},
|
|
// {"Bordered (TODO)", level.Bordered},
|
|
}
|
|
for _, t := range types {
|
|
// TODO: Hide some options for the free version of the game.
|
|
// - At launch only Bounded and Bordered will be available
|
|
// in the shareware version.
|
|
// - For now, only hide Bordered as it's not yet implemented.
|
|
// --------
|
|
// if balance.FreeVersion {
|
|
// if t.Value == level.Bordered {
|
|
// continue
|
|
// }
|
|
// }
|
|
|
|
func(t typeObj) {
|
|
radio := ui.NewRadioButton(t.Name,
|
|
&s.newPageType,
|
|
t.Value.String(),
|
|
ui.NewLabel(ui.Label{
|
|
Text: t.Name,
|
|
Font: balance.MenuFont,
|
|
}),
|
|
)
|
|
radio.Handle(ui.Click, func(ed ui.EventData) {
|
|
s.configureCanvas(d.Engine, t.Value, s.newWallpaper)
|
|
})
|
|
s.Supervisor.Add(radio)
|
|
typeFrame.Pack(radio, ui.Pack{
|
|
Side: ui.W,
|
|
PadX: 4,
|
|
})
|
|
}(t)
|
|
}
|
|
|
|
/******************
|
|
* Frame for selecting Level Wallpaper
|
|
******************/
|
|
|
|
label2 := ui.NewLabel(ui.Label{
|
|
Text: "Wallpaper",
|
|
Font: balance.LabelFont,
|
|
})
|
|
frame.Pack(label2, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
})
|
|
|
|
wpFrame := ui.NewFrame("Wallpaper Frame")
|
|
frame.Pack(wpFrame, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
})
|
|
|
|
type wallpaperObj struct {
|
|
Name string
|
|
Value string
|
|
}
|
|
var wallpapers = []wallpaperObj{
|
|
{"Notebook", "notebook.png"},
|
|
{"Blueprint", "blueprint.png"},
|
|
{"Legal Pad", "legal.png"},
|
|
{"Pure White", "white.png"},
|
|
// {"Placemat", "placemat.png"},
|
|
}
|
|
for _, t := range wallpapers {
|
|
func(t wallpaperObj) {
|
|
radio := ui.NewRadioButton(t.Name, &s.newWallpaper, t.Value, ui.NewLabel(ui.Label{
|
|
Text: t.Name,
|
|
Font: balance.MenuFont,
|
|
}))
|
|
radio.Handle(ui.Click, func(ed ui.EventData) {
|
|
log.Info("Set wallpaper to %s", t.Value)
|
|
if pageType, ok := level.PageTypeFromString(s.newPageType); ok {
|
|
s.configureCanvas(d.Engine, pageType, t.Value)
|
|
}
|
|
})
|
|
s.Supervisor.Add(radio)
|
|
wpFrame.Pack(radio, ui.Pack{
|
|
Side: ui.W,
|
|
PadX: 4,
|
|
})
|
|
}(t)
|
|
}
|
|
|
|
/******************
|
|
* Confirm/cancel buttons.
|
|
******************/
|
|
|
|
bottomFrame := ui.NewFrame("Button Frame")
|
|
// bottomFrame.Configure(ui.Config{
|
|
// BorderSize: 1,
|
|
// BorderStyle: ui.BorderSunken,
|
|
// BorderColor: render.Black,
|
|
// })
|
|
// bottomFrame.SetBackground(render.Grey)
|
|
frame.Pack(bottomFrame, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
PadY: 8,
|
|
})
|
|
|
|
var buttons = []struct {
|
|
Label string
|
|
F func(ui.EventData)
|
|
}{
|
|
{"Continue", func(ed ui.EventData) {
|
|
d.Flash("Create new map with %s page type and %s wallpaper", s.newPageType, s.newWallpaper)
|
|
pageType, ok := level.PageTypeFromString(s.newPageType)
|
|
if !ok {
|
|
d.Flash("Invalid Page Type '%s'", s.newPageType)
|
|
return
|
|
}
|
|
|
|
lvl := level.New()
|
|
lvl.Palette = level.DefaultPalette()
|
|
lvl.Wallpaper = s.newWallpaper
|
|
lvl.PageType = pageType
|
|
|
|
// Blueprint theme palette for the dark wallpaper color.
|
|
if lvl.Wallpaper == "blueprint.png" {
|
|
lvl.Palette = level.NewBlueprintPalette()
|
|
}
|
|
|
|
d.Goto(&EditorScene{
|
|
DrawingType: enum.LevelDrawing,
|
|
Level: lvl,
|
|
})
|
|
}},
|
|
|
|
{"Cancel", func(ed ui.EventData) {
|
|
d.Goto(&MainScene{})
|
|
}},
|
|
}
|
|
for _, t := range buttons {
|
|
btn := ui.NewButton(t.Label, ui.NewLabel(ui.Label{
|
|
Text: t.Label,
|
|
Font: balance.MenuFont,
|
|
}))
|
|
btn.Handle(ui.Click, t.F)
|
|
s.Supervisor.Add(btn)
|
|
bottomFrame.Pack(btn, ui.Pack{
|
|
Side: ui.W,
|
|
PadX: 4,
|
|
PadY: 8,
|
|
})
|
|
}
|
|
}
|
|
|
|
s.window = window
|
|
return nil
|
|
}
|
|
|
|
// setupLoadWindow sets up the UI for the "New" window.
|
|
func (s *MenuScene) setupLoadWindow(d *Doodle) error {
|
|
window := ui.NewWindow("Open Drawing")
|
|
window.Configure(ui.Config{
|
|
Width: int(float64(d.width) * 0.75),
|
|
Height: int(float64(d.height) * 0.75),
|
|
Background: render.Grey,
|
|
})
|
|
window.Compute(d.Engine)
|
|
|
|
{
|
|
frame := ui.NewFrame("Open Drawing Frame")
|
|
window.Pack(frame, ui.Pack{
|
|
Side: ui.N,
|
|
Fill: true,
|
|
Expand: true,
|
|
})
|
|
|
|
/******************
|
|
* Frame for selecting User Levels
|
|
******************/
|
|
|
|
label1 := ui.NewLabel(ui.Label{
|
|
Text: "Levels",
|
|
Font: balance.LabelFont,
|
|
})
|
|
frame.Pack(label1, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
})
|
|
|
|
// Get the user's levels.
|
|
levels, _ := userdir.ListLevels()
|
|
|
|
// Embedded levels, TODO
|
|
sysLevels, _ := level.ListSystemLevels()
|
|
levels = append(levels, sysLevels...)
|
|
|
|
lvlRow := ui.NewFrame("Level Row 0")
|
|
frame.Pack(lvlRow, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
PadY: 1,
|
|
})
|
|
for i, lvl := range levels {
|
|
func(i int, lvl string) {
|
|
log.Info("Add file %s to row %s", lvl, lvlRow.Name)
|
|
btn := ui.NewButton("Level Btn", ui.NewLabel(ui.Label{
|
|
Text: lvl,
|
|
Font: balance.MenuFont,
|
|
}))
|
|
btn.Handle(ui.Click, func(ed ui.EventData) {
|
|
if s.loadForPlay {
|
|
d.PlayLevel(lvl)
|
|
} else {
|
|
d.EditFile(lvl)
|
|
}
|
|
})
|
|
s.Supervisor.Add(btn)
|
|
lvlRow.Pack(btn, ui.Pack{
|
|
Side: ui.W,
|
|
Expand: true,
|
|
Fill: true,
|
|
})
|
|
|
|
if i > 0 && (i+1)%4 == 0 {
|
|
log.Warn("i=%d wrapped at mod 4", i)
|
|
lvlRow = ui.NewFrame(fmt.Sprintf("Level Row %d", i))
|
|
frame.Pack(lvlRow, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
PadY: 1,
|
|
})
|
|
}
|
|
}(i, lvl)
|
|
}
|
|
|
|
/******************
|
|
* Frame for selecting User Doodads
|
|
******************/
|
|
|
|
// Doodads not shown if we're loading a map to play, nor are they
|
|
// available to the free version.
|
|
if !s.loadForPlay && !balance.FreeVersion {
|
|
label2 := ui.NewLabel(ui.Label{
|
|
Text: "Doodads",
|
|
Font: balance.LabelFont,
|
|
})
|
|
frame.Pack(label2, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
})
|
|
|
|
files, _ := userdir.ListDoodads()
|
|
ddRow := ui.NewFrame("Doodad Row 0")
|
|
frame.Pack(ddRow, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
PadY: 1,
|
|
})
|
|
for i, dd := range files {
|
|
func(i int, dd string) {
|
|
btn := ui.NewButton("Doodad Btn", ui.NewLabel(ui.Label{
|
|
Text: dd,
|
|
Font: balance.MenuFont,
|
|
}))
|
|
btn.Handle(ui.Click, func(ed ui.EventData) {
|
|
d.EditFile(dd)
|
|
})
|
|
s.Supervisor.Add(btn)
|
|
ddRow.Pack(btn, ui.Pack{
|
|
Side: ui.W,
|
|
Expand: true,
|
|
Fill: true,
|
|
})
|
|
|
|
if i > 0 && (i+1)%4 == 0 {
|
|
ddRow = ui.NewFrame(fmt.Sprintf("Doodad Row %d", i))
|
|
frame.Pack(ddRow, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
PadY: 1,
|
|
})
|
|
}
|
|
}(i, dd)
|
|
}
|
|
}
|
|
|
|
/******************
|
|
* Confirm/cancel buttons.
|
|
******************/
|
|
|
|
bottomFrame := ui.NewFrame("Button Frame")
|
|
// bottomFrame.Configure(ui.Config{
|
|
// BorderSize: 1,
|
|
// BorderStyle: ui.BorderSunken,
|
|
// BorderColor: render.Black,
|
|
// })
|
|
// bottomFrame.SetBackground(render.Grey)
|
|
frame.Pack(bottomFrame, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
PadY: 8,
|
|
})
|
|
|
|
var buttons = []struct {
|
|
Label string
|
|
F func(ui.EventData)
|
|
}{
|
|
{"Cancel", func(ed ui.EventData) {
|
|
d.Goto(&MainScene{})
|
|
}},
|
|
}
|
|
for _, t := range buttons {
|
|
btn := ui.NewButton(t.Label, ui.NewLabel(ui.Label{
|
|
Text: t.Label,
|
|
Font: balance.MenuFont,
|
|
}))
|
|
btn.Handle(ui.Click, t.F)
|
|
s.Supervisor.Add(btn)
|
|
bottomFrame.Pack(btn, ui.Pack{
|
|
Side: ui.W,
|
|
PadX: 4,
|
|
PadY: 8,
|
|
})
|
|
}
|
|
}
|
|
|
|
s.window = window
|
|
return nil
|
|
}
|
|
|
|
// Loop the editor scene.
|
|
func (s *MenuScene) Loop(d *Doodle, ev *event.State) error {
|
|
s.Supervisor.Loop(ev)
|
|
|
|
if ev.WindowResized {
|
|
w, h := d.Engine.WindowSize()
|
|
d.width = w
|
|
d.height = h
|
|
log.Info("Resized to %dx%d", d.width, d.height)
|
|
s.canvas.Resize(render.Rect{
|
|
W: d.width,
|
|
H: d.height,
|
|
})
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Draw the pixels on this frame.
|
|
func (s *MenuScene) Draw(d *Doodle) error {
|
|
// Clear the canvas and fill it with white.
|
|
d.Engine.Clear(render.White)
|
|
|
|
// Draw the background canvas.
|
|
s.canvas.Present(d.Engine, render.Origin)
|
|
|
|
s.window.Compute(d.Engine)
|
|
s.window.MoveTo(render.Point{
|
|
X: (d.width / 2) - (s.window.Size().W / 2),
|
|
Y: 60,
|
|
})
|
|
s.window.Present(d.Engine, s.window.Point())
|
|
|
|
return nil
|
|
}
|
|
|
|
// Destroy the scene.
|
|
func (s *MenuScene) Destroy() error {
|
|
return nil
|
|
}
|