Noah Petherbridge
dce32ea14b
* Free (shareware) versions of the game will not be able to Publish Levels (attach custom doodads to the level file) and they will not be able to load a level which relies on embedded doodads. * The UI for the Publish Level window is still available, but clicking on the confirm button will just open the Register (License) window. * When loading a level containing embedded doodads: if some can't load because they're embedded and you're using the free version of the game, the error message is customized to reflect that.
356 lines
9.4 KiB
Go
356 lines
9.4 KiB
Go
package doodle
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"git.kirsle.net/apps/doodle/pkg/balance"
|
|
"git.kirsle.net/apps/doodle/pkg/doodads"
|
|
"git.kirsle.net/apps/doodle/pkg/level"
|
|
"git.kirsle.net/apps/doodle/pkg/level/publishing"
|
|
"git.kirsle.net/apps/doodle/pkg/license"
|
|
"git.kirsle.net/apps/doodle/pkg/log"
|
|
"git.kirsle.net/apps/doodle/pkg/modal"
|
|
"git.kirsle.net/apps/doodle/pkg/windows"
|
|
"git.kirsle.net/go/render"
|
|
"git.kirsle.net/go/ui"
|
|
)
|
|
|
|
/*
|
|
Functions to manage popup windows in the Editor Mode, such as:
|
|
|
|
* The Palette Editor
|
|
* The Layers Window
|
|
* etc.
|
|
*/
|
|
|
|
// Opens the "Layers" window (for editing doodads)
|
|
func (u *EditorUI) OpenLayersWindow() {
|
|
u.layersWindow.Hide()
|
|
u.layersWindow = nil
|
|
u.SetupPopups(u.d)
|
|
u.layersWindow.Show()
|
|
}
|
|
|
|
// OpenPaletteWindow opens the Palette Editor window.
|
|
func (u *EditorUI) OpenPaletteWindow() {
|
|
// TODO: recompute the window so the actual loaded level palette gets in
|
|
u.paletteEditor.Hide()
|
|
u.paletteEditor = nil
|
|
u.SetupPopups(u.d)
|
|
u.paletteEditor.Show()
|
|
}
|
|
|
|
// OpenDoodadDropper opens the Doodad Dropper window.
|
|
func (u *EditorUI) OpenDoodadDropper() {
|
|
// NOTE: most places in the code call this directly, nice
|
|
// and simple window :) but OpenDoodadDropper() added for consistency.
|
|
u.doodadWindow.Show()
|
|
}
|
|
|
|
// OpenPublishWindow opens the Publisher window.
|
|
func (u *EditorUI) OpenPublishWindow() {
|
|
u.publishWindow.Hide()
|
|
u.publishWindow = nil
|
|
u.SetupPopups(u.d)
|
|
u.publishWindow.Show()
|
|
}
|
|
|
|
// OpenPublishWindow opens the FileSystem window.
|
|
func (u *EditorUI) OpenFileSystemWindow() {
|
|
u.filesystemWindow.Hide()
|
|
u.filesystemWindow = nil
|
|
u.SetupPopups(u.d)
|
|
u.filesystemWindow.Show()
|
|
}
|
|
|
|
// SetupPopups preloads popup windows like the DoodadDropper.
|
|
func (u *EditorUI) SetupPopups(d *Doodle) {
|
|
// Common window configure function.
|
|
var configure = func(window *ui.Window) {
|
|
var size = window.Size()
|
|
window.Compute(d.Engine)
|
|
window.Supervise(u.Supervisor)
|
|
|
|
// Center the window.
|
|
window.MoveTo(render.Point{
|
|
X: (d.width / 2) - (size.W / 2),
|
|
Y: (d.height / 2) - (size.H / 2),
|
|
})
|
|
|
|
window.Hide()
|
|
}
|
|
|
|
// License Registration Window.
|
|
if u.licenseWindow == nil {
|
|
cfg := windows.License{
|
|
Supervisor: u.Supervisor,
|
|
Engine: d.Engine,
|
|
OnCancel: func() {
|
|
u.licenseWindow.Hide()
|
|
},
|
|
}
|
|
cfg.OnLicensed = func() {
|
|
// License status has changed, reload the window!
|
|
if u.licenseWindow != nil {
|
|
u.licenseWindow.Hide()
|
|
}
|
|
u.licenseWindow = windows.MakeLicenseWindow(d.width, d.height, cfg)
|
|
}
|
|
|
|
cfg.OnLicensed()
|
|
u.licenseWindow.Hide()
|
|
}
|
|
|
|
// Doodad Dropper.
|
|
if u.doodadWindow == nil {
|
|
u.doodadWindow = windows.NewDoodadDropper(windows.DoodadDropper{
|
|
Supervisor: u.Supervisor,
|
|
Engine: d.Engine,
|
|
|
|
OnStartDragActor: u.startDragActor,
|
|
OnCancel: func() {
|
|
u.doodadWindow.Hide()
|
|
},
|
|
})
|
|
configure(u.doodadWindow)
|
|
}
|
|
|
|
// Page Settings
|
|
if u.levelSettingsWindow == nil {
|
|
scene, _ := d.Scene.(*EditorScene)
|
|
|
|
u.levelSettingsWindow = windows.NewAddEditLevel(windows.AddEditLevel{
|
|
Supervisor: u.Supervisor,
|
|
Engine: d.Engine,
|
|
EditLevel: scene.Level,
|
|
|
|
OnChangePageTypeAndWallpaper: func(pageType level.PageType, wallpaper string) {
|
|
log.Info("OnChangePageTypeAndWallpaper called: %+v, %+v", pageType, wallpaper)
|
|
scene.Level.PageType = pageType
|
|
scene.Level.Wallpaper = wallpaper
|
|
u.Canvas.LoadLevel(d.Engine, scene.Level)
|
|
},
|
|
OnCancel: func() {
|
|
u.levelSettingsWindow.Hide()
|
|
},
|
|
})
|
|
configure(u.levelSettingsWindow)
|
|
}
|
|
|
|
// Publish Level (embed doodads)
|
|
if u.publishWindow == nil {
|
|
scene, _ := d.Scene.(*EditorScene)
|
|
|
|
u.publishWindow = windows.NewPublishWindow(windows.Publish{
|
|
Supervisor: u.Supervisor,
|
|
Engine: d.Engine,
|
|
Level: scene.Level,
|
|
|
|
OnPublish: func(includeBuiltins bool) {
|
|
// XXX: Paid Version Only.
|
|
if !license.IsRegistered() {
|
|
if u.licenseWindow != nil {
|
|
u.licenseWindow.Show()
|
|
u.Supervisor.FocusWindow(u.licenseWindow)
|
|
}
|
|
d.Flash("Level Publishing is only available in the full version of the game.")
|
|
// modal.Alert(
|
|
// "This feature is only available in the full version of the game.",
|
|
// ).WithTitle("Please register")
|
|
return
|
|
}
|
|
|
|
log.Debug("OnPublish: include builtins=%+v", includeBuiltins)
|
|
cwd, _ := os.Getwd()
|
|
d.Prompt(fmt.Sprintf("File name (relative to %s)> ", cwd), func(answer string) {
|
|
if answer == "" {
|
|
d.Flash("A file name is required to publish this level.")
|
|
return
|
|
}
|
|
|
|
if !strings.HasSuffix(answer, ".level") {
|
|
answer += ".level"
|
|
}
|
|
|
|
answer = filepath.Join(cwd, answer)
|
|
log.Debug("call with includeBuiltins=%+v", includeBuiltins)
|
|
if _, err := publishing.Publish(scene.Level, answer, includeBuiltins); err != nil {
|
|
modal.Alert("Error when publishing the level: %s", err)
|
|
return
|
|
}
|
|
d.Flash("Exported published level to: %s", answer)
|
|
})
|
|
},
|
|
OnCancel: func() {
|
|
u.publishWindow.Hide()
|
|
},
|
|
})
|
|
configure(u.publishWindow)
|
|
}
|
|
|
|
// Level FileSystem Viewer.
|
|
if u.filesystemWindow == nil {
|
|
scene, _ := d.Scene.(*EditorScene)
|
|
|
|
u.filesystemWindow = windows.NewFileSystemWindow(windows.FileSystem{
|
|
Supervisor: u.Supervisor,
|
|
Engine: d.Engine,
|
|
Level: scene.Level,
|
|
|
|
OnDelete: func(filename string) bool {
|
|
// Check if it is an embedded doodad.
|
|
if strings.HasPrefix(filename, balance.EmbeddedDoodadsBasePath) {
|
|
// Check if we have the doodad installed locally.
|
|
if _, err := doodads.LoadFile(filepath.Base(filename)); err != nil {
|
|
modal.Alert(
|
|
"Cannot remove %s:\n\n"+
|
|
"This doodad is still in use by the level and does not\n"+
|
|
"exist on your local device, so can not be deleted.",
|
|
filepath.Base(filename),
|
|
).WithTitle("Cannot Remove Custom Doodad")
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Can't delete the current wallpaper.
|
|
if filepath.Base(filename) == scene.Level.Wallpaper {
|
|
modal.Alert(
|
|
"This wallpaper is still in use as the level background, so can\n" +
|
|
"not be deleted. Change the wallpaper in the Page Settings window\n" +
|
|
"to one of the defaults and then you may remove this file from the level.",
|
|
).WithTitle("Cannot Remove Current Wallpaper")
|
|
return false
|
|
}
|
|
|
|
if ok := scene.Level.DeleteFile(filename); !ok {
|
|
modal.Alert("Failed to remove file from level data!")
|
|
return false
|
|
}
|
|
|
|
return true
|
|
},
|
|
OnCancel: func() {
|
|
u.filesystemWindow.Hide()
|
|
},
|
|
})
|
|
configure(u.filesystemWindow)
|
|
}
|
|
|
|
// Palette Editor.
|
|
if u.paletteEditor == nil {
|
|
scene, _ := d.Scene.(*EditorScene)
|
|
|
|
// Which palette?
|
|
var pal *level.Palette
|
|
if scene.Level != nil {
|
|
pal = scene.Level.Palette
|
|
} else if scene.Doodad != nil {
|
|
pal = scene.Doodad.Palette
|
|
}
|
|
|
|
u.paletteEditor = windows.NewPaletteEditor(windows.PaletteEditor{
|
|
Supervisor: u.Supervisor,
|
|
Engine: d.Engine,
|
|
IsDoodad: scene.Doodad != nil,
|
|
EditPalette: pal,
|
|
|
|
OnChange: func() {
|
|
// Reload the level.
|
|
if scene.Level != nil {
|
|
log.Warn("RELOAD LEVEL")
|
|
u.Canvas.LoadLevel(d.Engine, scene.Level)
|
|
scene.Level.Chunker.Redraw()
|
|
} else if scene.Doodad != nil {
|
|
log.Warn("RELOAD DOODAD")
|
|
u.Canvas.LoadDoodadToLayer(u.Scene.Doodad, u.Scene.ActiveLayer)
|
|
u.Scene.Doodad.Layers[u.Scene.ActiveLayer].Chunker.Redraw()
|
|
}
|
|
|
|
// Reload the palette frame to reflect the changed data.
|
|
u.Palette.Hide()
|
|
u.Palette = u.SetupPalette(d)
|
|
u.Resized(d)
|
|
},
|
|
OnAddColor: func() {
|
|
// Adding a new color to the palette.
|
|
sw := pal.AddSwatch()
|
|
log.Info("Added new palette color: %+v", sw)
|
|
|
|
// Awkward but... reload this very same window.
|
|
u.paletteEditor.Hide()
|
|
u.paletteEditor = nil
|
|
u.SetupPopups(d)
|
|
u.paletteEditor.Show()
|
|
},
|
|
OnCancel: func() {
|
|
u.paletteEditor.Hide()
|
|
},
|
|
})
|
|
configure(u.paletteEditor)
|
|
}
|
|
|
|
// Layers window (doodad editor)
|
|
if u.layersWindow == nil {
|
|
scene, _ := d.Scene.(*EditorScene)
|
|
|
|
u.layersWindow = windows.NewLayerWindow(windows.Layers{
|
|
Supervisor: u.Supervisor,
|
|
Engine: d.Engine,
|
|
EditDoodad: scene.Doodad,
|
|
ActiveLayer: scene.ActiveLayer,
|
|
|
|
OnChange: func(self *doodads.Doodad) {
|
|
// Reload the level.
|
|
log.Warn("RELOAD LEVEL")
|
|
u.Canvas.LoadDoodad(u.Scene.Doodad)
|
|
|
|
for i := range self.Layers {
|
|
scene.Doodad.Layers[i] = self.Layers[i]
|
|
}
|
|
|
|
// Awkward but... reload this very same window.
|
|
// Otherwise, the window doesn't update to show the new
|
|
// layer having been added.
|
|
u.layersWindow.Hide()
|
|
u.layersWindow = nil
|
|
u.SetupPopups(d)
|
|
u.layersWindow.Show()
|
|
},
|
|
OnAddLayer: func() {
|
|
layer := doodads.Layer{
|
|
Name: fmt.Sprintf("layer %d", len(scene.Doodad.Layers)),
|
|
Chunker: level.NewChunker(scene.DoodadSize),
|
|
}
|
|
scene.Doodad.Layers = append(scene.Doodad.Layers, layer)
|
|
log.Info("Added new layer: %d %s",
|
|
len(scene.Doodad.Layers), layer.Name)
|
|
|
|
// Awkward but... reload this very same window.
|
|
// Otherwise, the window doesn't update to show the new
|
|
// layer having been added.
|
|
u.layersWindow.Hide()
|
|
u.layersWindow = nil
|
|
u.SetupPopups(d)
|
|
u.layersWindow.Show()
|
|
},
|
|
OnChangeLayer: func(index int) {
|
|
if index < 0 || index >= len(scene.Doodad.Layers) {
|
|
d.Flash("OnChangeLayer: layer %d out of range", index)
|
|
return
|
|
}
|
|
|
|
log.Info("CHANGE DOODAD LAYER TO %d", index)
|
|
u.Canvas.LoadDoodadToLayer(u.Scene.Doodad, index)
|
|
u.Scene.ActiveLayer = index
|
|
},
|
|
OnCancel: func() {
|
|
u.layersWindow.Hide()
|
|
},
|
|
})
|
|
configure(u.layersWindow)
|
|
}
|
|
}
|