minewebgen - internal/js/maps.go
1 package main
2
3 import (
4 "errors"
5 "strconv"
6 "time"
7
8 "vimagination.zapto.org/gopherjs/overlay"
9 "vimagination.zapto.org/gopherjs/style"
10 "vimagination.zapto.org/gopherjs/tabs"
11 "vimagination.zapto.org/gopherjs/xdom"
12 "vimagination.zapto.org/gopherjs/xform"
13 "vimagination.zapto.org/gopherjs/xjs"
14 "vimagination.zapto.org/minewebgen/internal/data"
15 "honnef.co/go/js/dom"
16 )
17
18 func init() {
19 style.Add(`.mapName {
20 background-color : #ddd;
21 cursor: pointer;
22 cursor: hand;
23 }
24 `)
25 }
26
27 type Map struct {
28 data.Map
29 row dom.Node
30 name *dom.HTMLTableCellElement
31 status *dom.HTMLTableCellElement
32 }
33
34 func MapsTab() func(dom.Element) {
35 forceUpdate := make(chan struct{})
36 nm := xdom.Button()
37 nm.AddEventListener("click", false, func(dom.Event) {
38 d := xdom.Div()
39 o := overlay.New(d)
40 o.OnClose(func() {
41 go func() {
42 forceUpdate <- struct{}{}
43 }()
44 })
45 xjs.AppendChildren(d,
46 xjs.SetInnerText(xdom.H1(), "New Map"),
47 tabs.New([]tabs.Tab{
48 {"Create", createMap(o)},
49 {"Upload/Download", func(c dom.Element) {
50 c.AppendChild(transferFile("Map", "Upload/Download", 1, o))
51 }},
52 {"Generate", func(c dom.Element) {
53 c.AppendChild(transferFile("Map", "Generate", 2, o))
54 }},
55 }),
56 )
57 xjs.Body().AppendChild(o)
58 })
59 noneTd := xdom.Td()
60 noneTd.ColSpan = 2
61 none := xjs.AppendChildren(xdom.Tr(), xjs.SetInnerText(noneTd, "No Maps Found"))
62 mapList := xjs.AppendChildren(xdom.Table(),
63 xjs.AppendChildren(xdom.Thead(), xjs.AppendChildren(xdom.Tr(),
64 xjs.SetInnerText(xdom.Th(), "Map Name"),
65 xjs.SetInnerText(xdom.Th(), "Status"),
66 )),
67 none,
68 )
69 nodes := xjs.AppendChildren(xdom.Div(),
70 xjs.SetInnerText(xdom.H2(), "Maps"),
71 xjs.SetInnerText(nm, "New Map"),
72 mapList,
73 )
74
75 maps := make(map[int]*Map)
76 return func(c dom.Element) {
77 c.AppendChild(nodes)
78 updateStop := make(chan struct{})
79 registerUpdateStopper(c, updateStop)
80 for {
81 mps, err := RPC.MapList()
82 if err != nil {
83 xjs.Alert("Error getting map list: %s", err)
84 return
85 }
86
87 if none.ParentNode() != nil {
88 mapList.RemoveChild(none)
89 }
90
91 for _, m := range maps {
92 m.ID = -1
93 }
94
95 for _, m := range mps {
96 om, ok := maps[m.ID]
97 if ok {
98 om.Map = m
99 } else {
100 name := xdom.Td()
101 status := xdom.Td()
102 om = &Map{
103 Map: m,
104 row: xjs.AppendChildren(xdom.Tr(),
105 name,
106 status,
107 ),
108 name: name,
109 status: status,
110 }
111 maps[m.ID] = om
112 mapList.AppendChild(om.row)
113 name.Class().SetString("mapName")
114 name.AddEventListener("click", false, func() func(dom.Event) {
115 m := om
116 return func(dom.Event) {
117 div := xdom.Div()
118 o := overlay.New(div)
119 div.AppendChild(tabs.New([]tabs.Tab{
120 {"General", mapGeneral(m.Map)},
121 {"Properties", mapProperties(m.Map)},
122 {"Misc.", misc("map", m.Map.ID, o, RPC.RemoveMap)},
123 }))
124 o.OnClose(func() {
125 go func() {
126 forceUpdate <- struct{}{}
127 }()
128 })
129 xjs.Body().AppendChild(o)
130 }
131 }())
132 }
133 switch om.Server {
134 case -2:
135 xjs.SetInnerText(om.status, "Busy")
136 om.status.Style().SetProperty("color", "#f00", "")
137 case -1:
138 xjs.SetInnerText(om.status, "Unassigned")
139 om.status.Style().SetProperty("color", "#00f", "")
140 default:
141 serv, err := RPC.Server(om.Server)
142 if err == nil {
143 xjs.SetInnerText(om.status, "Assigned")
144 } else {
145 xjs.SetInnerText(om.status, "Assigned - "+serv.Name)
146 }
147 om.status.Style().SetProperty("color", "#000", "")
148 }
149 xjs.SetInnerText(om.name, om.Name)
150 }
151
152 for id, m := range maps {
153 if m.ID == -1 {
154 delete(maps, id)
155 mapList.RemoveChild(m.row)
156 }
157 }
158
159 if len(maps) == 0 {
160 mapList.AppendChild(none)
161 }
162
163 // Sleep until update
164 if !updateSleep(forceUpdate, updateStop) {
165 return
166 }
167 }
168 }
169 }
170
171 var gameModes = [...]string{"Survival", "Creative", "Adventure", "Hardcore", "Spectator"}
172
173 func createMap(o *overlay.Overlay) func(dom.Element) {
174 return func(c dom.Element) {
175 name := xform.InputText("name", "")
176 name.Required = true
177 gmOpts := make([]xform.Option, len(gameModes))
178 for i, m := range gameModes {
179 gmOpts[i] = xform.Option{
180 Label: m,
181 Value: strconv.Itoa(i),
182 }
183 }
184 gameMode := xform.SelectBox("gamemode", gmOpts...)
185 seed := xform.InputText("seed", "")
186 structures := xform.InputCheckbox("structures", true)
187 cheats := xform.InputCheckbox("cheats", false)
188 fs := xdom.Fieldset()
189 fs.AppendChild(xjs.SetInnerText(xdom.Legend(), "Create Map"))
190 c.AppendChild(xjs.AppendChildren(xdom.Form(), fs))
191 dataParser := func(mode int) func() (data.DefaultMap, error) {
192 return func() (data.DefaultMap, error) {
193 data := data.DefaultMap{
194 Mode: mode,
195 }
196 var err error
197 data.Name = name.Value
198 si := gameMode.SelectedIndex
199 if si < 0 || si >= len(gameModes) {
200 return data, errors.New("invalid gamemode")
201 }
202 if seed.Value == "" {
203 seed.Value = "0"
204 }
205 data.Seed, err = strconv.ParseInt(seed.Value, 10, 64)
206 if err != nil {
207 return data, err
208 }
209 data.Structures = structures.Checked
210 data.Cheats = cheats.Checked
211 return data, nil
212 }
213 }
214 xjs.AppendChildren(fs,
215 xform.Label("Name", "name"),
216 name,
217 xdom.Br(),
218 xform.Label("Game Mode", "gamemode"),
219 gameMode,
220 xdom.Br(),
221 xform.Label("Level Seed", "seed"),
222 seed,
223 xdom.Br(),
224 xform.Label("Structures", "structures"),
225 structures,
226 xdom.Br(),
227 xform.Label("Cheats", "cheats"),
228 cheats,
229 xdom.Br(),
230 tabs.New([]tabs.Tab{
231 {"Default", createMapMode(0, o, dataParser(0))},
232 {"Super Flat", createSuperFlatMap(o, dataParser(1))},
233 {"Large Biomes", createMapMode(2, o, dataParser(2))},
234 {"Amplified", createMapMode(3, o, dataParser(3))},
235 {"Customised", createCustomisedMap(o, dataParser(4))},
236 }),
237 )
238 }
239 }
240
241 var worldTypes = [...]string{
242 "The standard minecraft map generation.",
243 "A simple generator allowing customised levels of blocks.",
244 "The standard minecraft map generation, but tweaked to allow for much larger biomes.",
245 "The standard minecraft map generation, but tweaked to stretch the land upwards.",
246 "A completely customiseable generator.",
247 }
248
249 func createMapMode(mode int, o *overlay.Overlay, dataParser func() (data.DefaultMap, error)) func(dom.Element) {
250 submit := xform.InputSubmit("Create Map")
251 submit.AddEventListener("click", false, func(e dom.Event) {
252 data, err := dataParser()
253 if err != nil {
254 xjs.Alert("Error parsing values: %s", err)
255 return
256 }
257 e.PreventDefault()
258 go func() {
259 err = RPC.CreateDefaultMap(data)
260 if err != nil {
261 xjs.Alert("Error creating map: %s", err)
262 return
263 }
264 o.Close()
265 }()
266 })
267 return func(c dom.Element) {
268 xjs.AppendChildren(c,
269 xjs.SetPreText(xdom.Div(), worldTypes[mode]),
270 xdom.Br(),
271 submit,
272 )
273 }
274 }
275
276 func createSuperFlatMap(o *overlay.Overlay, dataParser func() (data.DefaultMap, error)) func(dom.Element) {
277 // create better UI here
278 d := xdom.Div()
279 gs := xform.InputText("settings", "0")
280 gs.Required = true
281 submit := xform.InputSubmit("Create Map")
282 xjs.AppendChildren(d,
283 xjs.SetPreText(xdom.Div(), worldTypes[1]),
284 xform.Label("Generator Settings", "settings"),
285 gs,
286 xdom.Br(),
287 submit,
288 )
289 submit.AddEventListener("click", false, func(e dom.Event) {
290 d, err := dataParser()
291 if err != nil {
292 xjs.Alert("Error parsing values: %s", err)
293 return
294 }
295 e.PreventDefault()
296 go func() {
297 err = RPC.CreateSuperflatMap(data.SuperFlatMap{
298 DefaultMap: d,
299 GeneratorSettings: gs.Value,
300 })
301 if err != nil {
302 xjs.Alert("Error creating map: %s", err)
303 return
304 }
305 o.Close()
306
307 }()
308 })
309 return func(c dom.Element) {
310 c.AppendChild(d)
311 }
312 }
313
314 func rangeWatch(r *dom.HTMLInputElement) dom.Element {
315 s := xdom.Span()
316 xjs.SetInnerText(s, r.Value)
317 r.AddEventListener("input", false, func(dom.Event) {
318 xjs.SetInnerText(s, r.Value)
319 })
320 return s
321 }
322
323 func enabler(c, r *dom.HTMLInputElement) {
324 c.AddEventListener("click", false, func(dom.Event) {
325 r.Disabled = !c.Checked
326 })
327 }
328
329 var biomes = []xform.Option{
330 {"All", "-1", false},
331 {"Ocean", "0", false},
332 {"Plains", "1", false},
333 {"Desert", "2", false},
334 {"Extreme Hills", "3", false},
335 {"Forest", "4", false},
336 {"Taiga", "5", false},
337 {"Swampland", "6", false},
338 {"River", "7", false},
339 {"Frozen Ocean", "10", false},
340 {"Frozen River", "11", false},
341 {"Ice Plains", "12", false},
342 {"Ice Mountains", "13", false},
343 {"Mushroom Island", "14", false},
344 {"Mushroom Island Shore", "15", false},
345 {"Beach", "16", false},
346 {"Desert Hills", "17", false},
347 {"Forest Hills", "18", false},
348 {"Taiga Hills", "19", false},
349 {"Extreme Hills Edge", "20", false},
350 {"Jungle", "21", false},
351 {"Jungle Hills", "22", false},
352 {"Jungle Edge", "23", false},
353 {"Deep Ocean", "24", false},
354 {"Stone Beach", "25", false},
355 {"Cold Beach", "26", false},
356 {"Birch Forest", "27", false},
357 {"Birch Forest Hills", "28", false},
358 {"Roofed Forest", "29", false},
359 {"Cold Taiga", "30", false},
360 {"Cold Taiga Hills", "31", false},
361 {"Mega Taiga", "32", false},
362 {"Mega Taiga Hills", "33", false},
363 {"Extreme Hills+", "34", false},
364 {"Savanna", "35", false},
365 {"Savanna Plateau", "36", false},
366 {"Mesa", "37", false},
367 {"Mesa Plateau F", "38", false},
368 {"Mesa Plateau", "39", false},
369 }
370
371 func init() {
372 style.Add(`.brClear br {
373 clear : left;
374 }
375 `)
376 }
377
378 func createCustomisedMap(o *overlay.Overlay, dataParser func() (data.DefaultMap, error)) func(dom.Element) {
379 d := xdom.Div()
380 d.Class().SetString("brClear")
381 seaLevel := xform.InputRange("sea", 0, 255, 1, 63)
382 caves := xform.InputCheckbox("caves", true)
383 strongholds := xform.InputCheckbox("strongholds", true)
384 villages := xform.InputCheckbox("villages", true)
385 mineshafts := xform.InputCheckbox("mineshafts", true)
386 temples := xform.InputCheckbox("templaes", true)
387 oceanMonuments := xform.InputCheckbox("oceanMonuments", true)
388 ravines := xform.InputCheckbox("ravines", true)
389 dungeons := xform.InputCheckbox("dungeons", true)
390 dungeonCount := xform.InputRange("dungeonCount", 1, 100, 1, 7)
391 waterLakes := xform.InputCheckbox("waterLakes", true)
392 waterLakeRarity := xform.InputRange("waterLakeRarity", 1, 100, 1, 4)
393 lavaLakes := xform.InputCheckbox("lavaLakes", true)
394 lavaLakeRarity := xform.InputRange("lavaLakeRarity", 1, 100, 1, 80)
395 biome := xform.SelectBox("biomes", biomes...)
396 biomeSize := xform.InputRange("biomeSize", 1, 8, 1, 4)
397 riverSize := xform.InputRange("riverSize", 1, 5, 1, 4)
398
399 dirtSpawnSize := xform.InputRange("dirtSpawnSize", 1, 50, 1, 33)
400 dirtSpawnTries := xform.InputRange("dirtSpawnTries", 0, 40, 1, 10)
401 dirtMinHeight := xform.InputRange("dirtMinHeight", 0, 255, 1, 0)
402 dirtMaxHeight := xform.InputRange("dirtMaxHeight", 0, 255, 1, 256)
403
404 gravelSpawnSize := xform.InputRange("gravelSpawnSize", 1, 50, 1, 33)
405 gravelSpawnTries := xform.InputRange("gravelSpawnTries", 0, 40, 1, 8)
406 gravelMinHeight := xform.InputRange("gravelMinHeight", 0, 255, 1, 0)
407 gravelMaxHeight := xform.InputRange("gravelMaxHeight", 0, 255, 1, 256)
408
409 graniteSpawnSize := xform.InputRange("graniteSpawnSize", 1, 50, 1, 33)
410 graniteSpawnTries := xform.InputRange("graniteSpawnTries", 0, 40, 1, 10)
411 graniteMinHeight := xform.InputRange("graniteMinHeight", 0, 255, 1, 0)
412 graniteMaxHeight := xform.InputRange("graniteMaxHeight", 0, 255, 1, 80)
413
414 dioriteSpawnSize := xform.InputRange("dioriteSpawnSize", 1, 50, 1, 33)
415 dioriteSpawnTries := xform.InputRange("dioriteSpawnTries", 0, 40, 1, 10)
416 dioriteMinHeight := xform.InputRange("dioriteMinHeight", 0, 255, 1, 0)
417 dioriteMaxHeight := xform.InputRange("dioriteMaxHeight", 0, 255, 1, 80)
418
419 andesiteSpawnSize := xform.InputRange("andesiteSpawnSize", 1, 50, 1, 33)
420 andesiteSpawnTries := xform.InputRange("andesiteSpawnTries", 0, 40, 1, 10)
421 andesiteMinHeight := xform.InputRange("andesiteMinHeight", 0, 255, 1, 0)
422 andesiteMaxHeight := xform.InputRange("andesiteMaxHeight", 0, 255, 1, 80)
423
424 coalOreSpawnSize := xform.InputRange("coalOreSpawnSize", 1, 50, 1, 17)
425 coalOreSpawnTries := xform.InputRange("coalOreSpawnTries", 0, 40, 1, 20)
426 coalOreMinHeight := xform.InputRange("coalOreMinHeight", 0, 255, 1, 0)
427 coalOreMaxHeight := xform.InputRange("coalOreMaxHeight", 0, 255, 1, 128)
428
429 ironOreSpawnSize := xform.InputRange("ironOreSpawnSize", 1, 50, 1, 9)
430 ironOreSpawnTries := xform.InputRange("ironOreSpawnTries", 0, 40, 1, 20)
431 ironOreMinHeight := xform.InputRange("ironOreMinHeight", 0, 255, 1, 0)
432 ironOreMaxHeight := xform.InputRange("ironOreMaxHeight", 0, 255, 1, 64)
433
434 goldOreSpawnSize := xform.InputRange("goldOreSpawnSize", 1, 50, 1, 9)
435 goldOreSpawnTries := xform.InputRange("goldOreSpawnTries", 0, 40, 1, 2)
436 goldOreMinHeight := xform.InputRange("goldOreMinHeight", 0, 255, 1, 0)
437 goldOreMaxHeight := xform.InputRange("goldOreMaxHeight", 0, 255, 1, 32)
438
439 redstoneOreSpawnSize := xform.InputRange("redstoneOreSpawnSize", 1, 50, 1, 8)
440 redstoneOreSpawnTries := xform.InputRange("redstoneOreSpawnTries", 0, 40, 1, 8)
441 redstoneOreMinHeight := xform.InputRange("redstoneOreMinHeight", 0, 255, 1, 0)
442 redstoneOreMaxHeight := xform.InputRange("redstoneOreMaxHeight", 0, 255, 1, 16)
443
444 diamondOreSpawnSize := xform.InputRange("diamondOreSpawnSize", 1, 50, 1, 8)
445 diamondOreSpawnTries := xform.InputRange("diamondOreSpawnTries", 0, 40, 1, 1)
446 diamondOreMinHeight := xform.InputRange("diamondOreMinHeight", 0, 255, 1, 0)
447 diamondOreMaxHeight := xform.InputRange("diamondOreMaxHeight", 0, 255, 1, 16)
448
449 lapisLazuliOreSpawnSize := xform.InputRange("lapisLazuliOreSpawnSize", 1, 50, 1, 7)
450 lapisLazuliOreSpawnTries := xform.InputRange("lapisLazuliOreSpawnTries", 0, 40, 1, 1)
451 lapisLazuliOreCentreHeight := xform.InputRange("lapisLazuliOreCentreHeight", 0, 255, 1, 16)
452 lapisLazuliOreSpreadHeight := xform.InputRange("lapisLazuliOreSpreadHeight", 0, 255, 1, 16)
453
454 mainNoiseScaleX := xform.InputRange("mainNoiseScaleX", 1, 5000, -1, 80)
455 mainNoiseScaleY := xform.InputRange("mainNoiseScaleY", 1, 5000, -1, 160)
456 mainNoiseScaleZ := xform.InputRange("mainNoiseScaleZ", 1, 5000, -1, 80)
457 depthNoiseScaleX := xform.InputRange("depthNoiseScaleX", 1, 2000, -1, 200)
458 depthNoiseScaleZ := xform.InputRange("depthNoiseScaleZ", 1, 2000, -1, 200)
459 depthNoiseExponent := xform.InputRange("depthNoiseExponent", 0.01, 20, -1, 0.5)
460 depthBaseSize := xform.InputRange("depthBaseSize", 1, 25, -1, 8.5)
461 coordinateScale := xform.InputRange("coordinateScale", 1, 6000, -1, 684.412)
462 heightScale := xform.InputRange("heightScale", 1, 6000, -1, 684.412)
463 heightStretch := xform.InputRange("heightStretch", 0.01, 50, -1, 12)
464 upperLimitScale := xform.InputRange("upperLimitScale", 1, 5000, -1, 512)
465 lowerLimitScale := xform.InputRange("lowerLimitScale", 1, 5000, -1, 512)
466 biomeDepthWeight := xform.InputRange("biomeDepthWeight", 1, 20, -1, 1)
467 biomeDepthOffset := xform.InputRange("biomeDepthOffset", 0, 20, -1, 0)
468 biomeScaleWeight := xform.InputRange("biomeScaleWeight", 1, 20, -1, 1)
469 biomeScaleOffset := xform.InputRange("biomeScaleOffset", 0, 20, -1, 0)
470
471 submit := xform.InputSubmit("Create Map")
472 submit.AddEventListener("click", false, func(e dom.Event) {
473 d, err := dataParser()
474 if err != nil {
475 xjs.Alert("Error parsing values: %s", err)
476 return
477 }
478 e.PreventDefault()
479 cd := data.CustomMap{
480 DefaultMap: d,
481 }
482 cd.GeneratorSettings.SeaLevel = uint8(seaLevel.ValueAsNumber)
483 cd.GeneratorSettings.Caves = caves.Checked
484 cd.GeneratorSettings.Strongholds = strongholds.Checked
485 cd.GeneratorSettings.Villages = villages.Checked
486 cd.GeneratorSettings.Mineshafts = mineshafts.Checked
487 cd.GeneratorSettings.Temples = temples.Checked
488 cd.GeneratorSettings.OceanMonuments = oceanMonuments.Checked
489 cd.GeneratorSettings.Ravines = ravines.Checked
490 cd.GeneratorSettings.Dungeons = dungeons.Checked
491 cd.GeneratorSettings.DungeonChance = uint8(dungeonCount.ValueAsNumber)
492 cd.GeneratorSettings.WaterLake = waterLakes.Checked
493 cd.GeneratorSettings.WaterLakeChance = uint8(waterLakeRarity.ValueAsNumber)
494 cd.GeneratorSettings.LaveLake = lavaLakes.Checked
495 cd.GeneratorSettings.LavaLakeChance = uint8(lavaLakeRarity.ValueAsNumber)
496 b, err := strconv.Atoi(biome.Value)
497 if err != nil {
498 b = -1
499 }
500 cd.GeneratorSettings.Biome = int16(b)
501
502 cd.GeneratorSettings.BiomeSize = uint8(biomeSize.ValueAsNumber)
503 cd.GeneratorSettings.RiverSize = uint8(riverSize.ValueAsNumber)
504
505 cd.GeneratorSettings.DirtSize = uint8(dirtSpawnSize.ValueAsNumber)
506 cd.GeneratorSettings.DirtTries = uint8(dirtSpawnTries.ValueAsNumber)
507 cd.GeneratorSettings.DirtMinHeight = uint8(dirtMinHeight.ValueAsNumber)
508 cd.GeneratorSettings.DirtMaxHeight = uint8(dirtMaxHeight.ValueAsNumber)
509
510 cd.GeneratorSettings.GravelSize = uint8(gravelSpawnSize.ValueAsNumber)
511 cd.GeneratorSettings.GravelTries = uint8(gravelSpawnTries.ValueAsNumber)
512 cd.GeneratorSettings.GravelMinHeight = uint8(gravelMinHeight.ValueAsNumber)
513 cd.GeneratorSettings.GravelMaxHeight = uint8(gravelMaxHeight.ValueAsNumber)
514
515 cd.GeneratorSettings.GraniteSize = uint8(graniteSpawnSize.ValueAsNumber)
516 cd.GeneratorSettings.GraniteTries = uint8(graniteSpawnTries.ValueAsNumber)
517 cd.GeneratorSettings.GraniteMinHeight = uint8(graniteMinHeight.ValueAsNumber)
518 cd.GeneratorSettings.GraniteMaxHeight = uint8(graniteMaxHeight.ValueAsNumber)
519
520 cd.GeneratorSettings.DiortiteSize = uint8(dioriteSpawnSize.ValueAsNumber)
521 cd.GeneratorSettings.DiortiteTries = uint8(dioriteSpawnTries.ValueAsNumber)
522 cd.GeneratorSettings.DiortiteMinHeight = uint8(dioriteMinHeight.ValueAsNumber)
523 cd.GeneratorSettings.DiortiteMaxHeight = uint8(dioriteMaxHeight.ValueAsNumber)
524
525 cd.GeneratorSettings.AndesiteSize = uint8(andesiteSpawnSize.ValueAsNumber)
526 cd.GeneratorSettings.AndesiteTries = uint8(andesiteSpawnTries.ValueAsNumber)
527 cd.GeneratorSettings.AndesiteMinHeight = uint8(andesiteMinHeight.ValueAsNumber)
528 cd.GeneratorSettings.AndesiteMaxHeight = uint8(andesiteMaxHeight.ValueAsNumber)
529
530 cd.GeneratorSettings.CoalSize = uint8(coalOreSpawnSize.ValueAsNumber)
531 cd.GeneratorSettings.CoalTries = uint8(coalOreSpawnTries.ValueAsNumber)
532 cd.GeneratorSettings.CoalMinHeight = uint8(coalOreMinHeight.ValueAsNumber)
533 cd.GeneratorSettings.CoalMaxHeight = uint8(coalOreMaxHeight.ValueAsNumber)
534
535 cd.GeneratorSettings.IronSize = uint8(ironOreSpawnSize.ValueAsNumber)
536 cd.GeneratorSettings.IronTries = uint8(ironOreSpawnTries.ValueAsNumber)
537 cd.GeneratorSettings.IronMinHeight = uint8(ironOreMinHeight.ValueAsNumber)
538 cd.GeneratorSettings.IronMaxHeight = uint8(ironOreMaxHeight.ValueAsNumber)
539
540 cd.GeneratorSettings.GoldSize = uint8(goldOreSpawnSize.ValueAsNumber)
541 cd.GeneratorSettings.GoldTries = uint8(goldOreSpawnTries.ValueAsNumber)
542 cd.GeneratorSettings.GoldMinHeight = uint8(goldOreMinHeight.ValueAsNumber)
543 cd.GeneratorSettings.GoldMaxHeight = uint8(goldOreMaxHeight.ValueAsNumber)
544
545 cd.GeneratorSettings.RedstoneSize = uint8(redstoneOreSpawnSize.ValueAsNumber)
546 cd.GeneratorSettings.RedstoneTries = uint8(redstoneOreSpawnTries.ValueAsNumber)
547 cd.GeneratorSettings.RedstoneMinHeight = uint8(redstoneOreMinHeight.ValueAsNumber)
548 cd.GeneratorSettings.RedstoneMaxHeight = uint8(redstoneOreMaxHeight.ValueAsNumber)
549
550 cd.GeneratorSettings.DiamondSize = uint8(diamondOreSpawnSize.ValueAsNumber)
551 cd.GeneratorSettings.DiamondTries = uint8(diamondOreSpawnTries.ValueAsNumber)
552 cd.GeneratorSettings.DiamondMinHeight = uint8(diamondOreMinHeight.ValueAsNumber)
553 cd.GeneratorSettings.DiamondMaxHeight = uint8(diamondOreMaxHeight.ValueAsNumber)
554
555 cd.GeneratorSettings.LapisSize = uint8(lapisLazuliOreSpawnSize.ValueAsNumber)
556 cd.GeneratorSettings.LapisTries = uint8(lapisLazuliOreSpawnTries.ValueAsNumber)
557 cd.GeneratorSettings.LapisCenterHeight = uint8(lapisLazuliOreCentreHeight.ValueAsNumber)
558 cd.GeneratorSettings.LapisSpread = uint8(lapisLazuliOreSpreadHeight.ValueAsNumber)
559
560 cd.GeneratorSettings.MainNoiseScaleX = mainNoiseScaleX.ValueAsNumber
561 cd.GeneratorSettings.MainNoiseScaleY = mainNoiseScaleY.ValueAsNumber
562 cd.GeneratorSettings.MainNoiseScaleZ = mainNoiseScaleZ.ValueAsNumber
563 cd.GeneratorSettings.DepthNoiseScaleX = depthNoiseScaleX.ValueAsNumber
564 cd.GeneratorSettings.DepthNoiseScaleZ = depthNoiseScaleZ.ValueAsNumber
565 cd.GeneratorSettings.DepthNoiseScaleExponent = depthNoiseExponent.ValueAsNumber
566 cd.GeneratorSettings.BaseSize = depthBaseSize.ValueAsNumber
567 cd.GeneratorSettings.CoordinateScale = coordinateScale.ValueAsNumber
568 cd.GeneratorSettings.HeightScale = heightScale.ValueAsNumber
569 cd.GeneratorSettings.HeightStretch = heightStretch.ValueAsNumber
570 cd.GeneratorSettings.UpperLimitScale = upperLimitScale.ValueAsNumber
571 cd.GeneratorSettings.LowerLimitScale = lowerLimitScale.ValueAsNumber
572 cd.GeneratorSettings.BiomeDepthWeight = biomeDepthWeight.ValueAsNumber
573 cd.GeneratorSettings.BiomeDepthOffset = biomeDepthOffset.ValueAsNumber
574 cd.GeneratorSettings.BiomeScaleWeight = biomeScaleWeight.ValueAsNumber
575 cd.GeneratorSettings.BiomeScaleOffset = biomeScaleOffset.ValueAsNumber
576 go func() {
577 err = RPC.CreateCustomMap(cd)
578 if err != nil {
579 xjs.Alert("Error creating map: %s", err)
580 return
581 }
582 o.Close()
583 }()
584 })
585
586 enabler(dungeons, dungeonCount)
587 enabler(waterLakes, waterLakeRarity)
588 enabler(lavaLakes, lavaLakeRarity)
589
590 xjs.AppendChildren(d,
591 xform.Label("Sea Level", "sea"), seaLevel, rangeWatch(seaLevel), xdom.Br(),
592 xform.Label("Caves", "caves"), caves, xdom.Br(),
593 xform.Label("Strongholds", "strongholds"), strongholds, xdom.Br(),
594 xform.Label("Villages", "villages"), villages, xdom.Br(),
595 xform.Label("Mineshafts", "mineshafts"), mineshafts, xdom.Br(),
596 xform.Label("Temples", "temples"), temples, xdom.Br(),
597 xform.Label("Ocean Monuments", "oceanMonuments"), oceanMonuments, xdom.Br(),
598 xform.Label("Ravines", "ravines"), ravines, xdom.Br(),
599 xform.Label("Dungeons", "dungeons"), dungeons, xdom.Br(),
600 xform.Label("Dungeon Count", "dungeonCount"), dungeonCount, rangeWatch(dungeonCount), xdom.Br(),
601 xform.Label("Water Lakes", "waterLakes"), waterLakes, xdom.Br(),
602 xform.Label("Water Lake Rarity", "waterLakeRarity"), waterLakeRarity, rangeWatch(waterLakeRarity), xdom.Br(),
603 xform.Label("Lava Lakes", "lavaLakes"), lavaLakes, xdom.Br(),
604 xform.Label("Lava Lake Rarity", "lavaLakeRarity"), lavaLakeRarity, rangeWatch(lavaLakeRarity), xdom.Br(),
605 xform.Label("Biomes", "biomes"), biome, xdom.Br(),
606 xform.Label("Biome Size", "biomeSize"), biomeSize, xdom.Br(),
607 xform.Label("River Size", "riverSize"), riverSize, xdom.Br(),
608 xdom.Br(),
609 xjs.AppendChildren(xdom.Table(),
610 xjs.AppendChildren(xdom.Tr(),
611 xjs.AppendChildren(xdom.Td(),
612 xform.Label("Dirt Spawn Size", "dirtSpawnSize"), dirtSpawnSize, rangeWatch(dirtSpawnSize), xdom.Br(),
613 xform.Label("Dirt Spawn Tries", "dirtSpawnTries"), dirtSpawnTries, rangeWatch(dirtSpawnTries), xdom.Br(),
614 xform.Label("Dirt Spawn Min Height", "dirtMinHeight"), dirtMinHeight, rangeWatch(dirtMinHeight), xdom.Br(),
615 xform.Label("Dirt Spawn Max Height", "dirtMaxHeight"), dirtMaxHeight, rangeWatch(dirtMaxHeight), xdom.Br(),
616 ),
617 xjs.AppendChildren(xdom.Td(),
618 xform.Label("Gravel Spawn Size", "gravelSpawnSize"), gravelSpawnSize, rangeWatch(gravelSpawnSize), xdom.Br(),
619 xform.Label("Gravel Spawn Tries", "gravelSpawnTries"), gravelSpawnTries, rangeWatch(gravelSpawnTries), xdom.Br(),
620 xform.Label("Gravel Spawn Min Height", "gravelMinHeight"), gravelMinHeight, rangeWatch(gravelMinHeight), xdom.Br(),
621 xform.Label("Gravel Spawn Max Height", "gravelMaxHeight"), gravelMaxHeight, rangeWatch(gravelMaxHeight), xdom.Br(),
622 ),
623 ),
624 xjs.AppendChildren(xdom.Tr(),
625 xjs.AppendChildren(xdom.Td(),
626 xform.Label("Granite Spawn Size", "graniteSpawnSize"), graniteSpawnSize, rangeWatch(graniteSpawnSize), xdom.Br(),
627 xform.Label("Granite Spawn Tries", "graniteSpawnTries"), graniteSpawnTries, rangeWatch(graniteSpawnTries), xdom.Br(),
628 xform.Label("Granite Spawn Min Height", "graniteMinHeight"), graniteMinHeight, rangeWatch(graniteMinHeight), xdom.Br(),
629 xform.Label("Granite Spawn Max Height", "graniteMaxHeight"), graniteMaxHeight, rangeWatch(graniteMaxHeight), xdom.Br(),
630 ),
631 xjs.AppendChildren(xdom.Td(),
632 xform.Label("Diorite Spawn Size", "dioriteSpawnSize"), dioriteSpawnSize, rangeWatch(dioriteSpawnSize), xdom.Br(),
633 xform.Label("Diorite Spawn Tries", "dioriteSpawnTries"), dioriteSpawnTries, rangeWatch(dioriteSpawnTries), xdom.Br(),
634 xform.Label("Diorite Spawn Min Height", "dioriteMinHeight"), dioriteMinHeight, rangeWatch(dioriteMinHeight), xdom.Br(),
635 xform.Label("Diorite Spawn Max Height", "dioriteMaxHeight"), dioriteMaxHeight, rangeWatch(dioriteMaxHeight), xdom.Br(),
636 ),
637 ),
638 xjs.AppendChildren(xdom.Tr(),
639 xjs.AppendChildren(xdom.Td(),
640 xform.Label("Andesite Spawn Size", "andesiteSpawnSize"), andesiteSpawnSize, rangeWatch(andesiteSpawnSize), xdom.Br(),
641 xform.Label("Andesite Spawn Tries", "andesiteSpawnTries"), andesiteSpawnTries, rangeWatch(andesiteSpawnTries), xdom.Br(),
642 xform.Label("Andesite Spawn Min Height", "andesiteMinHeight"), andesiteMinHeight, rangeWatch(andesiteMinHeight), xdom.Br(),
643 xform.Label("Andesite Spawn Max Height", "andesiteMaxHeight"), andesiteMaxHeight, rangeWatch(andesiteMaxHeight), xdom.Br(),
644 ),
645 xjs.AppendChildren(xdom.Td(),
646 xform.Label("Coal Ore Spawn Size", "coalOreSpawnSize"), coalOreSpawnSize, rangeWatch(coalOreSpawnSize), xdom.Br(),
647 xform.Label("Coal Ore Spawn Tries", "coalOreSpawnTries"), coalOreSpawnTries, rangeWatch(coalOreSpawnTries), xdom.Br(),
648 xform.Label("Coal Ore Spawn Min Height", "coalOreMinHeight"), coalOreMinHeight, rangeWatch(coalOreMinHeight), xdom.Br(),
649 xform.Label("Coal Ore Spawn Max Height", "coalOreMaxHeight"), coalOreMaxHeight, rangeWatch(coalOreMaxHeight), xdom.Br(),
650 ),
651 ),
652 xjs.AppendChildren(xdom.Tr(),
653 xjs.AppendChildren(xdom.Td(),
654 xform.Label("Iron Ore Spawn Size", "ironOreSpawnSize"), ironOreSpawnSize, rangeWatch(ironOreSpawnSize), xdom.Br(),
655 xform.Label("Iron Ore Spawn Tries", "ironOreSpawnTries"), ironOreSpawnTries, rangeWatch(ironOreSpawnTries), xdom.Br(),
656 xform.Label("Iron Ore Spawn Min Height", "ironOreMinHeight"), ironOreMinHeight, rangeWatch(ironOreMinHeight), xdom.Br(),
657 xform.Label("Iron Ore Spawn Max Height", "ironOreMaxHeight"), ironOreMaxHeight, rangeWatch(ironOreMaxHeight), xdom.Br(),
658 ),
659 xjs.AppendChildren(xdom.Td(),
660 xform.Label("Gold Ore Spawn Size", "goldOreSpawnSize"), goldOreSpawnSize, rangeWatch(goldOreSpawnSize), xdom.Br(),
661 xform.Label("Gold Ore Spawn Tries", "goldOreSpawnTries"), goldOreSpawnTries, rangeWatch(goldOreSpawnTries), xdom.Br(),
662 xform.Label("Gold Ore Spawn Min Height", "goldOreMinHeight"), goldOreMinHeight, rangeWatch(goldOreMinHeight), xdom.Br(),
663 xform.Label("Gold Ore Spawn Max Height", "goldOreMaxHeight"), goldOreMaxHeight, rangeWatch(goldOreMaxHeight), xdom.Br(),
664 ),
665 ),
666 xjs.AppendChildren(xdom.Tr(),
667 xjs.AppendChildren(xdom.Td(),
668 xform.Label("Redstone Ore Spawn Size", "redstoneOreSpawnSize"), redstoneOreSpawnSize, rangeWatch(redstoneOreSpawnSize), xdom.Br(),
669 xform.Label("Redstone Ore Spawn Tries", "redstoneOreSpawnTries"), redstoneOreSpawnTries, rangeWatch(redstoneOreSpawnTries), xdom.Br(),
670 xform.Label("Redstone Ore Spawn Min Height", "redstoneOreMinHeight"), redstoneOreMinHeight, rangeWatch(redstoneOreMinHeight), xdom.Br(),
671 xform.Label("Redstone Ore Spawn Max Height", "redstoneOreMaxHeight"), redstoneOreMaxHeight, rangeWatch(redstoneOreMaxHeight), xdom.Br(),
672 ),
673 xjs.AppendChildren(xdom.Td(),
674 xform.Label("Diamond Ore Spawn Size", "diamondOreSpawnSize"), diamondOreSpawnSize, rangeWatch(diamondOreSpawnSize), xdom.Br(),
675 xform.Label("Diamond Ore Spawn Tries", "diamondOreSpawnTries"), diamondOreSpawnTries, rangeWatch(diamondOreSpawnTries), xdom.Br(),
676 xform.Label("Diamond Ore Spawn Min Height", "diamondOreMinHeight"), diamondOreMinHeight, rangeWatch(diamondOreMinHeight), xdom.Br(),
677 xform.Label("Diamond Ore Spawn Max Height", "diamondOreMaxHeight"), diamondOreMaxHeight, rangeWatch(diamondOreMaxHeight), xdom.Br(),
678 ),
679 ),
680 xjs.AppendChildren(xdom.Tr(),
681 xjs.AppendChildren(xdom.Td(),
682 xform.Label("Lapis Lazuli Ore Spawn Size", "lapisLazuliOreSpawnSize"), lapisLazuliOreSpawnSize, rangeWatch(lapisLazuliOreSpawnSize), xdom.Br(),
683 xform.Label("Lapis Lazuli Ore Spawn Tries", "lapisLazuliOreSpawnTries"), lapisLazuliOreSpawnTries, rangeWatch(lapisLazuliOreSpawnTries), xdom.Br(),
684 xform.Label("Lapis Lazuli Ore Centre Height", "lapisLazuliOreCentreHeight"), lapisLazuliOreCentreHeight, rangeWatch(lapisLazuliOreCentreHeight), xdom.Br(),
685 xform.Label("Lapis Lazuli Ore Spread Height", "lapisLazuliOreSpreadHeight"), lapisLazuliOreSpreadHeight, rangeWatch(lapisLazuliOreSpreadHeight), xdom.Br(),
686 ),
687 ),
688 ),
689 xform.Label("Main Noise Scale X", "mainNoiseScaleX"), mainNoiseScaleX, rangeWatch(mainNoiseScaleX), xdom.Br(),
690 xform.Label("Main Noise Scale Y", "mainNoiseScaleY"), mainNoiseScaleY, rangeWatch(mainNoiseScaleY), xdom.Br(),
691 xform.Label("Main Noise Scale Z", "mainNoiseScaleZ"), mainNoiseScaleZ, rangeWatch(mainNoiseScaleZ), xdom.Br(),
692 xform.Label("Depth Noise Scale X", "depthNoiseScaleX"), depthNoiseScaleX, rangeWatch(depthNoiseScaleX), xdom.Br(),
693 xform.Label("Depth Noise Scale Z", "depthNoiseScaleZ"), depthNoiseScaleZ, rangeWatch(depthNoiseScaleZ), xdom.Br(),
694 xform.Label("Depth Noise Exponent", "depthNoiseExponent"), depthNoiseExponent, rangeWatch(depthNoiseExponent), xdom.Br(),
695 xform.Label("Depth Base Size", "depthBaseSize"), depthBaseSize, rangeWatch(depthBaseSize), xdom.Br(),
696 xform.Label("Coordinate Scale", "coordinateScale"), coordinateScale, rangeWatch(coordinateScale), xdom.Br(),
697 xform.Label("Height Scale", "heightScale"), heightScale, rangeWatch(heightScale), xdom.Br(),
698 xform.Label("Height Stretch", "heightStretch"), heightStretch, rangeWatch(heightStretch), xdom.Br(),
699 xform.Label("Upper Limit Scale", "upperLimitScale"), upperLimitScale, rangeWatch(upperLimitScale), xdom.Br(),
700 xform.Label("Lower Limit Scale", "lowerLimitScale"), lowerLimitScale, rangeWatch(lowerLimitScale), xdom.Br(),
701 xform.Label("Biome Depth Weight", "biomeDepthWeight"), biomeDepthWeight, rangeWatch(biomeDepthWeight), xdom.Br(),
702 xform.Label("Biome Depth Offset", "biomeDepthOffset"), biomeDepthOffset, rangeWatch(biomeDepthOffset), xdom.Br(),
703 xform.Label("Biome Scale Weight", "biomeDepthWeight"), biomeScaleWeight, rangeWatch(biomeScaleWeight), xdom.Br(),
704 xform.Label("Biome Scale Offset", "biomeDepthOffset"), biomeScaleOffset, rangeWatch(biomeScaleOffset), xdom.Br(),
705 submit,
706 )
707
708 return func(c dom.Element) {
709 c.AppendChild(d)
710 }
711 }
712
713 func mapGeneral(m data.Map) func(dom.Element) {
714 return func(c dom.Element) {
715 go func() {
716 servers, err := RPC.ServerList()
717 if err != nil {
718 c.AppendChild(xjs.SetInnerText(xdom.Div(), "Error getting server list: "+err.Error()))
719 return
720 }
721 name := xform.InputText("name", m.Name)
722 name.Required = true
723 opts := make([]xform.Option, 1, len(servers)+1)
724 opts[0] = xform.Option{
725 Label: "-- None --",
726 Value: "-1",
727 Selected: m.Server == -1,
728 }
729 var cs data.Server
730 for i, s := range servers {
731 n := s.Name
732 if s.Map != -1 {
733 if s.ID == m.Server {
734 cs = s
735 n = "* - " + n
736 } else {
737 n = "! - " + n
738 }
739 } else {
740 n = " " + n
741 }
742 opts = append(opts, xform.Option{
743 Label: n,
744 Value: strconv.Itoa(i),
745 Selected: s.ID == m.Server,
746 })
747 }
748 sel := xform.SelectBox("server", opts...)
749 submit := xform.InputSubmit("Set")
750 submit.AddEventListener("click", false, func(e dom.Event) {
751 if cs.State != data.StateStopped {
752 xjs.Alert("Cannot modify these settings while connected server is running.")
753 return
754 }
755 if name.Value == "" {
756 return
757 }
758 mID, err := strconv.Atoi(sel.Value)
759 if err != nil || mID < -1 || mID >= len(servers) {
760 return
761 }
762 submit.Disabled = true
763 e.PreventDefault()
764 if mID >= 0 {
765 s := servers[mID]
766 mID = s.ID
767 }
768 go func() {
769 err = RPC.SetServerMap(mID, m.ID)
770 if err != nil {
771 xjs.Alert("Error setting map server: %s", err)
772 return
773 }
774 m.Name = name.Value
775 err = RPC.SetMap(m)
776 if err != nil {
777 xjs.Alert("Error setting map data: %s", err)
778 return
779 }
780 span := xdom.Span()
781 span.Style().Set("color", "#f00")
782 c.AppendChild(xjs.SetInnerText(span, "Saved!"))
783 time.Sleep(5 * time.Second)
784 c.RemoveChild(span)
785 submit.Disabled = false
786 }()
787 })
788 xjs.AppendChildren(c, xjs.AppendChildren(xdom.Form(),
789 xform.Label("Server Name", "name"),
790 name,
791 xdom.Br(),
792 xform.Label("Server Name", "server"),
793 sel,
794 xdom.Br(),
795 submit,
796 ))
797 }()
798 }
799 }
800
801 func mapProperties(m data.Map) func(dom.Element) {
802 return func(c dom.Element) {
803 go editProperties(c, "Map", m.ID, RPC.MapProperties, RPC.SetMapProperties)
804 }
805 }