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,
)
}()
}
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 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 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 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
}
}
}
}