package doodle import ( "fmt" "path/filepath" "strings" "git.kirsle.net/SketchyMaze/doodle/pkg/balance" "git.kirsle.net/SketchyMaze/doodle/pkg/doodads" "git.kirsle.net/SketchyMaze/doodle/pkg/drawtool" "git.kirsle.net/SketchyMaze/doodle/pkg/level" "git.kirsle.net/SketchyMaze/doodle/pkg/license" "git.kirsle.net/SketchyMaze/doodle/pkg/log" "git.kirsle.net/SketchyMaze/doodle/pkg/modal" "git.kirsle.net/SketchyMaze/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.Close() 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.Close() 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() u.Supervisor.FocusWindow(u.doodadWindow) } // OpenTextTool opens the Text Tool window. func (u *EditorUI) OpenTextTool() { u.textToolWindow.Show() u.Supervisor.FocusWindow(u.textToolWindow) } // OpenPublishWindow opens the Publisher window. func (u *EditorUI) OpenPublishWindow() { scene, _ := u.d.Scene.(*EditorScene) u.publishWindow = windows.NewPublishWindow(windows.Publish{ Supervisor: u.Supervisor, Engine: u.d.Engine, Level: scene.Level, OnPublish: func(includeBuiltins bool) { u.d.FlashError("OnPublish Called") // XXX: Paid Version Only. if !license.IsRegistered() { if u.licenseWindow != nil { u.licenseWindow.Show() u.Supervisor.FocusWindow(u.licenseWindow) } u.d.FlashError("Level Publishing is only available in the full version of the game.") return } // NOTE: this function just saves the level. SaveDoodads and SaveBuiltins // are toggled in the publish window and the save handler does publishing. u.Scene.SaveLevel(u.Scene.filename) u.d.Flash("Saved level: %s", u.Scene.filename) }, OnCancel: func() { u.publishWindow.Close() }, }) u.ConfigureWindow(u.d, u.publishWindow) u.publishWindow.Close() // u.publishWindow = nil u.SetupPopups(u.d) u.publishWindow.Show() } // OpenPublishWindow opens the FileSystem window. func (u *EditorUI) OpenFileSystemWindow() { u.filesystemWindow.Close() u.filesystemWindow = nil u.SetupPopups(u.d) u.filesystemWindow.Show() } // ConfigureWindow sets default window config functions, like // centering them on screen. func (u *EditorUI) ConfigureWindow(d *Doodle, 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.Close() } // SetupPopups preloads popup windows like the DoodadDropper. func (u *EditorUI) SetupPopups(d *Doodle) { // License Registration Window. if u.licenseWindow == nil { cfg := windows.License{ Supervisor: u.Supervisor, Engine: d.Engine, OnCancel: func() { u.licenseWindow.Close() }, } cfg.OnLicensed = func() { // License status has changed, reload the window! if u.licenseWindow != nil { u.licenseWindow.Close() } u.licenseWindow = windows.MakeLicenseWindow(d.width, d.height, cfg) } cfg.OnLicensed() u.licenseWindow.Close() } // 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.Close() }, }) u.ConfigureWindow(d, u.doodadWindow) } // Text Tool window. if u.textToolWindow == nil { u.textToolWindow = windows.NewTextToolWindow(windows.TextTool{ Supervisor: u.Supervisor, Engine: d.Engine, OnChangeSettings: func(font string, size int, message string) { log.Info("Updated Text Tool settings: %s (%d): %s", font, size, message) drawtool.TT = drawtool.TextSettings{ Font: font, Size: size, Message: message, } }, }) u.ConfigureWindow(d, u.textToolWindow) } // 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.Destroy() // clean up old textures u.Canvas.LoadLevel(scene.Level) }, OnUpdateScreenshot: func() error { return scene.UpdateLevelScreenshot(scene.Level) }, OnReload: func() { log.Warn("RELOAD LEVEL") scene.Reset() }, OnCancel: func() { u.levelSettingsWindow.Close() }, }) u.ConfigureWindow(d, u.levelSettingsWindow) } // Doodad Properties if u.doodadPropertiesWindow == nil { scene, _ := d.Scene.(*EditorScene) cfg := &windows.DoodadProperties{ Supervisor: u.Supervisor, Engine: d.Engine, EditDoodad: scene.Doodad, } // Rebuild the window. TODO: hacky af. cfg.OnRefresh = func() { u.doodadPropertiesWindow.Close() u.doodadPropertiesWindow = nil u.SetupPopups(u.d) u.doodadPropertiesWindow.Show() } u.doodadPropertiesWindow = windows.NewDoodadPropertiesWindow(cfg) u.ConfigureWindow(d, u.doodadPropertiesWindow) } // 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.Close() }, }) u.ConfigureWindow(d, 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(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() } // Flush the palette cache in case swatches got renamed, // so it rebuilds the "color by name" map from scratch. pal.FlushCaches() // 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, err := pal.NewSwatch() if err != nil { modal.Alert("Couldn't add this swatch: %s", err).WithTitle("Limit Reached") return } log.Info("Added new palette color: %+v", sw) // Awkward but... reload this very same window. u.paletteEditor.Close() u.paletteEditor = nil u.SetupPopups(d) u.paletteEditor.Show() }, OnCancel: func() { u.paletteEditor.Close() }, }) u.ConfigureWindow(d, 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.Close() u.layersWindow = nil u.SetupPopups(d) u.layersWindow.Show() }, OnAddLayer: func() { layer := scene.Doodad.AddLayer( fmt.Sprintf("layer %d", len(scene.Doodad.Layers)), nil, ) 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.Close() u.layersWindow = nil u.SetupPopups(d) u.layersWindow.Show() }, OnChangeLayer: func(index int) { if index < 0 || index >= len(scene.Doodad.Layers) { d.FlashError("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.Close() }, }) u.ConfigureWindow(d, u.layersWindow) } }