doodle/pkg/windows/doodad_properties.go
Noah Petherbridge 701073cecc Doodad/Actor Runtime Options
* Add "Options" support for Doodads: these allow for individual Actor instances
  on your level to customize properties about the doodad. They're like "Tags"
  except the player can customize them on a per-actor basis.
* Doodad Editor: you can specify the Options in the Doodad Properties window.
* Level Editor: when the Actor Tool is selected, on mouse-over of an actor,
  clicking on the gear icon will open a new "Actor Properties" window which
  shows metadata (title, author, ID, position) and an Options tab to configure
  the actor's options.

Updates to the scripting API:

* Self.Options() returns a list of option names defined on the Doodad.
* Self.GetOption(name) returns the value for the named option, or nil if
  neither the actor nor its doodad have the option defined. The return type
  will be correctly a string, boolean or integer type.

Updates to the doodad command-line tool:

* `doodad show` will print the Options on a .doodad file and, when showing a
  .level file with --actors, prints any customized Options with the actors.
* `doodad edit-doodad` adds a --option parameter to define options.

Options added to the game's built-in doodads:

* Warp Doors: "locked (exit only)" will make it so the door can not be opened
  by the player, giving the "locked" message (as if it had no linked door),
  but the player may still exit from the door if sent by another warp door.
* Electric Door & Electric Trapdoor: "opened" can make the door be opened by
  default when the level begins instead of closed. A switch or a button that
  removes power will close the door as normal.
* Colored Doors & Small Key Door: "unlocked" will make the door unlocked at
  level start, not requiring a key to open it.
* Colored Keys & Small Key: "has gravity" will make the key subject to gravity
  and set its Mobile flag so that if it falls onto a button, it will activate.
* Gemstones: they had gravity by default; you can now uncheck "has gravity" to
  remove their Gravity and IsMobile status.
* Gemstone Totems: "has gemstone" will set the totem to its unlocked status by
  default with the gemstone inserted. No power signal will be emitted; it is
  cosmetic only.
* Fire Region: "name" can let you set a name for the fire region similarly to
  names for fire pixels: "Watch out for ${name}!"
* Invisible Warp Door: "locked (exit only)" added as well.
2022-10-09 17:41:24 -07:00

889 lines
20 KiB
Go

