Noah Petherbridge
ffc2c6f69b
Previously: the Chunker tracks with chunks were gotten during the current game tick and the N-1 and N-2 ticks, and chunks not accessed in two ticks were freed immediately. Now: they go into a "garbage collection" pool with a minimum number of game ticks to free. So if they're needed again, they're saved from the gc pool. F3 overlay data shows the count of the gc pool.
625 lines
16 KiB
Go
625 lines
16 KiB
Go
package doodle
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.kirsle.net/apps/doodle/pkg/balance"
|
|
"git.kirsle.net/apps/doodle/pkg/cursor"
|
|
"git.kirsle.net/apps/doodle/pkg/doodads"
|
|
"git.kirsle.net/apps/doodle/pkg/drawtool"
|
|
"git.kirsle.net/apps/doodle/pkg/enum"
|
|
"git.kirsle.net/apps/doodle/pkg/keybind"
|
|
"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/modal/loadscreen"
|
|
"git.kirsle.net/apps/doodle/pkg/usercfg"
|
|
"git.kirsle.net/apps/doodle/pkg/userdir"
|
|
"git.kirsle.net/apps/doodle/pkg/windows"
|
|
"git.kirsle.net/go/render"
|
|
"git.kirsle.net/go/render/event"
|
|
)
|
|
|
|
// EditorScene manages the "Edit Level" game mode.
|
|
type EditorScene struct {
|
|
// Configuration for the scene initializer.
|
|
DrawingType enum.DrawingType
|
|
OpenFile bool
|
|
Filename string
|
|
DoodadSize int
|
|
RememberScrollPosition render.Point // Play mode remembers it for us
|
|
|
|
UI *EditorUI
|
|
d *Doodle
|
|
|
|
// The current level or doodad object being edited, based on the
|
|
// DrawingType.
|
|
Level *level.Level
|
|
Doodad *doodads.Doodad
|
|
ActiveLayer int // which layer (of a doodad) is being edited now?
|
|
|
|
// Custom debug overlay values.
|
|
debTool *string
|
|
debSwatch *string
|
|
debWorldIndex *string
|
|
debLoadingViewport *string
|
|
|
|
// Last saved filename by the user.
|
|
filename string
|
|
|
|
lastAutosaveAt time.Time
|
|
}
|
|
|
|
// Name of the scene.
|
|
func (s *EditorScene) Name() string {
|
|
return "Edit"
|
|
}
|
|
|
|
// Setup the editor scene.
|
|
func (s *EditorScene) Setup(d *Doodle) error {
|
|
// Debug overlay values.
|
|
s.debTool = new(string)
|
|
s.debSwatch = new(string)
|
|
s.debWorldIndex = new(string)
|
|
s.debLoadingViewport = new(string)
|
|
customDebugLabels = []debugLabel{
|
|
{"Pixel:", s.debWorldIndex},
|
|
{"Tool:", s.debTool},
|
|
{"Swatch:", s.debSwatch},
|
|
{"Chunks:", s.debLoadingViewport},
|
|
}
|
|
|
|
// Initialize autosave time.
|
|
s.lastAutosaveAt = time.Now()
|
|
|
|
// Show the loading screen.
|
|
loadscreen.ShowWithProgress()
|
|
go func() {
|
|
if err := s.setupAsync(d); err != nil {
|
|
log.Error("EditorScene.setupAsync: %s", err)
|
|
}
|
|
loadscreen.Hide()
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
// Reset the editor scene from scratch. Good nuclear option when you change the level's
|
|
// palette on-the-fly or some other sticky situation and want to reload the editor.
|
|
func (s *EditorScene) Reset() {
|
|
if s.Level != nil {
|
|
s.Level.Chunker.Redraw()
|
|
}
|
|
if s.Doodad != nil {
|
|
s.Doodad.Layers[s.ActiveLayer].Chunker.Redraw()
|
|
}
|
|
|
|
s.d.Goto(&EditorScene{
|
|
Filename: s.Filename,
|
|
Level: s.Level,
|
|
Doodad: s.Doodad,
|
|
})
|
|
}
|
|
|
|
// setupAsync initializes trhe editor scene in the background,
|
|
// underneath a loading screen.
|
|
func (s *EditorScene) setupAsync(d *Doodle) error {
|
|
// Initialize the user interface. It references the palette and such so it
|
|
// must be initialized after those things.
|
|
s.d = d
|
|
s.UI = NewEditorUI(d, s)
|
|
|
|
// Were we given configuration data?
|
|
if s.Filename != "" {
|
|
log.Debug("EditorScene.Setup: Set filename to %s", s.Filename)
|
|
s.filename = s.Filename
|
|
s.Filename = ""
|
|
}
|
|
|
|
// Loading a Level or a Doodad?
|
|
switch s.DrawingType {
|
|
case enum.LevelDrawing:
|
|
if s.Level != nil {
|
|
log.Debug("EditorScene.Setup: received level from scene caller")
|
|
loadscreen.SetSubtitle(
|
|
"Opening: "+s.Level.Title,
|
|
"by "+s.Level.Author,
|
|
)
|
|
s.UI.Canvas.LoadLevel(s.Level)
|
|
s.UI.Canvas.InstallActors(s.Level.Actors)
|
|
} else if s.filename != "" && s.OpenFile {
|
|
log.Debug("EditorScene.Setup: Loading map from filename at %s", s.filename)
|
|
loadscreen.SetSubtitle(
|
|
"Opening: " + s.filename,
|
|
)
|
|
if err := s.LoadLevel(s.filename); err != nil {
|
|
d.FlashError("LoadLevel error: %s", err)
|
|
} else {
|
|
s.UI.Canvas.InstallActors(s.Level.Actors)
|
|
}
|
|
}
|
|
|
|
// Write locked level?
|
|
if s.Level != nil && s.Level.Locked {
|
|
if usercfg.Current.WriteLockOverride {
|
|
d.Flash("Note: write lock has been overridden")
|
|
} else {
|
|
d.FlashError("That level is write-protected and cannot be viewed in the editor.")
|
|
s.Level = nil
|
|
s.UI.Canvas.ClearActors()
|
|
s.filename = ""
|
|
}
|
|
}
|
|
|
|
// No level?
|
|
if s.Level == nil {
|
|
log.Debug("EditorScene.Setup: initializing a new Level")
|
|
s.Level = level.New()
|
|
s.Level.Palette = level.DefaultPalette()
|
|
s.UI.Canvas.LoadLevel(s.Level)
|
|
s.UI.Canvas.ScrollTo(render.Origin)
|
|
s.UI.Canvas.Scrollable = true
|
|
}
|
|
|
|
// Update the loading screen with level info.
|
|
loadscreen.SetSubtitle(
|
|
"Opening: "+s.Level.Title,
|
|
"by "+s.Level.Author,
|
|
)
|
|
case enum.DoodadDrawing:
|
|
// Getting a doodad from file?
|
|
if s.filename != "" && s.OpenFile {
|
|
log.Debug("EditorScene.Setup: Loading doodad from filename at %s", s.filename)
|
|
if err := s.LoadDoodad(s.filename); err != nil {
|
|
d.FlashError("LoadDoodad error: %s", err)
|
|
}
|
|
}
|
|
|
|
// Write locked doodad?
|
|
if s.Doodad != nil && s.Doodad.Locked {
|
|
if usercfg.Current.WriteLockOverride {
|
|
d.Flash("Note: write lock has been overridden")
|
|
} else {
|
|
d.FlashError("That doodad is write-protected and cannot be viewed in the editor.")
|
|
s.Doodad = nil
|
|
s.filename = ""
|
|
}
|
|
}
|
|
|
|
// No Doodad?
|
|
if s.Doodad == nil {
|
|
log.Debug("EditorScene.Setup: initializing a new Doodad")
|
|
s.Doodad = doodads.New(s.DoodadSize)
|
|
s.UI.Canvas.LoadDoodad(s.Doodad)
|
|
}
|
|
|
|
// Update the loading screen with level info.
|
|
loadscreen.SetSubtitle(
|
|
s.Doodad.Title,
|
|
"by "+s.Doodad.Author,
|
|
)
|
|
|
|
// TODO: move inside the UI. Just an approximate position for now.
|
|
s.UI.Canvas.Resize(render.NewRect(s.DoodadSize, s.DoodadSize))
|
|
s.UI.Canvas.ScrollTo(render.Origin)
|
|
s.UI.Canvas.Scrollable = false
|
|
s.UI.Workspace.Compute(d.Engine)
|
|
}
|
|
|
|
// Pre-cache all bitmap images from the level chunks.
|
|
// Note: we are not running on the main thread, so SDL2 Textures
|
|
// don't get created yet, but we do the full work of caching bitmap
|
|
// images which later get fed directly into SDL2 saving speed at
|
|
// runtime, + the bitmap generation is pretty wicked fast anyway.
|
|
loadscreen.PreloadAllChunkBitmaps(s.UI.Canvas.Chunker())
|
|
|
|
// Recompute the UI Palette window for the level's palette.
|
|
s.UI.FinishSetup(d)
|
|
|
|
// Scroll the level to the remembered position from when we went
|
|
// to Play Mode and back. If no remembered position, this is zero
|
|
// anyway.
|
|
if s.RememberScrollPosition.IsZero() && s.Level != nil {
|
|
s.UI.Canvas.ScrollTo(s.Level.ScrollPosition)
|
|
} else {
|
|
s.UI.Canvas.ScrollTo(s.RememberScrollPosition)
|
|
}
|
|
|
|
d.Flash("Editor Mode.")
|
|
if s.DrawingType == enum.LevelDrawing {
|
|
d.Flash("Press 'P' to playtest this level.")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Playtest switches the level into Play Mode.
|
|
func (s *EditorScene) Playtest() {
|
|
log.Info("Play Mode, Go!")
|
|
s.d.Goto(&PlayScene{
|
|
Filename: s.filename,
|
|
Level: s.Level,
|
|
CanEdit: true,
|
|
RememberScrollPosition: s.UI.Canvas.Scroll,
|
|
})
|
|
}
|
|
|
|
// PlaytestFrom enters play mode starting at a custom spawn point.
|
|
func (s *EditorScene) PlaytestFrom(p render.Point) {
|
|
log.Info("Play Mode, Go!")
|
|
s.d.Goto(&PlayScene{
|
|
Filename: s.filename,
|
|
Level: s.Level,
|
|
CanEdit: true,
|
|
RememberScrollPosition: s.UI.Canvas.Scroll,
|
|
SpawnPoint: p,
|
|
})
|
|
}
|
|
|
|
// ConfirmUnload may pop up a confirmation modal to save the level before the
|
|
// user performs an action that may close the level, such as click File->New.
|
|
func (s *EditorScene) ConfirmUnload(fn func()) {
|
|
if !s.UI.Canvas.Modified() {
|
|
fn()
|
|
return
|
|
}
|
|
|
|
modal.Confirm(
|
|
"This drawing has unsaved changes. Are you sure you\nwant to continue and lose your changes?",
|
|
).WithTitle("Confirm Closing Drawing").Then(fn)
|
|
}
|
|
|
|
// Loop the editor scene.
|
|
func (s *EditorScene) Loop(d *Doodle, ev *event.State) error {
|
|
// Skip if still loading.
|
|
if loadscreen.IsActive() {
|
|
return nil
|
|
}
|
|
|
|
// Update debug overlay values.
|
|
*s.debTool = s.UI.Canvas.Tool.String()
|
|
*s.debSwatch = "???"
|
|
*s.debWorldIndex = s.UI.Canvas.WorldIndexAt(s.UI.cursor).String()
|
|
*s.debLoadingViewport = "???"
|
|
|
|
// Safely...
|
|
if s.UI.Canvas.Palette != nil && s.UI.Canvas.Palette.ActiveSwatch != nil {
|
|
*s.debSwatch = s.UI.Canvas.Palette.ActiveSwatch.Name
|
|
}
|
|
if s.UI.Canvas != nil {
|
|
inside, outside := s.UI.Canvas.LoadUnloadMetrics()
|
|
*s.debLoadingViewport = fmt.Sprintf("%d in %d out %d cached %d gc", inside, outside, s.UI.Canvas.Chunker().CacheSize(), s.UI.Canvas.Chunker().GCSize())
|
|
}
|
|
|
|
// Has the window been resized?
|
|
if ev.WindowResized {
|
|
s.UI.Resized(d)
|
|
return nil
|
|
}
|
|
|
|
// Run all of the keybinds.
|
|
binders := []struct {
|
|
v bool
|
|
f func()
|
|
}{
|
|
{
|
|
keybind.NewLevel(ev), func() {
|
|
// Ctrl-N, New Level
|
|
s.MenuNewLevel()
|
|
},
|
|
},
|
|
{
|
|
keybind.SaveAs(ev), func() {
|
|
// Shift-Ctrl-S, Save As
|
|
s.MenuSave(true)()
|
|
},
|
|
},
|
|
{
|
|
keybind.Save(ev), func() {
|
|
// Ctrl-S, Save
|
|
s.MenuSave(false)()
|
|
},
|
|
},
|
|
{
|
|
keybind.Open(ev), func() {
|
|
// Ctrl-O, Open
|
|
s.MenuOpen()
|
|
},
|
|
},
|
|
{
|
|
keybind.Undo(ev), func() {
|
|
// Ctrl-Z, Undo
|
|
s.UI.Canvas.UndoStroke()
|
|
ev.ResetKeyDown()
|
|
},
|
|
},
|
|
{
|
|
keybind.Redo(ev), func() {
|
|
// Ctrl-Y, Undo
|
|
s.UI.Canvas.RedoStroke()
|
|
ev.ResetKeyDown()
|
|
},
|
|
},
|
|
{
|
|
|
|
keybind.ZoomIn(ev), func() {
|
|
s.UI.Canvas.Zoom++
|
|
ev.ResetKeyDown()
|
|
},
|
|
},
|
|
{
|
|
keybind.ZoomOut(ev), func() {
|
|
s.UI.Canvas.Zoom--
|
|
ev.ResetKeyDown()
|
|
},
|
|
},
|
|
{
|
|
keybind.ZoomReset(ev), func() {
|
|
s.UI.Canvas.Zoom = 0
|
|
ev.ResetKeyDown()
|
|
},
|
|
},
|
|
{
|
|
keybind.Origin(ev), func() {
|
|
d.Flash("Scrolled back to level origin (0,0)")
|
|
s.UI.Canvas.ScrollTo(render.Origin)
|
|
ev.ResetKeyDown()
|
|
},
|
|
},
|
|
{
|
|
keybind.CloseAllWindows(ev), func() {
|
|
s.UI.Supervisor.CloseAllWindows()
|
|
},
|
|
},
|
|
{
|
|
keybind.CloseTopmostWindow(ev), func() {
|
|
s.UI.Supervisor.CloseActiveWindow()
|
|
},
|
|
},
|
|
{
|
|
keybind.NewViewport(ev), func() {
|
|
if s.DrawingType != enum.LevelDrawing {
|
|
return
|
|
}
|
|
|
|
pip := windows.MakePiPWindow(d.width, d.height, windows.PiP{
|
|
Supervisor: s.UI.Supervisor,
|
|
Engine: s.d.Engine,
|
|
Level: s.Level,
|
|
Event: s.d.event,
|
|
|
|
Tool: &s.UI.Canvas.Tool,
|
|
BrushSize: &s.UI.Canvas.BrushSize,
|
|
})
|
|
|
|
pip.Show()
|
|
},
|
|
},
|
|
}
|
|
for _, bind := range binders {
|
|
if bind.v {
|
|
bind.f()
|
|
}
|
|
}
|
|
|
|
// s.UI.Loop(ev)
|
|
|
|
// Switching to Play Mode?
|
|
if s.DrawingType == enum.LevelDrawing && keybind.GotoPlay(ev) {
|
|
s.Playtest()
|
|
} else if keybind.LineTool(ev) {
|
|
d.Flash("Line Tool selected.")
|
|
s.UI.Canvas.Tool = drawtool.LineTool
|
|
s.UI.activeTool = s.UI.Canvas.Tool.String()
|
|
} else if keybind.PencilTool(ev) {
|
|
d.Flash("Pencil Tool selected.")
|
|
s.UI.Canvas.Tool = drawtool.PencilTool
|
|
s.UI.activeTool = s.UI.Canvas.Tool.String()
|
|
} else if keybind.RectTool(ev) {
|
|
d.Flash("Rectangle Tool selected.")
|
|
s.UI.Canvas.Tool = drawtool.RectTool
|
|
s.UI.activeTool = s.UI.Canvas.Tool.String()
|
|
} else if keybind.EllipseTool(ev) {
|
|
d.Flash("Ellipse Tool selected.")
|
|
s.UI.Canvas.Tool = drawtool.EllipseTool
|
|
s.UI.activeTool = s.UI.Canvas.Tool.String()
|
|
} else if keybind.EraserTool(ev) {
|
|
d.Flash("Eraser Tool selected.")
|
|
s.UI.Canvas.Tool = drawtool.EraserTool
|
|
s.UI.activeTool = s.UI.Canvas.Tool.String()
|
|
} else if keybind.DoodadDropper(ev) {
|
|
s.UI.OpenDoodadDropper()
|
|
}
|
|
|
|
s.UI.Loop(ev)
|
|
|
|
// Trigger auto-save of the level in case of crash or accidental closure.
|
|
if time.Since(s.lastAutosaveAt) > balance.AutoSaveInterval {
|
|
s.lastAutosaveAt = time.Now()
|
|
if !usercfg.Current.DisableAutosave {
|
|
if err := s.AutoSave(); err != nil {
|
|
d.FlashError("Autosave error: %s", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Draw the current frame.
|
|
func (s *EditorScene) Draw(d *Doodle) error {
|
|
// Skip if still loading.
|
|
if loadscreen.IsActive() {
|
|
return nil
|
|
}
|
|
|
|
// Clear the canvas and fill it with magenta so it's clear if any spots are missed.
|
|
d.Engine.Clear(render.RGBA(160, 120, 160, 255))
|
|
|
|
s.UI.Present(d.Engine)
|
|
|
|
return nil
|
|
}
|
|
|
|
// LoadLevel loads a level from disk.
|
|
func (s *EditorScene) LoadLevel(filename string) error {
|
|
s.filename = filename
|
|
|
|
level, err := level.LoadFile(filename)
|
|
if err != nil {
|
|
return fmt.Errorf("EditorScene.LoadLevel(%s): %s", filename, err)
|
|
}
|
|
|
|
s.DrawingType = enum.LevelDrawing
|
|
s.Level = level
|
|
s.UI.Canvas.LoadLevel(s.Level)
|
|
|
|
log.Info("Installing %d actors into the drawing", len(level.Actors))
|
|
if err := s.UI.Canvas.InstallActors(level.Actors); err != nil {
|
|
summary := "This level references some doodads that were not found:"
|
|
if strings.Contains(err.Error(), license.ErrRegisteredFeature.Error()) {
|
|
summary = "This level contains embedded doodads, but this is not\n" +
|
|
"available in the free version of the game. The following\n" +
|
|
"doodads could not be loaded:"
|
|
}
|
|
modal.Alert("%s\n\n%s", summary, err).WithTitle("Level Errors")
|
|
return fmt.Errorf("EditorScene.LoadLevel: InstallActors: %s", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SaveLevel saves the level to disk.
|
|
func (s *EditorScene) SaveLevel(filename string) error {
|
|
if s.DrawingType != enum.LevelDrawing {
|
|
return errors.New("SaveLevel: current drawing is not a Level type")
|
|
}
|
|
|
|
if !strings.HasSuffix(filename, enum.LevelExt) {
|
|
filename += enum.LevelExt
|
|
}
|
|
|
|
s.filename = filename
|
|
|
|
m := s.Level
|
|
if m.Title == "" {
|
|
m.Title = "Alpha"
|
|
}
|
|
if m.Author == "" {
|
|
m.Author = os.Getenv("USER")
|
|
}
|
|
|
|
m.Palette = s.UI.Canvas.Palette
|
|
m.Chunker = s.UI.Canvas.Chunker()
|
|
|
|
// Store the scroll position.
|
|
m.ScrollPosition = s.UI.Canvas.Scroll
|
|
|
|
// Clear the modified flag on the level.
|
|
s.UI.Canvas.SetModified(false)
|
|
|
|
// Attach doodads to the level on save.
|
|
if err := publishing.Publish(m); err != nil {
|
|
log.Error("Error publishing level: %s", err.Error())
|
|
}
|
|
|
|
s.lastAutosaveAt = time.Now()
|
|
return m.WriteFile(filename)
|
|
}
|
|
|
|
// AutoSave takes an autosave snapshot of the level or drawing.
|
|
func (s *EditorScene) AutoSave() error {
|
|
var (
|
|
filename = "_autosave.level"
|
|
err error
|
|
)
|
|
|
|
s.d.FlashError("Beginning AutoSave() in a background thread")
|
|
|
|
// Trigger the auto-save in the background to not block the main thread.
|
|
go func() {
|
|
var err error
|
|
switch s.DrawingType {
|
|
case enum.LevelDrawing:
|
|
err = s.Level.WriteFile(filename)
|
|
s.d.Flash("Automatically saved level to %s", filename)
|
|
case enum.DoodadDrawing:
|
|
filename = "_autosave.doodad"
|
|
err = s.Doodad.WriteFile(filename)
|
|
s.d.Flash("Automatically saved doodad to %s", filename)
|
|
}
|
|
|
|
if err != nil {
|
|
s.d.FlashError("Error saving %s: %s", filename, err)
|
|
}
|
|
}()
|
|
|
|
return err
|
|
}
|
|
|
|
// LoadDoodad loads a doodad from disk.
|
|
func (s *EditorScene) LoadDoodad(filename string) error {
|
|
s.filename = filename
|
|
|
|
doodad, err := doodads.LoadFile(filename)
|
|
if err != nil {
|
|
return fmt.Errorf("EditorScene.LoadDoodad(%s): %s", filename, err)
|
|
}
|
|
|
|
s.DrawingType = enum.DoodadDrawing
|
|
s.Doodad = doodad
|
|
s.DoodadSize = doodad.Layers[0].Chunker.Size
|
|
s.UI.Canvas.LoadDoodad(s.Doodad)
|
|
return nil
|
|
}
|
|
|
|
// SaveDoodad saves the doodad to disk.
|
|
func (s *EditorScene) SaveDoodad(filename string) error {
|
|
if s.DrawingType != enum.DoodadDrawing {
|
|
return errors.New("SaveDoodad: current drawing is not a Doodad type")
|
|
}
|
|
|
|
if !strings.HasSuffix(filename, enum.DoodadExt) {
|
|
filename += enum.DoodadExt
|
|
}
|
|
|
|
s.filename = filename
|
|
d := s.Doodad
|
|
if d.Title == "" {
|
|
d.Title = "Untitled Doodad"
|
|
}
|
|
if d.Author == "" {
|
|
d.Author = os.Getenv("USER")
|
|
}
|
|
|
|
// TODO: is this copying necessary?
|
|
d.Palette = s.UI.Canvas.Palette
|
|
d.Layers[s.ActiveLayer].Chunker = s.UI.Canvas.Chunker()
|
|
|
|
// Clear the modified flag on the level.
|
|
s.UI.Canvas.SetModified(false)
|
|
|
|
// Save it to their profile directory.
|
|
filename = userdir.DoodadPath(filename)
|
|
log.Info("Write Doodad: %s", filename)
|
|
return d.WriteFile(filename)
|
|
}
|
|
|
|
// Destroy the scene.
|
|
func (s *EditorScene) Destroy() error {
|
|
// Free SDL2 textures. Note: if they are switching to the Editor, the chunks still have
|
|
// their bitmaps cached and will regen the textures as needed.
|
|
s.UI.Teardown()
|
|
|
|
// Reset the cursor to default.
|
|
cursor.Current = cursor.NewPointer(s.d.Engine)
|
|
|
|
return nil
|
|
}
|