func misc(mType string, id int, o *overlay.Overlay, deleteFunc func(int) error) func(dom.Element) { return func(c dom.Element) { download := xdom.A() download.Href = "http://" + js.Global.Get("location").Get("host").String() + "/download/" + mType + "/" + strconv.Itoa(id) + ".zip" download.Target = "_blank" del := xdom.Button() del.AddEventListener("click", false, func(dom.Event) { del.Disabled = true if dom.GetWindow().Confirm("Are you sure?") { go func() { err := deleteFunc(id) if err != nil { del.Disabled = false xjs.Alert("Error while deleting %s: %s", mType, err) } else { o.Close() } }() } }) xjs.AppendChildren(c, xjs.AppendChildren(xdom.Fieldset(), xjs.SetInnerText(xdom.Legend(), "Download"), xjs.SetInnerText(xdom.Div(), "Click the following link to download the "+mType+" as a zip file."), xjs.SetInnerText(download, download.Href), ), xjs.AppendChildren(xdom.Fieldset(), xjs.SetInnerText(xdom.Legend(), "Delete"), xjs.SetInnerText(xdom.Div(), "The following button will permanently delete the "+mType+" (this cannot be undone)."), xjs.SetInnerText(del, "Delete "+mType), ), ) } }
// New wraps a dom.Element in an Overlay func New(e dom.Node) *Overlay { o := &Overlay{Element: xdom.Div()} o.SetAttribute("class", "mw-overlay") c := xdom.Div() c.SetTextContent("X") c.SetAttribute("class", "closer") c.AddEventListener("click", false, func(dom.Event) { o.Close() }) o.AppendChild(c) o.AppendChild(e) return o }
func GeneratorsTab(c dom.Element) { go func() { xjs.RemoveChildren(c) gs, err := RPC.Generators() if err != nil { xjs.Alert("Error getting generator list: %s", err) return } ng := xdom.Button() xjs.SetInnerText(ng, "New Generator") ng.AddEventListener("click", false, func(dom.Event) { d := xdom.Div() o := overlay.New(d) o.OnClose(func() { GeneratorsTab(c) }) d.AppendChild(transferFile("Map", "Upload/Download", 3, o)) xjs.Body().AppendChild(o) }) table := xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Th(), "Generator"))) if len(gs) == 0 { table.AppendChild(xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Td(), "No Generators"))) } else { for _, g := range gs { td := xdom.Td() td.AddEventListener("click", false, func(g data.Generator) func(dom.Event) { return func(dom.Event) { d := xdom.Div() o := overlay.New(d) o.OnClose(func() { GeneratorsTab(c) }) d.AppendChild(tabs.New([]tabs.Tab{ {"Profile", generatorProfile(g.ID)}, {"Misc", misc("generator", g.ID, o, RPC.RemoveGenerator)}, })) xjs.Body().AppendChild(o) } }(g)) table.AppendChild(xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(td, g.Name))) } } xjs.AppendChildren(c, xjs.SetInnerText(xdom.H2(), "Generators"), ng, table, ) }() }
// InputSizeableList creates a list of InputSizeable elements, wrapped in a div func InputSizeableList(values ...string) *SizeableList { d := xdom.Div() d.Class().SetString("sizeableList") contents := make([]*dom.HTMLSpanElement, len(values)) for i, value := range values { s := InputSizeable("", value) d.AppendChild(s) contents[i] = s } sl := &SizeableList{ d, contents, } remove := InputButton("", "-") remove.AddEventListener("click", false, func(dom.Event) { l := len(sl.contents) - 1 d.RemoveChild(sl.contents[l]) sl.contents = sl.contents[:l] }) add := InputButton("", "+") add.AddEventListener("click", false, func(dom.Event) { s := InputSizeable("", "") d.InsertBefore(s, remove) sl.contents = append(sl.contents, s) }) d.AppendChild(remove) d.AppendChild(add) return sl }
func createMapMode(mode int, o *overlay.Overlay, dataParser func() (data.DefaultMap, error)) func(dom.Element) { submit := xform.InputSubmit("Create Map") submit.AddEventListener("click", false, func(e dom.Event) { data, err := dataParser() if err != nil { xjs.Alert("Error parsing values: %s", err) return } e.PreventDefault() go func() { err = RPC.CreateDefaultMap(data) if err != nil { xjs.Alert("Error creating map: %s", err) return } o.Close() }() }) return func(c dom.Element) { xjs.AppendChildren(c, xjs.SetPreText(xdom.Div(), worldTypes[mode]), xdom.Br(), submit, ) } }
func createSuperFlatMap(o *overlay.Overlay, dataParser func() (data.DefaultMap, error)) func(dom.Element) { // create better UI here d := xdom.Div() gs := xform.InputText("settings", "0") gs.Required = true submit := xform.InputSubmit("Create Map") xjs.AppendChildren(d, xjs.SetPreText(xdom.Div(), worldTypes[1]), xform.Label("Generator Settings", "settings"), gs, xdom.Br(), submit, ) submit.AddEventListener("click", false, func(e dom.Event) { d, err := dataParser() if err != nil { xjs.Alert("Error parsing values: %s", err) return } e.PreventDefault() go func() { err = RPC.CreateSuperflatMap(data.SuperFlatMap{ DefaultMap: d, GeneratorSettings: gs.Value, }) if err != nil { xjs.Alert("Error creating map: %s", err) return } o.Close() }() }) return func(c dom.Element) { c.AppendChild(d) } }
// New takes a list of tabs and generates a tabbed interface, which is return as a document fragment func New(t []Tab) dom.Node { f := xdom.DocumentFragment() if len(t) < 0 { return f } tabsDiv := xdom.Div() contents := xdom.Div() tabsDiv.Class().SetString("tabs") contents.Class().SetString("content") tabs := make([]dom.Element, len(t)) for n := range t { tabs[n] = xjs.SetInnerText(xdom.Div(), t[n].Name).(dom.Element) tabs[n].AddEventListener("click", false, func() func(dom.Event) { i := n return func(e dom.Event) { if tabs[i].Class().String() == "selected" { return } for _, tab := range tabs { tab.Class().Remove("selected") } newContents := contents.CloneNode(false).(*dom.HTMLDivElement) contents.ParentNode().ReplaceChild(newContents, contents) contents = newContents tabs[i].Class().Add("selected") go t[i].Func(contents) } }()) tabsDiv.AppendChild(tabs[n]) } go t[0].Func(contents) tabs[0].Class().Add("selected") f.AppendChild(tabsDiv) f.AppendChild(contents) return f }
func generatorProfile(id int) func(dom.Element) { var d dom.Node return func(c dom.Element) { if d == nil { g, err := RPC.Generator(id) if err != nil { xjs.Alert("Error while getting generator settings: %s", err) return } tTable := xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Th(), "Colour"), xjs.SetInnerText(xdom.Th(), "Colour Code"), xjs.SetInnerText(xdom.Th(), "Name"), ))) for _, t := range g.Terrain { colour := xdom.Td() cc := fmt.Sprintf("rgb(%d, %d, %d)", t.Colour.R, t.Colour.G, t.Colour.B) colour.Style().SetProperty("background-color", cc, "") colour.Style().SetProperty("border", "1px solid #000", "") tTable.AppendChild(xjs.AppendChildren(xdom.Tr(), colour, xjs.SetInnerText(xdom.Td(), cc), xjs.SetInnerText(xdom.Td(), t.Name), )) } bTable := xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Th(), "Colour"), xjs.SetInnerText(xdom.Th(), "Colour Code"), xjs.SetInnerText(xdom.Th(), "Name"), ))) for _, b := range g.Biomes { colour := xdom.Td() cc := fmt.Sprintf("rgb(%d, %d, %d)", b.Colour.R, b.Colour.G, b.Colour.B) colour.Style().SetProperty("background-color", cc, "") colour.Style().SetProperty("border", "1px solid #000", "") bTable.AppendChild(xjs.AppendChildren(xdom.Tr(), colour, xjs.SetInnerText(xdom.Td(), cc), xjs.SetInnerText(xdom.Td(), b.Name), )) } pTable := xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Th(), "Colour"), xjs.SetInnerText(xdom.Th(), "Colour Code"), xjs.SetInnerText(xdom.Th(), "Name"), ))) for _, p := range g.Plants { colour := xdom.Td() cc := fmt.Sprintf("rgb(%d, %d, %d)", p.Colour.R, p.Colour.G, p.Colour.B) colour.Style().SetProperty("background-color", cc, "") colour.Style().SetProperty("border", "1px solid #000", "") pTable.AppendChild(xjs.AppendChildren(xdom.Tr(), colour, xjs.SetInnerText(xdom.Td(), cc), xjs.SetInnerText(xdom.Td(), p.Name), )) } d = xjs.AppendChildren(xdom.Div(), xjs.SetInnerText(xdom.H2(), "Terrain"), tTable, xjs.SetInnerText(xdom.H2(), "Biomes"), bTable, xjs.SetInnerText(xdom.H2(), "Plants"), pTable, ) } c.AppendChild(d) } }
func transferFile(typeName, method string, typeID uint8, o *overlay.Overlay) dom.Node { name := xform.InputText("name", "") url := xform.InputRadio("url", "switch", true) upload := xform.InputRadio("upload", "switch", false) fileI := xform.InputUpload("") urlI := xform.InputURL("", "") s := xform.InputSubmit(method) name.Required = true typeFunc := func(dom.Event) { if url.Checked { urlI.Style().RemoveProperty("display") fileI.Style().SetProperty("display", "none", "") urlI.Required = true fileI.Required = false fileI.SetID("") urlI.SetID("file") } else { fileI.Style().RemoveProperty("display") urlI.Style().SetProperty("display", "none", "") fileI.Required = true urlI.Required = false urlI.SetID("") fileI.SetID("file") } } typeFunc(nil) url.AddEventListener("change", false, typeFunc) upload.AddEventListener("change", false, typeFunc) f := xjs.AppendChildren(xdom.Form(), xjs.AppendChildren(xdom.Fieldset(), xjs.SetInnerText(xdom.Legend(), method+" "+typeName), xform.Label(typeName+" Name", "name"), name, xdom.Br(), xform.Label("URL", "url"), url, xdom.Br(), xform.Label("Upload", "upload"), upload, xdom.Br(), xform.Label("File", "file"), fileI, urlI, xdom.Br(), s, )) s.AddEventListener("click", false, func(e dom.Event) { if name.Value == "" { return } if url.Checked { if urlI.Value == "" { return } } else if len(fileI.Files()) != 1 { return } s.Disabled = true name.Disabled = true url.Disabled = true upload.Disabled = true fileI.Disabled = true urlI.Disabled = true e.PreventDefault() go func() { d := xdom.Div() uo := overlay.New(d) uo.OnClose(func() { o.Close() }) xjs.Body().AppendChild(uo) status := xdom.Div() d.AppendChild(xjs.SetInnerText(status, "Transferring...")) conn, err := websocket.Dial("ws://" + js.Global.Get("location").Get("host").String() + "/transfer") if err != nil { xjs.SetInnerText(status, err.Error()) return } defer conn.Close() w := byteio.StickyWriter{Writer: byteio.LittleEndianWriter{Writer: conn}} r := byteio.StickyReader{Reader: byteio.LittleEndianReader{Reader: conn}} pb := progress.New(color.RGBA{255, 0, 0, 0}, color.RGBA{0, 0, 255, 0}, 400, 50) d.AppendChild(pb) if url.Checked { w.WriteUint8(typeID << 1) data.WriteString(&w, urlI.Value) length := int(r.ReadInt32()) total := 0 for total < length { switch v := r.ReadUint8(); v { case 1: i := int(r.ReadInt32()) total += i pb.Percent(100 * total / length) default: xjs.SetInnerText(status, ReadError(&r).Error()) return } } } else { f := files.NewFileReader(files.NewFile(fileI.Files()[0])) l := f.Len() if l == 0 { xjs.SetInnerText(status, "Zero-length file") return } w.WriteUint8(typeID<<1 | 1) w.WriteInt32(int32(l)) io.Copy(&w, pb.Reader(f, l)) } d.RemoveChild(pb) xjs.SetInnerText(status, "Checking File") data.WriteString(&w, name.Value) var ctx *dom.CanvasRenderingContext2D for { switch v := r.ReadUint8(); v { case 0: if r.Err != nil { xjs.SetInnerText(status, r.Err.Error()) } else { xjs.SetInnerText(status, ReadError(&r).Error()) } return case 1: files := make([]xform.Option, r.ReadInt16()) for i := range files { files[i] = xform.Option{ Value: strconv.Itoa(i), Label: data.ReadString(&r), } } j := xform.SelectBox("files", files...) sel := xjs.SetInnerText(xdom.Button(), "Select") fo := overlay.New(xjs.AppendChildren(xdom.Div(), xjs.AppendChildren(xdom.Fieldset(), xjs.SetInnerText(xdom.Legend(), "Please select the "+typeName+" file"), xform.Label("File", "files"), j, xdom.Br(), sel, ))) c := make(chan int16, 0) done := false fo.OnClose(func() { if !done { done = true c <- -1 } }) sel.AddEventListener("click", false, func(dom.Event) { if !done { done = true v, err := strconv.Atoi(j.Value) if err != nil { v = -1 } c <- int16(v) fo.Close() } }) xjs.Body().AppendChild(fo) w.WriteInt16(<-c) close(c) case 2: w := r.ReadInt32() h := r.ReadInt32() canvas := xdom.Canvas() canvas.Width = int(w) * 8 canvas.Height = int(h) * 8 d.AppendChild(canvas) ctx = canvas.GetContext2d() ctx.Scale(8, 8) case 3: xjs.SetInnerText(status, data.ReadString(&r)) case 4: x := r.ReadInt32() y := r.ReadInt32() red := r.ReadUint8() green := r.ReadUint8() blue := r.ReadUint8() alpha := r.ReadUint8() ctx.FillStyle = "rgba(" + strconv.Itoa(int(red)) + ", " + strconv.Itoa(int(green)) + ", " + strconv.Itoa(int(blue)) + ", " + strconv.FormatFloat(float64(alpha)/255, 'f', -1, 32) + ")" ctx.FillRect(int(x), int(y), 1, 1) case 255: uo.Close() return } } }() }) return f }
func editProperties(c dom.Element, name string, id int, rpcGet func(int) (map[string]string, error), rpcSet func(id int, properties map[string]string) error) { sp, err := rpcGet(id) if err != nil { c.AppendChild(xjs.SetInnerText(xdom.Div(), "Failed to get properties: "+err.Error())) return } props := make(PropertyList, 0, len(sp)) for k, v := range sp { props = append(props, [2]string{k, v}) } sort.Sort(props) propE := make([][2]*dom.HTMLSpanElement, len(props)) df := xjs.DocumentFragment() toggleFunc := func(k, v *dom.HTMLSpanElement, toggle *dom.HTMLInputElement) func(dom.Event) { return func(dom.Event) { if toggle.Value == "-" { k.SetContentEditable("false") v.SetContentEditable("false") k.Style().SetProperty("background-color", "#888", "") v.Style().SetProperty("background-color", "#888", "") toggle.Value = "+" } else { k.SetContentEditable("true") v.SetContentEditable("true") k.Style().RemoveProperty("background-color") v.Style().RemoveProperty("background-color") toggle.Value = "-" } } } for i, prop := range props { k := xform.InputSizeable("", prop[0]) v := xform.InputSizeable("", prop[1]) toggle := xform.InputButton("", "-") toggle.AddEventListener("click", false, toggleFunc(k, v, toggle)) propE[i][0] = k propE[i][1] = v xjs.AppendChildren(df, toggle, k, xjs.SetInnerText(xdom.Span(), "="), v, xdom.Br(), ) } add := xform.InputButton("", "Add") submit := xform.InputButton("", "Save") fs := xjs.AppendChildren(xdom.Fieldset(), xjs.SetInnerText(xdom.Legend(), name+" Properties"), df, add, submit, ) add.AddEventListener("click", false, func(dom.Event) { k := xform.InputSizeable("", "") v := xform.InputSizeable("", "") toggle := xform.InputButton("", "-") toggle.AddEventListener("click", false, toggleFunc(k, v, toggle)) propE = append(propE, [2]*dom.HTMLSpanElement{k, v}) fs.InsertBefore(toggle, add) fs.InsertBefore(k, add) fs.InsertBefore(xjs.SetInnerText(xdom.Span(), "="), add) fs.InsertBefore(v, add) fs.InsertBefore(xdom.Br(), add) }) submit.AddEventListener("click", false, func(dom.Event) { submit.Disabled = true props := make(map[string]string, len(propE)) for _, spans := range propE { if spans[0].IsContentEditable() { props[spans[0].TextContent()] = spans[1].TextContent() } } go func() { err := rpcSet(id, props) if err != nil { xjs.Alert("Error setting "+name+" properties: %s", err) return } span := xdom.Span() span.Style().Set("color", "#f00") fs.AppendChild(xjs.SetInnerText(span, "Saved!")) time.Sleep(5 * time.Second) fs.RemoveChild(span) submit.Disabled = false }() }) xjs.AppendChildren(c, xjs.AppendChildren(xdom.Form(), fs)) }
func ServersTab() func(dom.Element) { forceUpdate := make(chan struct{}) ns := xdom.Button() ns.AddEventListener("click", false, func(dom.Event) { d := xdom.Div() o := overlay.New(d) d.AppendChild(transferFile("Server", "Upload/Download", 0, o)) o.OnClose(func() { go func() { forceUpdate <- struct{}{} }() }) xjs.Body().AppendChild(o) }) noneTd := xdom.Td() noneTd.ColSpan = 3 none := xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(noneTd, "No Servers Found")) serverList := xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Th(), "Server Name"), xjs.SetInnerText(xdom.Th(), "Status"), xjs.SetInnerText(xdom.Th(), "Controls"), )), none, ) nodes := xjs.AppendChildren(xdom.Div(), xjs.SetInnerText(xdom.H2(), "Servers"), xjs.SetInnerText(ns, "New Server"), serverList, ) servers := make(map[int]*Server) return func(c dom.Element) { c.AppendChild(nodes) updateStop := make(chan struct{}) registerUpdateStopper(c, updateStop) for { servs, err := RPC.ServerList() if err != nil { xjs.Alert("Error getting server list: %s", err) return } if none.ParentNode() != nil { serverList.RemoveChild(none) } for _, s := range servers { s.ID = -1 } for _, s := range servs { os, ok := servers[s.ID] if ok { os.Server = s } else { name := xdom.Td() status := xdom.Td() startStop := xdom.Button() os = &Server{ Server: s, row: xjs.AppendChildren(xdom.Tr(), name, status, xjs.AppendChildren(xdom.Td(), startStop), ), name: name, status: status, button: startStop, } servers[s.ID] = os serverList.AppendChild(os.row) name.Class().SetString("serverName") name.AddEventListener("click", false, func() func(dom.Event) { s := os return func(dom.Event) { go func() { d, err := RPC.ServerEULA(s.ID) if err != nil { d = "" } t := []tabs.Tab{ {"General", serverGeneral(s.Server)}, {"Properties", serverProperties(s.Server)}, {"Console", serverConsole(s.Server)}, } if d != "" { t = append(t, tabs.Tab{"EULA", serverEULA(s.Server, d)}) } div := xdom.Div() o := overlay.New(div) t = append(t, tabs.Tab{"Misc.", misc("server", s.Server.ID, o, RPC.RemoveServer)}) div.AppendChild(tabs.New(t)) o.OnClose(func() { go func() { forceUpdate <- struct{}{} }() }) xjs.Body().AppendChild(o) }() } }()) startStop.AddEventListener("click", false, func() func(dom.Event) { b := startStop s := os return func(dom.Event) { go func() { b.Disabled = true switch s.State { case data.StateStopped: err := RPC.StartServer(s.ID) if err != nil { xjs.Alert("Error starting server: %s", err) return } case data.StateRunning: err := RPC.StopServer(s.ID) if err != nil { xjs.Alert("Error stopping server: %s", err) return } default: return } go func() { forceUpdate <- struct{}{} }() }() } }()) } if os.Map >= 0 { xjs.SetInnerText(os.status, os.State.String()) switch os.State { case data.StateStopped: xjs.SetInnerText(os.button, "Start") os.button.Disabled = false case data.StateRunning: xjs.SetInnerText(os.button, "Stop") os.button.Disabled = false default: xjs.SetInnerText(os.button, "N/A") os.button.Disabled = true } } else { xjs.SetInnerText(os.status, "No Map") os.button.Disabled = true xjs.SetInnerText(os.button, "N/A") } xjs.SetInnerText(os.name, os.Name) } for id, s := range servers { if s.ID == -1 { delete(servers, id) serverList.RemoveChild(s.row) } } if len(servers) == 0 { serverList.AppendChild(none) } // Sleep until update if !updateSleep(forceUpdate, updateStop) { return } } } }
func serverGeneral(s data.Server) func(dom.Element) { return func(c dom.Element) { go func() { maps, err := RPC.MapList() if err != nil { c.AppendChild(xjs.SetInnerText(xdom.Div(), "Error getting map list: "+err.Error())) return } name := xform.InputText("name", s.Name) name.Required = true opts := make([]xform.Option, 1, len(maps)+1) opts[0] = xform.Option{ Label: "-- None -- ", Value: "-1", Selected: s.Map == -1, } for i, m := range maps { n := m.Name if m.Server != -1 { if m.ID == s.Map { n = "* - " + n } else { n = "! - " + n } } else { n = " " + n } opts = append(opts, xform.Option{ Label: n, Value: strconv.Itoa(i), Selected: m.ID == s.Map, }) } args := xform.InputSizeableList(s.Args...) sel := xform.SelectBox("map", opts...) submit := xform.InputSubmit("Set") submit.AddEventListener("click", false, func(e dom.Event) { if s.State != data.StateStopped { xjs.Alert("Cannot modify these settings while the server is running") return } if name.Value == "" { return } sID, err := strconv.Atoi(sel.Value) if err != nil || sID < -1 || sID >= len(maps) { return } submit.Disabled = true e.PreventDefault() if sID >= 0 { m := maps[sID] sID = m.ID } go func() { err = RPC.SetServerMap(s.ID, sID) if err != nil { xjs.Alert("Error setting server map: %s", err) return } s.Name = name.Value s.Args = args.Values() err = RPC.SetServer(s) if err != nil { xjs.Alert("Error setting server data: %s", err) return } span := xdom.Span() span.Style().Set("color", "#f00") c.AppendChild(xjs.SetInnerText(span, "Saved!")) time.Sleep(5 * time.Second) c.RemoveChild(span) submit.Disabled = false }() }) xjs.AppendChildren(c, xjs.AppendChildren(xdom.Form(), xform.Label("Server Name", "name"), name, xdom.Br(), xform.Label("Arguments", "args"), args, xdom.Br(), xform.Label("Map Name", "map"), sel, xdom.Br(), submit, )) }() } }
func mapGeneral(m data.Map) func(dom.Element) { return func(c dom.Element) { go func() { servers, err := RPC.ServerList() if err != nil { c.AppendChild(xjs.SetInnerText(xdom.Div(), "Error getting server list: "+err.Error())) return } name := xform.InputText("name", m.Name) name.Required = true opts := make([]xform.Option, 1, len(servers)+1) opts[0] = xform.Option{ Label: "-- None --", Value: "-1", Selected: m.Server == -1, } var cs data.Server for i, s := range servers { n := s.Name if s.Map != -1 { if s.ID == m.Server { cs = s n = "* - " + n } else { n = "! - " + n } } else { n = " " + n } opts = append(opts, xform.Option{ Label: n, Value: strconv.Itoa(i), Selected: s.ID == m.Server, }) } sel := xform.SelectBox("server", opts...) submit := xform.InputSubmit("Set") submit.AddEventListener("click", false, func(e dom.Event) { if cs.State != data.StateStopped { xjs.Alert("Cannot modify these settings while connected server is running.") return } if name.Value == "" { return } mID, err := strconv.Atoi(sel.Value) if err != nil || mID < -1 || mID >= len(servers) { return } submit.Disabled = true e.PreventDefault() if mID >= 0 { s := servers[mID] mID = s.ID } go func() { err = RPC.SetServerMap(mID, m.ID) if err != nil { xjs.Alert("Error setting map server: %s", err) return } m.Name = name.Value err = RPC.SetMap(m) if err != nil { xjs.Alert("Error setting map data: %s", err) return } span := xdom.Span() span.Style().Set("color", "#f00") c.AppendChild(xjs.SetInnerText(span, "Saved!")) time.Sleep(5 * time.Second) c.RemoveChild(span) submit.Disabled = false }() }) xjs.AppendChildren(c, xjs.AppendChildren(xdom.Form(), xform.Label("Server Name", "name"), name, xdom.Br(), xform.Label("Server Name", "server"), sel, xdom.Br(), submit, )) }() } }
func createCustomisedMap(o *overlay.Overlay, dataParser func() (data.DefaultMap, error)) func(dom.Element) { d := xdom.Div() d.Class().SetString("brClear") seaLevel := xform.InputRange("sea", 0, 255, 1, 63) caves := xform.InputCheckbox("caves", true) strongholds := xform.InputCheckbox("strongholds", true) villages := xform.InputCheckbox("villages", true) mineshafts := xform.InputCheckbox("mineshafts", true) temples := xform.InputCheckbox("templaes", true) oceanMonuments := xform.InputCheckbox("oceanMonuments", true) ravines := xform.InputCheckbox("ravines", true) dungeons := xform.InputCheckbox("dungeons", true) dungeonCount := xform.InputRange("dungeonCount", 1, 100, 1, 7) waterLakes := xform.InputCheckbox("waterLakes", true) waterLakeRarity := xform.InputRange("waterLakeRarity", 1, 100, 1, 4) lavaLakes := xform.InputCheckbox("lavaLakes", true) lavaLakeRarity := xform.InputRange("lavaLakeRarity", 1, 100, 1, 80) biome := xform.SelectBox("biomes", biomes...) biomeSize := xform.InputRange("biomeSize", 1, 8, 1, 4) riverSize := xform.InputRange("riverSize", 1, 5, 1, 4) dirtSpawnSize := xform.InputRange("dirtSpawnSize", 1, 50, 1, 33) dirtSpawnTries := xform.InputRange("dirtSpawnTries", 0, 40, 1, 10) dirtMinHeight := xform.InputRange("dirtMinHeight", 0, 255, 1, 0) dirtMaxHeight := xform.InputRange("dirtMaxHeight", 0, 255, 1, 256) gravelSpawnSize := xform.InputRange("gravelSpawnSize", 1, 50, 1, 33) gravelSpawnTries := xform.InputRange("gravelSpawnTries", 0, 40, 1, 8) gravelMinHeight := xform.InputRange("gravelMinHeight", 0, 255, 1, 0) gravelMaxHeight := xform.InputRange("gravelMaxHeight", 0, 255, 1, 256) graniteSpawnSize := xform.InputRange("graniteSpawnSize", 1, 50, 1, 33) graniteSpawnTries := xform.InputRange("graniteSpawnTries", 0, 40, 1, 10) graniteMinHeight := xform.InputRange("graniteMinHeight", 0, 255, 1, 0) graniteMaxHeight := xform.InputRange("graniteMaxHeight", 0, 255, 1, 80) dioriteSpawnSize := xform.InputRange("dioriteSpawnSize", 1, 50, 1, 33) dioriteSpawnTries := xform.InputRange("dioriteSpawnTries", 0, 40, 1, 10) dioriteMinHeight := xform.InputRange("dioriteMinHeight", 0, 255, 1, 0) dioriteMaxHeight := xform.InputRange("dioriteMaxHeight", 0, 255, 1, 80) andesiteSpawnSize := xform.InputRange("andesiteSpawnSize", 1, 50, 1, 33) andesiteSpawnTries := xform.InputRange("andesiteSpawnTries", 0, 40, 1, 10) andesiteMinHeight := xform.InputRange("andesiteMinHeight", 0, 255, 1, 0) andesiteMaxHeight := xform.InputRange("andesiteMaxHeight", 0, 255, 1, 80) coalOreSpawnSize := xform.InputRange("coalOreSpawnSize", 1, 50, 1, 17) coalOreSpawnTries := xform.InputRange("coalOreSpawnTries", 0, 40, 1, 20) coalOreMinHeight := xform.InputRange("coalOreMinHeight", 0, 255, 1, 0) coalOreMaxHeight := xform.InputRange("coalOreMaxHeight", 0, 255, 1, 128) ironOreSpawnSize := xform.InputRange("ironOreSpawnSize", 1, 50, 1, 9) ironOreSpawnTries := xform.InputRange("ironOreSpawnTries", 0, 40, 1, 20) ironOreMinHeight := xform.InputRange("ironOreMinHeight", 0, 255, 1, 0) ironOreMaxHeight := xform.InputRange("ironOreMaxHeight", 0, 255, 1, 64) goldOreSpawnSize := xform.InputRange("goldOreSpawnSize", 1, 50, 1, 9) goldOreSpawnTries := xform.InputRange("goldOreSpawnTries", 0, 40, 1, 2) goldOreMinHeight := xform.InputRange("goldOreMinHeight", 0, 255, 1, 0) goldOreMaxHeight := xform.InputRange("goldOreMaxHeight", 0, 255, 1, 32) redstoneOreSpawnSize := xform.InputRange("redstoneOreSpawnSize", 1, 50, 1, 8) redstoneOreSpawnTries := xform.InputRange("redstoneOreSpawnTries", 0, 40, 1, 8) redstoneOreMinHeight := xform.InputRange("redstoneOreMinHeight", 0, 255, 1, 0) redstoneOreMaxHeight := xform.InputRange("redstoneOreMaxHeight", 0, 255, 1, 16) diamondOreSpawnSize := xform.InputRange("diamondOreSpawnSize", 1, 50, 1, 8) diamondOreSpawnTries := xform.InputRange("diamondOreSpawnTries", 0, 40, 1, 1) diamondOreMinHeight := xform.InputRange("diamondOreMinHeight", 0, 255, 1, 0) diamondOreMaxHeight := xform.InputRange("diamondOreMaxHeight", 0, 255, 1, 16) lapisLazuliOreSpawnSize := xform.InputRange("lapisLazuliOreSpawnSize", 1, 50, 1, 7) lapisLazuliOreSpawnTries := xform.InputRange("lapisLazuliOreSpawnTries", 0, 40, 1, 1) lapisLazuliOreCentreHeight := xform.InputRange("lapisLazuliOreCentreHeight", 0, 255, 1, 16) lapisLazuliOreSpreadHeight := xform.InputRange("lapisLazuliOreSpreadHeight", 0, 255, 1, 16) mainNoiseScaleX := xform.InputRange("mainNoiseScaleX", 1, 5000, -1, 80) mainNoiseScaleY := xform.InputRange("mainNoiseScaleY", 1, 5000, -1, 160) mainNoiseScaleZ := xform.InputRange("mainNoiseScaleZ", 1, 5000, -1, 80) depthNoiseScaleX := xform.InputRange("depthNoiseScaleX", 1, 2000, -1, 200) depthNoiseScaleZ := xform.InputRange("depthNoiseScaleZ", 1, 2000, -1, 200) depthNoiseExponent := xform.InputRange("depthNoiseExponent", 0.01, 20, -1, 0.5) depthBaseSize := xform.InputRange("depthBaseSize", 1, 25, -1, 8.5) coordinateScale := xform.InputRange("coordinateScale", 1, 6000, -1, 684.412) heightScale := xform.InputRange("heightScale", 1, 6000, -1, 684.412) heightStretch := xform.InputRange("heightStretch", 0.01, 50, -1, 12) upperLimitScale := xform.InputRange("upperLimitScale", 1, 5000, -1, 512) lowerLimitScale := xform.InputRange("lowerLimitScale", 1, 5000, -1, 512) biomeDepthWeight := xform.InputRange("biomeDepthWeight", 1, 20, -1, 1) biomeDepthOffset := xform.InputRange("biomeDepthOffset", 0, 20, -1, 0) biomeScaleWeight := xform.InputRange("biomeScaleWeight", 1, 20, -1, 1) biomeScaleOffset := xform.InputRange("biomeScaleOffset", 0, 20, -1, 0) submit := xform.InputSubmit("Create Map") submit.AddEventListener("click", false, func(e dom.Event) { d, err := dataParser() if err != nil { xjs.Alert("Error parsing values: %s", err) return } e.PreventDefault() cd := data.CustomMap{ DefaultMap: d, } cd.GeneratorSettings.SeaLevel = uint8(seaLevel.ValueAsNumber) cd.GeneratorSettings.Caves = caves.Checked cd.GeneratorSettings.Strongholds = strongholds.Checked cd.GeneratorSettings.Villages = villages.Checked cd.GeneratorSettings.Mineshafts = mineshafts.Checked cd.GeneratorSettings.Temples = temples.Checked cd.GeneratorSettings.OceanMonuments = oceanMonuments.Checked cd.GeneratorSettings.Ravines = ravines.Checked cd.GeneratorSettings.Dungeons = dungeons.Checked cd.GeneratorSettings.DungeonChance = uint8(dungeonCount.ValueAsNumber) cd.GeneratorSettings.WaterLake = waterLakes.Checked cd.GeneratorSettings.WaterLakeChance = uint8(waterLakeRarity.ValueAsNumber) cd.GeneratorSettings.LaveLake = lavaLakes.Checked cd.GeneratorSettings.LavaLakeChance = uint8(lavaLakeRarity.ValueAsNumber) b, err := strconv.Atoi(biome.Value) if err != nil { b = -1 } cd.GeneratorSettings.Biome = int16(b) cd.GeneratorSettings.BiomeSize = uint8(biomeSize.ValueAsNumber) cd.GeneratorSettings.RiverSize = uint8(riverSize.ValueAsNumber) cd.GeneratorSettings.DirtSize = uint8(dirtSpawnSize.ValueAsNumber) cd.GeneratorSettings.DirtTries = uint8(dirtSpawnTries.ValueAsNumber) cd.GeneratorSettings.DirtMinHeight = uint8(dirtMinHeight.ValueAsNumber) cd.GeneratorSettings.DirtMaxHeight = uint8(dirtMaxHeight.ValueAsNumber) cd.GeneratorSettings.GravelSize = uint8(gravelSpawnSize.ValueAsNumber) cd.GeneratorSettings.GravelTries = uint8(gravelSpawnTries.ValueAsNumber) cd.GeneratorSettings.GravelMinHeight = uint8(gravelMinHeight.ValueAsNumber) cd.GeneratorSettings.GravelMaxHeight = uint8(gravelMaxHeight.ValueAsNumber) cd.GeneratorSettings.GraniteSize = uint8(graniteSpawnSize.ValueAsNumber) cd.GeneratorSettings.GraniteTries = uint8(graniteSpawnTries.ValueAsNumber) cd.GeneratorSettings.GraniteMinHeight = uint8(graniteMinHeight.ValueAsNumber) cd.GeneratorSettings.GraniteMaxHeight = uint8(graniteMaxHeight.ValueAsNumber) cd.GeneratorSettings.DiortiteSize = uint8(dioriteSpawnSize.ValueAsNumber) cd.GeneratorSettings.DiortiteTries = uint8(dioriteSpawnTries.ValueAsNumber) cd.GeneratorSettings.DiortiteMinHeight = uint8(dioriteMinHeight.ValueAsNumber) cd.GeneratorSettings.DiortiteMaxHeight = uint8(dioriteMaxHeight.ValueAsNumber) cd.GeneratorSettings.AndesiteSize = uint8(andesiteSpawnSize.ValueAsNumber) cd.GeneratorSettings.AndesiteTries = uint8(andesiteSpawnTries.ValueAsNumber) cd.GeneratorSettings.AndesiteMinHeight = uint8(andesiteMinHeight.ValueAsNumber) cd.GeneratorSettings.AndesiteMaxHeight = uint8(andesiteMaxHeight.ValueAsNumber) cd.GeneratorSettings.CoalSize = uint8(coalOreSpawnSize.ValueAsNumber) cd.GeneratorSettings.CoalTries = uint8(coalOreSpawnTries.ValueAsNumber) cd.GeneratorSettings.CoalMinHeight = uint8(coalOreMinHeight.ValueAsNumber) cd.GeneratorSettings.CoalMaxHeight = uint8(coalOreMaxHeight.ValueAsNumber) cd.GeneratorSettings.IronSize = uint8(ironOreSpawnSize.ValueAsNumber) cd.GeneratorSettings.IronTries = uint8(ironOreSpawnTries.ValueAsNumber) cd.GeneratorSettings.IronMinHeight = uint8(ironOreMinHeight.ValueAsNumber) cd.GeneratorSettings.IronMaxHeight = uint8(ironOreMaxHeight.ValueAsNumber) cd.GeneratorSettings.GoldSize = uint8(goldOreSpawnSize.ValueAsNumber) cd.GeneratorSettings.GoldTries = uint8(goldOreSpawnTries.ValueAsNumber) cd.GeneratorSettings.GoldMinHeight = uint8(goldOreMinHeight.ValueAsNumber) cd.GeneratorSettings.GoldMaxHeight = uint8(goldOreMaxHeight.ValueAsNumber) cd.GeneratorSettings.RedstoneSize = uint8(redstoneOreSpawnSize.ValueAsNumber) cd.GeneratorSettings.RedstoneTries = uint8(redstoneOreSpawnTries.ValueAsNumber) cd.GeneratorSettings.RedstoneMinHeight = uint8(redstoneOreMinHeight.ValueAsNumber) cd.GeneratorSettings.RedstoneMaxHeight = uint8(redstoneOreMaxHeight.ValueAsNumber) cd.GeneratorSettings.DiamondSize = uint8(diamondOreSpawnSize.ValueAsNumber) cd.GeneratorSettings.DiamondTries = uint8(diamondOreSpawnTries.ValueAsNumber) cd.GeneratorSettings.DiamondMinHeight = uint8(diamondOreMinHeight.ValueAsNumber) cd.GeneratorSettings.DiamondMaxHeight = uint8(diamondOreMaxHeight.ValueAsNumber) cd.GeneratorSettings.LapisSize = uint8(lapisLazuliOreSpawnSize.ValueAsNumber) cd.GeneratorSettings.LapisTries = uint8(lapisLazuliOreSpawnTries.ValueAsNumber) cd.GeneratorSettings.LapisCenterHeight = uint8(lapisLazuliOreCentreHeight.ValueAsNumber) cd.GeneratorSettings.LapisSpread = uint8(lapisLazuliOreSpreadHeight.ValueAsNumber) cd.GeneratorSettings.MainNoiseScaleX = mainNoiseScaleX.ValueAsNumber cd.GeneratorSettings.MainNoiseScaleY = mainNoiseScaleY.ValueAsNumber cd.GeneratorSettings.MainNoiseScaleZ = mainNoiseScaleZ.ValueAsNumber cd.GeneratorSettings.DepthNoiseScaleX = depthNoiseScaleX.ValueAsNumber cd.GeneratorSettings.DepthNoiseScaleZ = depthNoiseScaleZ.ValueAsNumber cd.GeneratorSettings.DepthNoiseScaleExponent = depthNoiseExponent.ValueAsNumber cd.GeneratorSettings.BaseSize = depthBaseSize.ValueAsNumber cd.GeneratorSettings.CoordinateScale = coordinateScale.ValueAsNumber cd.GeneratorSettings.HeightScale = heightScale.ValueAsNumber cd.GeneratorSettings.HeightStretch = heightStretch.ValueAsNumber cd.GeneratorSettings.UpperLimitScale = upperLimitScale.ValueAsNumber cd.GeneratorSettings.LowerLimitScale = lowerLimitScale.ValueAsNumber cd.GeneratorSettings.BiomeDepthWeight = biomeDepthWeight.ValueAsNumber cd.GeneratorSettings.BiomeDepthOffset = biomeDepthOffset.ValueAsNumber cd.GeneratorSettings.BiomeScaleWeight = biomeScaleWeight.ValueAsNumber cd.GeneratorSettings.BiomeScaleOffset = biomeScaleOffset.ValueAsNumber go func() { err = RPC.CreateCustomMap(cd) if err != nil { xjs.Alert("Error creating map: %s", err) return } o.Close() }() }) enabler(dungeons, dungeonCount) enabler(waterLakes, waterLakeRarity) enabler(lavaLakes, lavaLakeRarity) xjs.AppendChildren(d, xform.Label("Sea Level", "sea"), seaLevel, rangeWatch(seaLevel), xdom.Br(), xform.Label("Caves", "caves"), caves, xdom.Br(), xform.Label("Strongholds", "strongholds"), strongholds, xdom.Br(), xform.Label("Villages", "villages"), villages, xdom.Br(), xform.Label("Mineshafts", "mineshafts"), mineshafts, xdom.Br(), xform.Label("Temples", "temples"), temples, xdom.Br(), xform.Label("Ocean Monuments", "oceanMonuments"), oceanMonuments, xdom.Br(), xform.Label("Ravines", "ravines"), ravines, xdom.Br(), xform.Label("Dungeons", "dungeons"), dungeons, xdom.Br(), xform.Label("Dungeon Count", "dungeonCount"), dungeonCount, rangeWatch(dungeonCount), xdom.Br(), xform.Label("Water Lakes", "waterLakes"), waterLakes, xdom.Br(), xform.Label("Water Lake Rarity", "waterLakeRarity"), waterLakeRarity, rangeWatch(waterLakeRarity), xdom.Br(), xform.Label("Lava Lakes", "lavaLakes"), lavaLakes, xdom.Br(), xform.Label("Lava Lake Rarity", "lavaLakeRarity"), lavaLakeRarity, rangeWatch(lavaLakeRarity), xdom.Br(), xform.Label("Biomes", "biomes"), biome, xdom.Br(), xform.Label("Biome Size", "biomeSize"), biomeSize, xdom.Br(), xform.Label("River Size", "riverSize"), riverSize, xdom.Br(), xdom.Br(), xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Tr(), xjs.AppendChildren(xdom.Td(), xform.Label("Dirt Spawn Size", "dirtSpawnSize"), dirtSpawnSize, rangeWatch(dirtSpawnSize), xdom.Br(), xform.Label("Dirt Spawn Tries", "dirtSpawnTries"), dirtSpawnTries, rangeWatch(dirtSpawnTries), xdom.Br(), xform.Label("Dirt Spawn Min Height", "dirtMinHeight"), dirtMinHeight, rangeWatch(dirtMinHeight), xdom.Br(), xform.Label("Dirt Spawn Max Height", "dirtMaxHeight"), dirtMaxHeight, rangeWatch(dirtMaxHeight), xdom.Br(), ), xjs.AppendChildren(xdom.Td(), xform.Label("Gravel Spawn Size", "gravelSpawnSize"), gravelSpawnSize, rangeWatch(gravelSpawnSize), xdom.Br(), xform.Label("Gravel Spawn Tries", "gravelSpawnTries"), gravelSpawnTries, rangeWatch(gravelSpawnTries), xdom.Br(), xform.Label("Gravel Spawn Min Height", "gravelMinHeight"), gravelMinHeight, rangeWatch(gravelMinHeight), xdom.Br(), xform.Label("Gravel Spawn Max Height", "gravelMaxHeight"), gravelMaxHeight, rangeWatch(gravelMaxHeight), xdom.Br(), ), ), xjs.AppendChildren(xdom.Tr(), xjs.AppendChildren(xdom.Td(), xform.Label("Granite Spawn Size", "graniteSpawnSize"), graniteSpawnSize, rangeWatch(graniteSpawnSize), xdom.Br(), xform.Label("Granite Spawn Tries", "graniteSpawnTries"), graniteSpawnTries, rangeWatch(graniteSpawnTries), xdom.Br(), xform.Label("Granite Spawn Min Height", "graniteMinHeight"), graniteMinHeight, rangeWatch(graniteMinHeight), xdom.Br(), xform.Label("Granite Spawn Max Height", "graniteMaxHeight"), graniteMaxHeight, rangeWatch(graniteMaxHeight), xdom.Br(), ), xjs.AppendChildren(xdom.Td(), xform.Label("Diorite Spawn Size", "dioriteSpawnSize"), dioriteSpawnSize, rangeWatch(dioriteSpawnSize), xdom.Br(), xform.Label("Diorite Spawn Tries", "dioriteSpawnTries"), dioriteSpawnTries, rangeWatch(dioriteSpawnTries), xdom.Br(), xform.Label("Diorite Spawn Min Height", "dioriteMinHeight"), dioriteMinHeight, rangeWatch(dioriteMinHeight), xdom.Br(), xform.Label("Diorite Spawn Max Height", "dioriteMaxHeight"), dioriteMaxHeight, rangeWatch(dioriteMaxHeight), xdom.Br(), ), ), xjs.AppendChildren(xdom.Tr(), xjs.AppendChildren(xdom.Td(), xform.Label("Andesite Spawn Size", "andesiteSpawnSize"), andesiteSpawnSize, rangeWatch(andesiteSpawnSize), xdom.Br(), xform.Label("Andesite Spawn Tries", "andesiteSpawnTries"), andesiteSpawnTries, rangeWatch(andesiteSpawnTries), xdom.Br(), xform.Label("Andesite Spawn Min Height", "andesiteMinHeight"), andesiteMinHeight, rangeWatch(andesiteMinHeight), xdom.Br(), xform.Label("Andesite Spawn Max Height", "andesiteMaxHeight"), andesiteMaxHeight, rangeWatch(andesiteMaxHeight), xdom.Br(), ), xjs.AppendChildren(xdom.Td(), xform.Label("Coal Ore Spawn Size", "coalOreSpawnSize"), coalOreSpawnSize, rangeWatch(coalOreSpawnSize), xdom.Br(), xform.Label("Coal Ore Spawn Tries", "coalOreSpawnTries"), coalOreSpawnTries, rangeWatch(coalOreSpawnTries), xdom.Br(), xform.Label("Coal Ore Spawn Min Height", "coalOreMinHeight"), coalOreMinHeight, rangeWatch(coalOreMinHeight), xdom.Br(), xform.Label("Coal Ore Spawn Max Height", "coalOreMaxHeight"), coalOreMaxHeight, rangeWatch(coalOreMaxHeight), xdom.Br(), ), ), xjs.AppendChildren(xdom.Tr(), xjs.AppendChildren(xdom.Td(), xform.Label("Iron Ore Spawn Size", "ironOreSpawnSize"), ironOreSpawnSize, rangeWatch(ironOreSpawnSize), xdom.Br(), xform.Label("Iron Ore Spawn Tries", "ironOreSpawnTries"), ironOreSpawnTries, rangeWatch(ironOreSpawnTries), xdom.Br(), xform.Label("Iron Ore Spawn Min Height", "ironOreMinHeight"), ironOreMinHeight, rangeWatch(ironOreMinHeight), xdom.Br(), xform.Label("Iron Ore Spawn Max Height", "ironOreMaxHeight"), ironOreMaxHeight, rangeWatch(ironOreMaxHeight), xdom.Br(), ), xjs.AppendChildren(xdom.Td(), xform.Label("Gold Ore Spawn Size", "goldOreSpawnSize"), goldOreSpawnSize, rangeWatch(goldOreSpawnSize), xdom.Br(), xform.Label("Gold Ore Spawn Tries", "goldOreSpawnTries"), goldOreSpawnTries, rangeWatch(goldOreSpawnTries), xdom.Br(), xform.Label("Gold Ore Spawn Min Height", "goldOreMinHeight"), goldOreMinHeight, rangeWatch(goldOreMinHeight), xdom.Br(), xform.Label("Gold Ore Spawn Max Height", "goldOreMaxHeight"), goldOreMaxHeight, rangeWatch(goldOreMaxHeight), xdom.Br(), ), ), xjs.AppendChildren(xdom.Tr(), xjs.AppendChildren(xdom.Td(), xform.Label("Redstone Ore Spawn Size", "redstoneOreSpawnSize"), redstoneOreSpawnSize, rangeWatch(redstoneOreSpawnSize), xdom.Br(), xform.Label("Redstone Ore Spawn Tries", "redstoneOreSpawnTries"), redstoneOreSpawnTries, rangeWatch(redstoneOreSpawnTries), xdom.Br(), xform.Label("Redstone Ore Spawn Min Height", "redstoneOreMinHeight"), redstoneOreMinHeight, rangeWatch(redstoneOreMinHeight), xdom.Br(), xform.Label("Redstone Ore Spawn Max Height", "redstoneOreMaxHeight"), redstoneOreMaxHeight, rangeWatch(redstoneOreMaxHeight), xdom.Br(), ), xjs.AppendChildren(xdom.Td(), xform.Label("Diamond Ore Spawn Size", "diamondOreSpawnSize"), diamondOreSpawnSize, rangeWatch(diamondOreSpawnSize), xdom.Br(), xform.Label("Diamond Ore Spawn Tries", "diamondOreSpawnTries"), diamondOreSpawnTries, rangeWatch(diamondOreSpawnTries), xdom.Br(), xform.Label("Diamond Ore Spawn Min Height", "diamondOreMinHeight"), diamondOreMinHeight, rangeWatch(diamondOreMinHeight), xdom.Br(), xform.Label("Diamond Ore Spawn Max Height", "diamondOreMaxHeight"), diamondOreMaxHeight, rangeWatch(diamondOreMaxHeight), xdom.Br(), ), ), xjs.AppendChildren(xdom.Tr(), xjs.AppendChildren(xdom.Td(), xform.Label("Lapis Lazuli Ore Spawn Size", "lapisLazuliOreSpawnSize"), lapisLazuliOreSpawnSize, rangeWatch(lapisLazuliOreSpawnSize), xdom.Br(), xform.Label("Lapis Lazuli Ore Spawn Tries", "lapisLazuliOreSpawnTries"), lapisLazuliOreSpawnTries, rangeWatch(lapisLazuliOreSpawnTries), xdom.Br(), xform.Label("Lapis Lazuli Ore Centre Height", "lapisLazuliOreCentreHeight"), lapisLazuliOreCentreHeight, rangeWatch(lapisLazuliOreCentreHeight), xdom.Br(), xform.Label("Lapis Lazuli Ore Spread Height", "lapisLazuliOreSpreadHeight"), lapisLazuliOreSpreadHeight, rangeWatch(lapisLazuliOreSpreadHeight), xdom.Br(), ), ), ), xform.Label("Main Noise Scale X", "mainNoiseScaleX"), mainNoiseScaleX, rangeWatch(mainNoiseScaleX), xdom.Br(), xform.Label("Main Noise Scale Y", "mainNoiseScaleY"), mainNoiseScaleY, rangeWatch(mainNoiseScaleY), xdom.Br(), xform.Label("Main Noise Scale Z", "mainNoiseScaleZ"), mainNoiseScaleZ, rangeWatch(mainNoiseScaleZ), xdom.Br(), xform.Label("Depth Noise Scale X", "depthNoiseScaleX"), depthNoiseScaleX, rangeWatch(depthNoiseScaleX), xdom.Br(), xform.Label("Depth Noise Scale Z", "depthNoiseScaleZ"), depthNoiseScaleZ, rangeWatch(depthNoiseScaleZ), xdom.Br(), xform.Label("Depth Noise Exponent", "depthNoiseExponent"), depthNoiseExponent, rangeWatch(depthNoiseExponent), xdom.Br(), xform.Label("Depth Base Size", "depthBaseSize"), depthBaseSize, rangeWatch(depthBaseSize), xdom.Br(), xform.Label("Coordinate Scale", "coordinateScale"), coordinateScale, rangeWatch(coordinateScale), xdom.Br(), xform.Label("Height Scale", "heightScale"), heightScale, rangeWatch(heightScale), xdom.Br(), xform.Label("Height Stretch", "heightStretch"), heightStretch, rangeWatch(heightStretch), xdom.Br(), xform.Label("Upper Limit Scale", "upperLimitScale"), upperLimitScale, rangeWatch(upperLimitScale), xdom.Br(), xform.Label("Lower Limit Scale", "lowerLimitScale"), lowerLimitScale, rangeWatch(lowerLimitScale), xdom.Br(), xform.Label("Biome Depth Weight", "biomeDepthWeight"), biomeDepthWeight, rangeWatch(biomeDepthWeight), xdom.Br(), xform.Label("Biome Depth Offset", "biomeDepthOffset"), biomeDepthOffset, rangeWatch(biomeDepthOffset), xdom.Br(), xform.Label("Biome Scale Weight", "biomeDepthWeight"), biomeScaleWeight, rangeWatch(biomeScaleWeight), xdom.Br(), xform.Label("Biome Scale Offset", "biomeDepthOffset"), biomeScaleOffset, rangeWatch(biomeScaleOffset), xdom.Br(), submit, ) return func(c dom.Element) { c.AppendChild(d) } }
func MapsTab() func(dom.Element) { forceUpdate := make(chan struct{}) nm := xdom.Button() nm.AddEventListener("click", false, func(dom.Event) { d := xdom.Div() o := overlay.New(d) o.OnClose(func() { go func() { forceUpdate <- struct{}{} }() }) xjs.AppendChildren(d, xjs.SetInnerText(xdom.H1(), "New Map"), tabs.New([]tabs.Tab{ {"Create", createMap(o)}, {"Upload/Download", func(c dom.Element) { c.AppendChild(transferFile("Map", "Upload/Download", 1, o)) }}, {"Generate", func(c dom.Element) { c.AppendChild(transferFile("Map", "Generate", 2, o)) }}, }), ) xjs.Body().AppendChild(o) }) noneTd := xdom.Td() noneTd.ColSpan = 2 none := xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(noneTd, "No Maps Found")) mapList := xjs.AppendChildren(xdom.Table(), xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(xdom.Th(), "Map Name"), xjs.SetInnerText(xdom.Th(), "Status"), )), none, ) nodes := xjs.AppendChildren(xdom.Div(), xjs.SetInnerText(xdom.H2(), "Maps"), xjs.SetInnerText(nm, "New Map"), mapList, ) maps := make(map[int]*Map) return func(c dom.Element) { c.AppendChild(nodes) updateStop := make(chan struct{}) registerUpdateStopper(c, updateStop) for { mps, err := RPC.MapList() if err != nil { xjs.Alert("Error getting map list: %s", err) return } if none.ParentNode() != nil { mapList.RemoveChild(none) } for _, m := range maps { m.ID = -1 } for _, m := range mps { om, ok := maps[m.ID] if ok { om.Map = m } else { name := xdom.Td() status := xdom.Td() om = &Map{ Map: m, row: xjs.AppendChildren(xdom.Tr(), name, status, ), name: name, status: status, } maps[m.ID] = om mapList.AppendChild(om.row) name.Class().SetString("mapName") name.AddEventListener("click", false, func() func(dom.Event) { m := om return func(dom.Event) { div := xdom.Div() o := overlay.New(div) div.AppendChild(tabs.New([]tabs.Tab{ {"General", mapGeneral(m.Map)}, {"Properties", mapProperties(m.Map)}, {"Misc.", misc("map", m.Map.ID, o, RPC.RemoveMap)}, })) o.OnClose(func() { go func() { forceUpdate <- struct{}{} }() }) xjs.Body().AppendChild(o) } }()) } switch om.Server { case -2: xjs.SetInnerText(om.status, "Busy") om.status.Style().SetProperty("color", "#f00", "") case -1: xjs.SetInnerText(om.status, "Unassigned") om.status.Style().SetProperty("color", "#00f", "") default: serv, err := RPC.Server(om.Server) if err == nil { xjs.SetInnerText(om.status, "Assigned") } else { xjs.SetInnerText(om.status, "Assigned - "+serv.Name) } om.status.Style().SetProperty("color", "#000", "") } xjs.SetInnerText(om.name, om.Name) } for id, m := range maps { if m.ID == -1 { delete(maps, id) mapList.RemoveChild(m.row) } } if len(maps) == 0 { mapList.AppendChild(none) } // Sleep until update if !updateSleep(forceUpdate, updateStop) { return } } } }