package windows
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"sort"
"strconv"
"strings"
"git.kirsle.net/SketchyMaze/doodle/assets"
"git.kirsle.net/SketchyMaze/doodle/pkg/balance"
"git.kirsle.net/SketchyMaze/doodle/pkg/doodads"
"git.kirsle.net/SketchyMaze/doodle/pkg/log"
"git.kirsle.net/SketchyMaze/doodle/pkg/modal"
"git.kirsle.net/SketchyMaze/doodle/pkg/native"
"git.kirsle.net/SketchyMaze/doodle/pkg/shmem"
"git.kirsle.net/SketchyMaze/doodle/pkg/userdir"
"git.kirsle.net/go/render"
"git.kirsle.net/go/ui"
)
// Some generic built-in doodad scripts users can attach.
var GenericScripts = []struct {
Label string
Help string
Filename string
SetTags map[string]string
}{
{
Label: "Generic Solid",
Help: "The whole canvas of your doodad acts solid.\n" +
"The player and other mobile doodads can walk on\n" +
"top of it, and it blocks movement from the sides.",
Filename: "assets/scripts/generic-solid.js",
},
{
Label: "Generic Fire",
Help: "The whole canvas of your doodad acts like fire.\n" +
"Mobile doodads who touch it turn dark, and if\n" +
"the player touches it - game over! The failure\n" +
"message says: 'Watch out for (title)!'",
Filename: "assets/scripts/generic-fire.js",
},
{
Label: "Generic Anvil",
Help: "This doodad will behave like the Anvil: fall with\n" +
"gravity and be deadly to any mobile doodad that it\n" +
"lands on! The failure message says:\n" +
"'Watch out for (title)!'",
Filename: "assets/scripts/generic-anvil.js",
},
{
Label: "Generic Collectible Item",
Help: "This doodad will behave like a pocketable item, like\n" +
"the Keys. Tip: set a Doodad tag like quantity=0 to set\n" +
"the item quantity when picked up (default is 1).",
Filename: "assets/scripts/generic-item.js",
SetTags: map[string]string{
"quantity": "1",
},
},
}
// DoodadProperties window.
type DoodadProperties struct {
// Settings passed in by doodle
Supervisor *ui.Supervisor
Engine render.Engine
// Configuration options.
EditDoodad *doodads.Doodad
ActiveTab string // specify the tab to open
OnRefresh func() // caller should rebuild the window
// Widgets.
TabFrame *ui.TabFrame
}
// HACKY GLOBAL VARIABLE
var (
showTagsOnRefreshDoodadPropertiesWindow bool
showOptsOnRefreshDoodadPropertiesWindow bool
)
// NewSettingsWindow initializes the window.
func NewDoodadPropertiesWindow(cfg *DoodadProperties) *ui.Window {
var (
Width = 400
Height = 300
)
window := ui.NewWindow("Doodad Properties")
window.SetButtons(ui.CloseButton)
window.Configure(ui.Config{
Width: Width,
Height: Height,
Background: render.Grey,
})
///////////
// Tab Bar
tabFrame := ui.NewTabFrame("Tab Frame")
tabFrame.SetBackground(render.DarkGrey)
window.Pack(tabFrame, ui.Pack{
Side: ui.N,
FillX: true,
})
cfg.TabFrame = tabFrame
// Make the tabs.
cfg.makeMetaTab(tabFrame, Width, Height)
cfg.makeTagsTab(tabFrame, Width, Height)
cfg.makeOptionsTab(tabFrame, Width, Height)
if showTagsOnRefreshDoodadPropertiesWindow {
tabFrame.SetTab("Tags")
showTagsOnRefreshDoodadPropertiesWindow = false
} else if showOptsOnRefreshDoodadPropertiesWindow {
tabFrame.SetTab("Options")
showOptsOnRefreshDoodadPropertiesWindow = false
}
tabFrame.Supervise(cfg.Supervisor)
return window
}
// DoodadProperties Window "Metadata" Tab
func (c DoodadProperties) makeMetaTab(tabFrame *ui.TabFrame, Width, Height int) *ui.Frame {
tab := tabFrame.AddTab("Metadata", ui.NewLabel(ui.Label{
Text: "Metadata",
Font: balance.TabFont,
}))
tab.Resize(render.NewRect(Width-4, Height-tab.Size().H-46))
if c.EditDoodad == nil {
return tab
}
//////////////
// Draw the editable metadata form.
var hitboxString = c.EditDoodad.Hitbox.String()
for _, data := range []struct {
Label string
Prompt string // optional
Variable *string
Update func(string)
}{
{
Label: "Title:",
Variable: &c.EditDoodad.Title,
Update: func(v string) {
c.EditDoodad.Title = v
},
},
{
Label: "Author:",
Variable: &c.EditDoodad.Author,
Update: func(v string) {
c.EditDoodad.Author = v
},
},
{
Label: "Hitbox:",
Prompt: "Enter hitbox in X,Y,W,H or just W,H format: ",
Variable: &hitboxString,
Update: func(v string) {
// Parse it.
parts := strings.Split(v, ",")
var ints []int
for _, part := range parts {
a, err := strconv.Atoi(strings.TrimSpace(part))
if err != nil {
shmem.Flash("Invalid format for hitbox, using the default")
return
}
ints = append(ints, a)
}
if len(ints) == 2 {
c.EditDoodad.Hitbox = render.NewRect(ints[0], ints[1])
} else if len(ints) == 4 {
c.EditDoodad.Hitbox = render.Rect{
X: ints[0],
Y: ints[1],
W: ints[2],
H: ints[3],
}
} else {
shmem.Flash("Hitbox should be in X,Y,W,H or just W,H format, 2 or 4 numbers.")
return
}
hitboxString = c.EditDoodad.Hitbox.String()
},
},
} {
data := data
frame := ui.NewFrame("Metadata " + data.Label + " Frame")
tab.Pack(frame, ui.Pack{
Side: ui.N,
PadY: 4,
FillX: true,
})
// The label
label := ui.NewLabel(ui.Label{
Text: data.Label,
Font: balance.MenuFont,
})
label.Configure(ui.Config{
Width: 75,
})
frame.Pack(label, ui.Pack{
Side: ui.W,
})
// The button.
btn := ui.NewButton(data.Label, ui.NewLabel(ui.Label{
TextVariable: data.Variable,
Font: balance.MenuFont,
}))
btn.Handle(ui.Click, func(ed ui.EventData) error {
var prompt = data.Prompt
if prompt == "" {
prompt = "Enter a new " + data.Label + " "
}
shmem.Prompt(prompt, func(answer string) {
if answer != "" {
data.Update(answer)
}
})
return nil
})
c.Supervisor.Add(btn)
frame.Pack(btn, ui.Pack{
Side: ui.W,
Expand: true,
PadX: 2,
})
}
//////////////////////////////////
// Draw the JavaScript management
scriptHeader := ui.NewLabel(ui.Label{
Text: "Doodad Script",
Font: balance.LargeLabelFont,
})
tab.Pack(scriptHeader, ui.Pack{
Side: ui.N,
FillX: true,
PadY: 8,
})
// Frame for if a script does exist on the doodad.
var (
ifScript *ui.Frame
elseScript *ui.Frame
)
// "If Script" Frame
{
ifScript = ui.NewFrame("If Script")
tab.Pack(ifScript, ui.Pack{
Side: ui.N,
FillX: true,
})
label := ui.NewLabel(ui.Label{
Text: "This Doodad has a script attached.",
Font: balance.MenuFont,
})
ifScript.Pack(label, ui.Pack{
Side: ui.W,
})
// Delete Button
deleteBtn := ui.NewButton("Save", ui.NewLabel(ui.Label{
Text: "Delete",
Font: balance.MenuFont,
}))
deleteBtn.SetStyle(&balance.ButtonDanger)
deleteBtn.Handle(ui.Click, func(ed ui.EventData) error {
modal.Confirm("Are you sure you want to delete this script?").Then(func() {
c.EditDoodad.Script = ""
ifScript.Hide()
elseScript.Show()
})
return nil
})
c.Supervisor.Add(deleteBtn)
ifScript.Pack(deleteBtn, ui.Pack{
Side: ui.E,
PadX: 2,
})
// Open Button
saveBtn := ui.NewButton("Open", ui.NewLabel(ui.Label{
Text: "View",
Font: balance.MenuFont,
}))
saveBtn.SetStyle(&balance.ButtonPrimary)
saveBtn.Handle(ui.Click, func(ed ui.EventData) error {
// Write the js file to cache and try and open it in the user's
// native text editor program.
outname := filepath.Join(userdir.CacheDirectory, c.EditDoodad.Filename+".js")
err := ioutil.WriteFile(outname, []byte(c.EditDoodad.Script), 0644)
if err == nil {
native.OpenLocalURL(outname)
return nil
}
// Otherwise, prompt the user for their filepath.
shmem.Prompt("Save script as (*.js): ", func(answer string) {
if answer != "" {
cwd, _ := os.Getwd()
err := ioutil.WriteFile(answer, []byte(c.EditDoodad.Script), 0644)
if err != nil {
shmem.Flash(err.Error())
} else {
shmem.Flash("Written to: %s (%d bytes)", filepath.Join(cwd, answer), len(c.EditDoodad.Script))
native.OpenLocalURL(filepath.Join(cwd, answer))
}
}
})
return nil
})
c.Supervisor.Add(saveBtn)
ifScript.Pack(saveBtn, ui.Pack{
Side: ui.E,
PadX: 2,
})
}
// "Else Script" Frame
{
elseScript = ui.NewFrame("If Script")
tab.Pack(elseScript, ui.Pack{
Side: ui.N,
FillX: true,
})
label := ui.NewLabel(ui.Label{
Text: "There is no script attached to this doodad.",
Font: balance.MenuFont,
})
elseScript.Pack(label, ui.Pack{
Side: ui.W,
})
}
// Attaching a Script Frame
{
label := ui.NewLabel(ui.Label{
Text: "Attach a Script",
Font: balance.LabelFont,
})
tab.Pack(label, ui.Pack{
Side: ui.N,
FillX: true,
})
frame := ui.NewFrame("Attach Script Frame")
tab.Pack(frame, ui.Pack{
Side: ui.N,
FillX: true,
})
// Browse Script label.
lblBrowse := ui.NewLabel(ui.Label{
Text: "Browse and attach a .js file:",
Font: balance.MenuFont,
})
frame.Pack(lblBrowse, ui.Pack{
Side: ui.W,
})
// Browse Script button.
btnBrowse := ui.NewButton("Browse Script", ui.NewLabel(ui.Label{
Text: "Attach a script...",
Font: balance.MenuFont,
}))
btnBrowse.SetStyle(&balance.ButtonPrimary)
btnBrowse.Handle(ui.Click, func(ed ui.EventData) error {
filename, err := native.OpenFile("Choose a .js file", "*.js")
if err != nil {
shmem.Flash("Couldn't show file dialog: %s", err)
return nil
}
data, err := ioutil.ReadFile(filename)
if err != nil {
shmem.Flash("Couldn't read file: %s", err)
return nil
}
c.EditDoodad.Script = string(data)
shmem.Flash("Attached %d-byte script to this doodad.", len(c.EditDoodad.Script))
// Toggle the if/else frames.
ifScript.Show()
elseScript.Hide()
return nil
})
c.Supervisor.Add(btnBrowse)
frame.Pack(btnBrowse, ui.Pack{
Side: ui.E,
})
}
// Built-in Generic Scripts Frame
{
frame := ui.NewFrame("Generic Scripts Frame")
tab.Pack(frame, ui.Pack{
Side: ui.N,
FillX: true,
PadY: 4,
})
label := ui.NewLabel(ui.Label{
Text: "Or select from a generic script:",
Font: ui.MenuFont,
})
frame.Pack(label, ui.Pack{
Side: ui.W,
})
// SelectBox for the built-ins.
sb := ui.NewSelectBox("Select", ui.Label{
Font: ui.MenuFont,
})
tab.Pack(sb, ui.Pack{
Side: ui.N,
FillX: true,
})
for _, script := range GenericScripts {
sb.AddItem(script.Label, script.Filename, func() {})
}
sb.SetValue(GenericScripts[0].Filename)
sb.AlwaysChange = true
sb.Handle(ui.Change, func(ed ui.EventData) error {
if selection, ok := sb.GetValue(); ok {
if filename, ok := selection.Value.(string); ok {
// Get this script from the built-in assets.
data, err := assets.Asset(filename)
if err != nil {
shmem.Flash("Couldn't get script: %s", err)
return nil
}
// Find the data from the builtins.
var label, help string
var setTags map[string]string
for _, script := range GenericScripts {
if script.Filename == filename {
label = script.Label
help = script.Help
setTags = script.SetTags
break
}
}
// Prompt the user + a description of this option.
var (
basename = filepath.Base(filename)
description = fmt.Sprintf(
"Do you want to install %s to your doodad?\n\n"+
"%s\n\n%s",
basename,
label,
help,
)
)
modal.Confirm(description).Then(func() {
c.EditDoodad.Script = string(data)
shmem.Flash("Attached %s to your doodad", filepath.Base(filename))
// Set any tags that come with this script.
if setTags != nil && len(setTags) > 0 {
for k, v := range setTags {
log.Info("Set doodad tag %s=%s", k, v)
c.EditDoodad.Tags[k] = v
}
}
// Toggle the if/else frames.
ifScript.Show()
elseScript.Hide()
})
}
}
return nil
})
sb.Supervise(c.Supervisor)
c.Supervisor.Add(sb)
}
// Show/hide appropriate frames.
if c.EditDoodad.Script == "" {
ifScript.Hide()
elseScript.Show()
} else {
ifScript.Show()
elseScript.Hide()
}
return tab
}
// DoodadProperties Window "Tags" Tab
func (c DoodadProperties) makeTagsTab(tabFrame *ui.TabFrame, Width, Height int) *ui.Frame {
tab := tabFrame.AddTab("Tags", ui.NewLabel(ui.Label{
Text: "Tags",
Font: balance.TabFont,
}))
tab.Resize(render.NewRect(Width-4, Height-tab.Size().H-46))
if c.EditDoodad == nil {
return tab
}
// Draw a table view of the current tags on this doodad.
var (
headers = []string{"Name", "Value", "Del."}
columns = []int{150, 150, 80} // TODO, Width=400
height = 24
row = ui.NewFrame("HeaderRow")
)
tab.Pack(row, ui.Pack{
Side: ui.N,
FillX: true,
})
for i, value := range headers {
cell := ui.NewLabel(ui.Label{
Text: value,
Font: balance.MenuFontBold,
})
cell.Resize(render.NewRect(columns[i], height))
row.Pack(cell, ui.Pack{
Side: ui.W,
})
}
// No tags?
if len(c.EditDoodad.Tags) == 0 {
label := ui.NewLabel(ui.Label{
Text: "There are no tags on this doodad.",
Font: balance.MenuFont,
})
tab.Pack(label, ui.Pack{
Side: ui.N,
FillX: true,
})
} else {
// Draw the rows for each tag.
var sortedTags []string
for name := range c.EditDoodad.Tags {
sortedTags = append(sortedTags, name)
}
sort.Strings(sortedTags)
for _, tagName := range sortedTags {
var (
name = tagName
value = c.EditDoodad.Tags[name]
)
row = ui.NewFrame("Tag Row")
tab.Pack(row, ui.Pack{
Side: ui.N,
FillX: true,
PadY: 2,
})
lblName := ui.NewLabel(ui.Label{
Text: name,
Font: balance.MenuFont,
})
lblName.Resize(render.NewRect(columns[0], height))
btnValue := ui.NewButton("Tag Button", ui.NewLabel(ui.Label{
Text: value,
Font: balance.MenuFont,
}))
btnValue.Resize(render.NewRect(columns[1], height))
btnValue.Handle(ui.Click, func(ed ui.EventData) error {
shmem.Prompt("Enter new value: ", func(answer string) {
if answer == "" {
return
}
c.EditDoodad.Tags[name] = answer
btnValue.SetText(answer)
})
return nil
})
c.Supervisor.Add(btnValue)
btnDelete := ui.NewButton("Delete Button", ui.NewLabel(ui.Label{
Text: "Delete",
Font: balance.MenuFont,
}))
btnDelete.Resize(render.NewRect(columns[2], height))
btnDelete.SetStyle(&balance.ButtonDanger)
btnDelete.Handle(ui.Click, func(ed ui.EventData) error {
modal.Confirm("Delete tag %s?", name).Then(func() {
log.Info("Delete tag: %s", name)
delete(c.EditDoodad.Tags, name)
// Trigger a refresh.
if c.OnRefresh != nil {
showTagsOnRefreshDoodadPropertiesWindow = true
c.OnRefresh()
}
})
return nil
})
c.Supervisor.Add(btnDelete)
// Pack the widgets.
row.Pack(lblName, ui.Pack{
Side: ui.W,
})
row.Pack(btnValue, ui.Pack{
Side: ui.W,
PadX: 4,
})
row.Pack(btnDelete, ui.Pack{
Side: ui.W,
})
}
}
// Add Tag button.
row = ui.NewFrame("Button Frame")
tab.Pack(row, ui.Pack{
Side: ui.N,
FillX: true,
})
btnAdd := ui.NewButton("New Tag", ui.NewLabel(ui.Label{
Text: "Add Tag",
Font: balance.MenuFont,
}))
btnAdd.SetStyle(&balance.ButtonPrimary)
btnAdd.Handle(ui.Click, func(ed ui.EventData) error {
shmem.Prompt("Enter name of the new tag: ", func(answer string) {
if answer == "" {
return
}
log.Info("Adding doodad tag: %s", answer)
c.EditDoodad.Tags[answer] = ""
if c.OnRefresh != nil {
showTagsOnRefreshDoodadPropertiesWindow = true
c.OnRefresh()
}
})
return nil
})
c.Supervisor.Add(btnAdd)
row.Pack(btnAdd, ui.Pack{
Side: ui.E,
})
return tab
}
// DoodadProperties Window "Options" Tab
func (c DoodadProperties) makeOptionsTab(tabFrame *ui.TabFrame, Width, Height int) *ui.Frame {
tab := tabFrame.AddTab("Options", ui.NewLabel(ui.Label{
Text: "Options",
Font: balance.TabFont,
}))
tab.Resize(render.NewRect(Width-4, Height-tab.Size().H-46))
if c.EditDoodad == nil {
return tab
}
// Draw a table view of the current tags on this doodad.
var (
headers = []string{"Type", "Name", "Default", "Del."}
columns = []int{40, 130, 130, 80} // TODO, Width=400
height = 24
row = ui.NewFrame("HeaderRow")
)
tab.Pack(row, ui.Pack{
Side: ui.N,
FillX: true,
})
for i, value := range headers {
cell := ui.NewLabel(ui.Label{
Text: value,
Font: balance.MenuFontBold,
})
cell.Resize(render.NewRect(columns[i], height))
row.Pack(cell, ui.Pack{
Side: ui.W,
})
}
// No tags?
if len(c.EditDoodad.Options) == 0 {
label := ui.NewLabel(ui.Label{
Text: "There are no options on this doodad.",
Font: balance.MenuFont,
})
tab.Pack(label, ui.Pack{
Side: ui.N,
FillX: true,
})
} else {
// Draw the rows for each tag.
var sortedOpts []string
for name := range c.EditDoodad.Options {
sortedOpts = append(sortedOpts, name)
}
sort.Strings(sortedOpts)
for _, optName := range sortedOpts {
var (
name = optName
value = c.EditDoodad.Options[name]
)
row = ui.NewFrame("Option Row")
tab.Pack(row, ui.Pack{
Side: ui.N,
FillX: true,
PadY: 2,
})
lblType := ui.NewLabel(ui.Label{
Text: value.Type,
Font: balance.MenuFont,
})
lblType.Resize(render.NewRect(columns[0], height))
lblName := ui.NewLabel(ui.Label{
Text: name,
Font: balance.MenuFont,
})
lblName.Resize(render.NewRect(columns[1], height))
// Value button: show a checkbox for booleans or a clickable
// button for other types (prompts user for value)
var btnValue ui.Widget
if value.Type == "bool" {
var cbValue = value.Default.(bool)
checkbox := ui.NewCheckbox("Bool Box", &cbValue, ui.NewLabel(ui.Label{
Text: fmt.Sprintf("%v", cbValue),
Font: balance.MenuFont,
}))
checkbox.Resize(render.NewRect(columns[2], height))
checkbox.Handle(ui.Click, func(ed ui.EventData) error {
var label string
if cbValue {
label = "true"
} else {
label = "false"
}
c.EditDoodad.Options[name].Set(label)
checkbox.SetText(label)
return nil
})
checkbox.Supervise(c.Supervisor)
btnValue = checkbox
} else {
button := ui.NewButton("Tag Button", ui.NewLabel(ui.Label{
Text: fmt.Sprintf("%v", value.Default),
Font: balance.MenuFont,
}))
button.Resize(render.NewRect(columns[2], height))
button.Handle(ui.Click, func(ed ui.EventData) error {
shmem.Prompt("Enter new value: ", func(answer string) {
if answer == "" {
return
}
answer = c.EditDoodad.Options[name].Set(answer)
button.SetText(answer)
})
return nil
})
c.Supervisor.Add(button)
btnValue = button
}
btnDelete := ui.NewButton("Delete Button", ui.NewLabel(ui.Label{
Text: "Del",
Font: balance.MenuFont,
}))
btnDelete.Resize(render.NewRect(columns[3], height))
btnDelete.SetStyle(&balance.ButtonDanger)
btnDelete.Handle(ui.Click, func(ed ui.EventData) error {
modal.Confirm("Delete option %s?", name).Then(func() {
log.Info("Delete option: %s", name)
delete(c.EditDoodad.Options, name)
// Trigger a refresh.
if c.OnRefresh != nil {
showOptsOnRefreshDoodadPropertiesWindow = true
c.OnRefresh()
}
})
return nil
})
c.Supervisor.Add(btnDelete)
// Pack the widgets.
row.Pack(lblType, ui.Pack{
Side: ui.W,
})
row.Pack(lblName, ui.Pack{
Side: ui.W,
})
row.Pack(btnValue, ui.Pack{
Side: ui.W,
PadX: 4,
})
row.Pack(btnDelete, ui.Pack{
Side: ui.W,
})
}
}
// Add Option menu button.
row = ui.NewFrame("Button Frame")
tab.Pack(row, ui.Pack{
Side: ui.N,
FillX: true,
})
btnAdd := ui.NewMenuButton("New Option", ui.NewLabel(ui.Label{
Text: "Add Option",
Font: balance.MenuFont,
}))
btnAdd.SetStyle(&balance.ButtonPrimary)
// Types of options
for _, item := range []struct {
label string
typing string
value interface{}
}{
{"Boolean", "bool", false},
{"String", "str", ""},
{"Integer", "int", 0},
} {
item := item
btnAdd.AddItem(item.label, func() {
shmem.Prompt("Enter name of the new boolean: ", func(answer string) {
if answer == "" {
return
}
c.EditDoodad.Options[answer] = &doodads.Option{
Name: answer,
Type: item.typing,
Default: item.value,
}
if c.OnRefresh != nil {
showOptsOnRefreshDoodadPropertiesWindow = true
c.OnRefresh()
}
})
})
}
btnAdd.Supervise(c.Supervisor)
c.Supervisor.Add(btnAdd)
row.Pack(btnAdd, ui.Pack{
Side: ui.E,
})
return tab
}
func (c DoodadProperties) reloadTagFrame() {
}