New features: * Flood Tool for the editor. It replaces pixels of one color with another, contiguously. Has limits on how far from the original pixel it will color, to avoid infinite loops in case the user clicked on wide open void. The limit when clicking an existing color is 1200px or only a 600px limit if clicking into the void. * Cheat code: 'master key' to play locked Story Mode levels. Level GameRules feature added: * A new tab in the Level Properties dialog * Difficulty has been moved to this tab * Survival Mode: for silver high score, longest time alive is better than fastest time, for Azulian Tag maps. Gold high score is still based on fastest time - find the hidden level exit without dying! Tweaks to the Azulians' jump heights: * Blue Azulian: 12 -> 14 * Red Azulian: 14 -> 18 * White Azulian: 16 -> 20 Bugs fixed: * When editing your Palette to rename a color or add a new color, it wasn't possible to draw with that color until the editor was completely unloaded and reloaded; this is now fixed. * Minor bugfix in Difficulty.String() for Peaceful (-1) difficulty to avoid a negative array index. * Try and prevent user giving the same name to multiple swatches on their palette. Replacing the whole palette can let duplication through still.
608 lines
15 KiB
Go
608 lines
15 KiB
Go
package windows
|
|
|
|
import (
|
|
"fmt"
|
|
"regexp"
|
|
"strconv"
|
|
|
|
"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/modal"
|
|
"git.kirsle.net/apps/doodle/pkg/native"
|
|
"git.kirsle.net/apps/doodle/pkg/shmem"
|
|
magicform "git.kirsle.net/apps/doodle/pkg/uix/magic-form"
|
|
"git.kirsle.net/apps/doodle/pkg/wallpaper"
|
|
"git.kirsle.net/go/render"
|
|
"git.kirsle.net/go/ui"
|
|
)
|
|
|
|
// AddEditLevel is the "Create New Level & Edit Level Properties" window
|
|
type AddEditLevel struct {
|
|
Supervisor *ui.Supervisor
|
|
Engine render.Engine
|
|
|
|
// Editing settings for an existing level?
|
|
EditLevel *level.Level
|
|
|
|
// Callback functions.
|
|
OnChangePageTypeAndWallpaper func(pageType level.PageType, wallpaper string)
|
|
OnCreateNewLevel func(*level.Level)
|
|
OnCreateNewDoodad func(size int)
|
|
OnReload func()
|
|
OnCancel func()
|
|
}
|
|
|
|
// NewAddEditLevel initializes the window.
|
|
func NewAddEditLevel(config AddEditLevel) *ui.Window {
|
|
// Default options.
|
|
var (
|
|
title = "New Drawing"
|
|
)
|
|
|
|
// Given a level to edit?
|
|
if config.EditLevel != nil {
|
|
title = "Level Properties"
|
|
}
|
|
|
|
window := ui.NewWindow(title)
|
|
window.SetButtons(ui.CloseButton)
|
|
window.Configure(ui.Config{
|
|
Width: 400,
|
|
Height: 290,
|
|
Background: render.Grey,
|
|
})
|
|
|
|
// Tabbed UI for New Level or New Doodad.
|
|
tabframe := ui.NewTabFrame("Level Tabs")
|
|
window.Pack(tabframe, ui.Pack{
|
|
Side: ui.N,
|
|
Fill: true,
|
|
Expand: true,
|
|
})
|
|
|
|
// Add the tabs.
|
|
config.setupLevelFrame(tabframe) // Level Properties (always)
|
|
if config.EditLevel == nil {
|
|
// New Doodad properties (New window only)
|
|
config.setupDoodadFrame(tabframe)
|
|
} else {
|
|
// Additional Level tabs (existing level only)
|
|
config.setupGameRuleFrame(tabframe)
|
|
}
|
|
|
|
tabframe.Supervise(config.Supervisor)
|
|
|
|
window.Hide()
|
|
return window
|
|
}
|
|
|
|
// Creates the Create/Edit Level tab ("index").
|
|
func (config AddEditLevel) setupLevelFrame(tf *ui.TabFrame) {
|
|
// Default options.
|
|
var (
|
|
tabLabel = "New Level"
|
|
newPageType = level.Bounded.String()
|
|
newWallpaper = "notebook.png"
|
|
paletteName = level.DefaultPaletteNames[0]
|
|
isNewLevel = config.EditLevel == nil
|
|
|
|
// Default text for the Palette drop-down for already-existing levels.
|
|
// (needs --experimental feature flag to enable the UI).
|
|
textCurrentPalette = "Keep current palette"
|
|
|
|
// For NEW levels, if a custom wallpaper is selected from disk, cache
|
|
// it in these vars. For pre-existing levels, the wallpaper updates
|
|
// immediately in the live config.EditLevel object.
|
|
newWallpaperB64 string
|
|
)
|
|
|
|
// Given a level to edit?
|
|
if !isNewLevel {
|
|
tabLabel = "Properties"
|
|
newPageType = config.EditLevel.PageType.String()
|
|
newWallpaper = config.EditLevel.Wallpaper
|
|
paletteName = textCurrentPalette
|
|
}
|
|
|
|
frame := tf.AddTab("index", ui.NewLabel(ui.Label{
|
|
Text: tabLabel,
|
|
Font: balance.TabFont,
|
|
}))
|
|
|
|
/******************
|
|
* Frame for selecting Page Type
|
|
******************/
|
|
|
|
// Selected "Page Type" property.
|
|
var pageType = level.Bounded
|
|
if !isNewLevel {
|
|
pageType = config.EditLevel.PageType
|
|
}
|
|
|
|
form := magicform.Form{
|
|
Supervisor: config.Supervisor,
|
|
Engine: config.Engine,
|
|
Vertical: true,
|
|
LabelWidth: 120,
|
|
PadY: 2,
|
|
}
|
|
fields := []magicform.Field{
|
|
{
|
|
Label: "Page type:",
|
|
Font: balance.UIFont,
|
|
Options: []magicform.Option{
|
|
{
|
|
Label: "Bounded",
|
|
Value: level.Bounded,
|
|
},
|
|
{
|
|
Label: "Unbounded",
|
|
Value: level.Unbounded,
|
|
},
|
|
{
|
|
Label: "No Negative Space",
|
|
Value: level.NoNegativeSpace,
|
|
},
|
|
},
|
|
SelectValue: pageType,
|
|
OnSelect: func(v interface{}) {
|
|
value, _ := v.(level.PageType)
|
|
newPageType = value.String() // for the "New" screen background
|
|
config.OnChangePageTypeAndWallpaper(value, newWallpaper)
|
|
},
|
|
},
|
|
}
|
|
|
|
/******************
|
|
* Wallpaper settings
|
|
******************/
|
|
|
|
var selectedWallpaper = "notebook.png"
|
|
if config.EditLevel != nil {
|
|
selectedWallpaper = config.EditLevel.Wallpaper
|
|
}
|
|
|
|
fields = append(fields, []magicform.Field{
|
|
{
|
|
Label: "Wallpaper:",
|
|
Font: balance.UIFont,
|
|
SelectValue: selectedWallpaper,
|
|
Options: []magicform.Option{
|
|
{
|
|
Label: "Notebook",
|
|
Value: "notebook.png",
|
|
},
|
|
{
|
|
Label: "Legal Pad",
|
|
Value: "legal.png",
|
|
},
|
|
{
|
|
Label: "Graph paper",
|
|
Value: "graph.png",
|
|
},
|
|
{
|
|
Label: "Dotted paper",
|
|
Value: "dots.png",
|
|
},
|
|
{
|
|
Label: "Blueprint",
|
|
Value: "blueprint.png",
|
|
},
|
|
{
|
|
Label: "Pure white",
|
|
Value: "white.png",
|
|
},
|
|
{
|
|
Separator: true,
|
|
},
|
|
{
|
|
Label: "Custom wallpaper...",
|
|
Value: balance.CustomWallpaperFilename,
|
|
},
|
|
},
|
|
OnSelect: func(v interface{}) {
|
|
if filename, ok := v.(string); ok {
|
|
// Picking the Custom option?
|
|
if filename == balance.CustomWallpaperFilename {
|
|
filename, err := native.OpenFile("Choose a custom wallpaper:", "*.png *.jpg *.gif")
|
|
if err == nil {
|
|
b64data, err := wallpaper.FileToB64(filename)
|
|
if err != nil {
|
|
shmem.Flash("Error loading wallpaper: %s", err)
|
|
return
|
|
}
|
|
|
|
// If editing a level, apply the update straight away.
|
|
if config.EditLevel != nil {
|
|
config.EditLevel.SetFile(balance.CustomWallpaperEmbedPath, []byte(b64data))
|
|
newWallpaper = balance.CustomWallpaperFilename
|
|
|
|
// Trigger the page type change to the caller.
|
|
if pageType, ok := level.PageTypeFromString(newPageType); ok {
|
|
config.OnChangePageTypeAndWallpaper(pageType, balance.CustomWallpaperFilename)
|
|
}
|
|
} else {
|
|
// Hold onto the new wallpaper until the level is created.
|
|
newWallpaper = balance.CustomWallpaperFilename
|
|
newWallpaperB64 = b64data
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
if pageType, ok := level.PageTypeFromString(newPageType); ok {
|
|
config.OnChangePageTypeAndWallpaper(pageType, filename)
|
|
newWallpaper = filename
|
|
}
|
|
}
|
|
},
|
|
},
|
|
}...)
|
|
|
|
/******************
|
|
* Frame for picking a default color palette.
|
|
******************/
|
|
|
|
// For new level or --experimental only.
|
|
if config.EditLevel == nil || balance.Feature.ChangePalette {
|
|
var (
|
|
palettes = []magicform.Option{}
|
|
)
|
|
|
|
if config.EditLevel != nil {
|
|
palettes = append(palettes, []magicform.Option{
|
|
{
|
|
Label: paletteName, // "Keep current palette"
|
|
Value: paletteName,
|
|
},
|
|
{
|
|
Separator: true,
|
|
},
|
|
}...)
|
|
}
|
|
|
|
for _, palName := range level.DefaultPaletteNames {
|
|
palettes = append(palettes, magicform.Option{
|
|
Label: palName,
|
|
Value: palName,
|
|
})
|
|
}
|
|
|
|
// Add form fields.
|
|
fields = append(fields, []magicform.Field{
|
|
{
|
|
Label: "Palette:",
|
|
Font: balance.UIFont,
|
|
Options: palettes,
|
|
OnSelect: func(v interface{}) {
|
|
value, _ := v.(string)
|
|
paletteName = value
|
|
},
|
|
},
|
|
}...)
|
|
}
|
|
|
|
/******************
|
|
* Extended options for editing existing level (vs. Create New screen)
|
|
******************/
|
|
|
|
if config.EditLevel != nil {
|
|
var (
|
|
levelSizeStr = fmt.Sprintf("%dx%d", config.EditLevel.MaxWidth, config.EditLevel.MaxHeight)
|
|
levelSizeRegexp = regexp.MustCompile(`^(\d+)x(\d+)$`)
|
|
)
|
|
fields = append(fields, []magicform.Field{
|
|
{
|
|
Label: "Limits (bounded):",
|
|
Font: balance.UIFont,
|
|
TextVariable: &levelSizeStr,
|
|
OnClick: func() {
|
|
shmem.Prompt(fmt.Sprintf("Enter new limits in WxH format or [%s]: ", levelSizeStr), func(answer string) {
|
|
if answer == "" {
|
|
return
|
|
}
|
|
|
|
match := levelSizeRegexp.FindStringSubmatch(answer)
|
|
if match == nil {
|
|
return
|
|
}
|
|
|
|
levelSizeStr = match[0]
|
|
width, _ := strconv.Atoi(match[1])
|
|
height, _ := strconv.Atoi(match[2])
|
|
|
|
config.EditLevel.MaxWidth = int64(width)
|
|
config.EditLevel.MaxHeight = int64(height)
|
|
})
|
|
},
|
|
},
|
|
{
|
|
Label: "Metadata",
|
|
Font: balance.LabelFont,
|
|
},
|
|
{
|
|
Label: "Title:",
|
|
Font: balance.UIFont,
|
|
TextVariable: &config.EditLevel.Title,
|
|
PromptUser: func(answer string) {
|
|
config.EditLevel.Title = answer
|
|
},
|
|
},
|
|
{
|
|
Label: "Author:",
|
|
Font: balance.UIFont,
|
|
TextVariable: &config.EditLevel.Author,
|
|
PromptUser: func(answer string) {
|
|
config.EditLevel.Author = answer
|
|
},
|
|
},
|
|
}...)
|
|
}
|
|
|
|
// The confirm/cancel buttons.
|
|
var okLabel = "Apply"
|
|
if config.EditLevel == nil {
|
|
okLabel = "Continue"
|
|
}
|
|
fields = append(fields, []magicform.Field{
|
|
{
|
|
Buttons: []magicform.Field{
|
|
{
|
|
ButtonStyle: &balance.ButtonPrimary,
|
|
Label: okLabel,
|
|
Font: balance.UIFont,
|
|
OnClick: func() {
|
|
// Is it a NEW level?
|
|
if config.EditLevel == nil {
|
|
shmem.Flash("Create new map with %s page type and %s wallpaper", newPageType, newWallpaper)
|
|
pageType, ok := level.PageTypeFromString(newPageType)
|
|
if !ok {
|
|
shmem.Flash("Invalid Page Type '%s'", newPageType)
|
|
return
|
|
}
|
|
|
|
lvl := level.New()
|
|
lvl.Palette = level.DefaultPalettes[paletteName]
|
|
lvl.Wallpaper = newWallpaper
|
|
lvl.PageType = pageType
|
|
|
|
// Was a custom wallpaper selected for our NEW level?
|
|
if lvl.Wallpaper == balance.CustomWallpaperFilename && len(newWallpaperB64) > 0 {
|
|
lvl.SetFile(balance.CustomWallpaperEmbedPath, []byte(newWallpaperB64))
|
|
}
|
|
|
|
if config.OnCreateNewLevel != nil {
|
|
config.OnCreateNewLevel(lvl)
|
|
} else {
|
|
shmem.FlashError("OnCreateNewLevel not attached")
|
|
}
|
|
} else {
|
|
// Editing an existing level.
|
|
|
|
// If we're editing a level, did we select a new palette?
|
|
// Warn the user about if they want to change palettes.
|
|
if paletteName != textCurrentPalette {
|
|
modal.Confirm(
|
|
"Are you sure you want to change the level palette?\n" +
|
|
"Existing pixels drawn on your level may change, and\n" +
|
|
"if the new palette is smaller, some pixels may be\n" +
|
|
"lost from your level. OK to continue?",
|
|
).WithTitle("Change Level Palette").Then(func() {
|
|
// Install the new level palette.
|
|
config.EditLevel.ReplacePalette(level.DefaultPalettes[paletteName])
|
|
if config.OnReload != nil {
|
|
config.OnReload()
|
|
}
|
|
})
|
|
return
|
|
}
|
|
|
|
config.OnCancel()
|
|
}
|
|
},
|
|
},
|
|
{
|
|
Label: "Cancel",
|
|
Font: balance.UIFont,
|
|
OnClick: func() {
|
|
config.OnCancel()
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}...)
|
|
|
|
form.Create(frame, fields)
|
|
}
|
|
|
|
// Creates the "New Doodad" frame.
|
|
func (config AddEditLevel) setupDoodadFrame(tf *ui.TabFrame) {
|
|
// Default options.
|
|
var (
|
|
doodadSize = 64
|
|
)
|
|
|
|
frame := tf.AddTab("doodad", ui.NewLabel(ui.Label{
|
|
Text: "New Doodad",
|
|
Font: balance.TabFont,
|
|
}))
|
|
|
|
/******************
|
|
* Frame for selecting Page Type
|
|
******************/
|
|
|
|
typeFrame := ui.NewFrame("Doodad Options Frame")
|
|
frame.Pack(typeFrame, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
})
|
|
|
|
label1 := ui.NewLabel(ui.Label{
|
|
Text: "Doodad sprite size (square):",
|
|
Font: balance.LabelFont,
|
|
})
|
|
typeFrame.Pack(label1, ui.Pack{
|
|
Side: ui.W,
|
|
})
|
|
|
|
// A selectbox to suggest some sizes or let the user enter a custom.
|
|
sizeBtn := ui.NewSelectBox("Size Select", ui.Label{
|
|
Font: ui.MenuFont,
|
|
})
|
|
typeFrame.Pack(sizeBtn, ui.Pack{
|
|
Side: ui.W,
|
|
Expand: true,
|
|
})
|
|
|
|
for _, row := range []struct {
|
|
Name string
|
|
Value int
|
|
}{
|
|
{"32", 32},
|
|
{"64", 64},
|
|
{"96", 96},
|
|
{"128", 128},
|
|
{"200", 200},
|
|
{"256", 256},
|
|
{"Custom...", 0},
|
|
} {
|
|
row := row
|
|
sizeBtn.AddItem(row.Name, row.Value, func() {})
|
|
}
|
|
|
|
sizeBtn.SetValue(doodadSize)
|
|
sizeBtn.Handle(ui.Change, func(ed ui.EventData) error {
|
|
if selection, ok := sizeBtn.GetValue(); ok {
|
|
if size, ok := selection.Value.(int); ok {
|
|
if size == 0 {
|
|
shmem.Prompt("Enter a custom size for the doodad width and height: ", func(answer string) {
|
|
if a, err := strconv.Atoi(answer); err == nil && a > 0 {
|
|
doodadSize = a
|
|
} else {
|
|
shmem.FlashError("Doodad size should be a number greater than zero.")
|
|
}
|
|
})
|
|
} else {
|
|
doodadSize = size
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
|
|
sizeBtn.Supervise(config.Supervisor)
|
|
config.Supervisor.Add(sizeBtn)
|
|
|
|
/******************
|
|
* Confirm/cancel buttons.
|
|
******************/
|
|
|
|
bottomFrame := ui.NewFrame("Button Frame")
|
|
frame.Pack(bottomFrame, ui.Pack{
|
|
Side: ui.N,
|
|
FillX: true,
|
|
PadY: 8,
|
|
})
|
|
|
|
var buttons = []struct {
|
|
Label string
|
|
F func(ui.EventData) error
|
|
}{
|
|
{"Continue", func(ed ui.EventData) error {
|
|
if config.OnCreateNewDoodad != nil {
|
|
config.OnCreateNewDoodad(doodadSize)
|
|
} else {
|
|
shmem.FlashError("OnCreateNewDoodad not attached")
|
|
}
|
|
return nil
|
|
}},
|
|
|
|
{"Cancel", func(ed ui.EventData) error {
|
|
config.OnCancel()
|
|
return nil
|
|
}},
|
|
}
|
|
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)
|
|
config.Supervisor.Add(btn)
|
|
bottomFrame.Pack(btn, ui.Pack{
|
|
Side: ui.W,
|
|
PadX: 4,
|
|
PadY: 8,
|
|
})
|
|
}
|
|
}
|
|
|
|
// Creates the Game Rules frame for existing level (set difficulty, etc.)
|
|
func (config AddEditLevel) setupGameRuleFrame(tf *ui.TabFrame) {
|
|
frame := tf.AddTab("GameRules", ui.NewLabel(ui.Label{
|
|
Text: "Game Rules",
|
|
Font: balance.TabFont,
|
|
}))
|
|
|
|
form := magicform.Form{
|
|
Supervisor: config.Supervisor,
|
|
Engine: config.Engine,
|
|
Vertical: true,
|
|
LabelWidth: 120,
|
|
PadY: 2,
|
|
}
|
|
fields := []magicform.Field{
|
|
{
|
|
Label: "Game Rules are specific to this level and can change some of\n" +
|
|
"the game's default behaviors.",
|
|
Font: balance.UIFont,
|
|
},
|
|
{
|
|
Label: "Difficulty:",
|
|
Font: balance.UIFont,
|
|
SelectValue: config.EditLevel.GameRule.Difficulty,
|
|
Tooltip: ui.Tooltip{
|
|
Text: "Peaceful: enemies may not attack\n" +
|
|
"Normal: default difficulty\n" +
|
|
"Hard: enemies may be more aggressive",
|
|
Edge: ui.Top,
|
|
},
|
|
Options: []magicform.Option{
|
|
{
|
|
Label: "Peaceful",
|
|
Value: enum.Peaceful,
|
|
},
|
|
{
|
|
Label: "Normal (recommended)",
|
|
Value: enum.Normal,
|
|
},
|
|
{
|
|
Label: "Hard",
|
|
Value: enum.Hard,
|
|
},
|
|
},
|
|
OnSelect: func(v interface{}) {
|
|
value, _ := v.(enum.Difficulty)
|
|
config.EditLevel.GameRule.Difficulty = value
|
|
log.Info("Set level difficulty to: %d (%s)", value, value)
|
|
},
|
|
},
|
|
{
|
|
Label: "Survival Mode (silver high score)",
|
|
Font: balance.UIFont,
|
|
BoolVariable: &config.EditLevel.GameRule.Survival,
|
|
Tooltip: ui.Tooltip{
|
|
Text: "Use for levels where dying at least once is very likely\n" +
|
|
"(e.g. Azulian Tag). The silver high score will be for\n" +
|
|
"longest time rather than fastest time. The gold high\n" +
|
|
"score will still be for fastest time.",
|
|
Edge: ui.Top,
|
|
},
|
|
},
|
|
}
|
|
|
|
form.Create(frame, fields)
|
|
}
|