func InsertOnlineMenu(ui gui.WidgetParent) error {
var sm OnlineMenu
datadir := base.GetDataDir()
err := base.LoadAndProcessObject(filepath.Join(datadir, "ui", "start", "online", "layout.json"), "json", &sm.layout)
if err != nil {
return err
}
sm.buttons = []ButtonLike{
&sm.layout.Back,
&sm.layout.Unstarted.Up,
&sm.layout.Unstarted.Down,
&sm.layout.Active.Up,
&sm.layout.Active.Down,
&sm.layout.User,
&sm.layout.NewGame,
}
sm.control.in = make(chan struct{})
sm.control.out = make(chan struct{})
sm.layout.Back.f = func(interface{}) {
ui.RemoveChild(&sm)
InsertStartMenu(ui)
}
sm.ui = ui
fmt.Sscanf(base.GetStoreVal("netid"), "%d", &net_id)
if net_id == 0 {
net_id = mrgnet.NetId(mrgnet.RandomId())
base.SetStoreVal("netid", fmt.Sprintf("%d", net_id))
}
in_newgame := false
sm.layout.NewGame.f = func(interface{}) {
if in_newgame {
return
}
in_newgame = true
go func() {
var req mrgnet.NewGameRequest
req.Id = net_id
var resp mrgnet.NewGameResponse
done := make(chan bool, 1)
go func() {
mrgnet.DoAction("new", req, &resp)
done <- true
}()
select {
case <-done:
case <-time.After(5 * time.Second):
resp.Err = "Couldn't connect to server."
}
<-sm.control.in
defer func() {
in_newgame = false
sm.control.out <- struct{}{}
}()
if resp.Err != "" {
sm.layout.Error.err = resp.Err
base.Error().Printf("Couldn't make new game: %v", resp.Err)
return
}
ui.RemoveChild(&sm)
err := InsertMapChooser(
ui,
func(name string) {
ui.AddChild(MakeGamePanel(name, nil, nil, resp.Game_key))
},
InsertOnlineMenu,
)
if err != nil {
base.Error().Printf("Error making Map Chooser: %v", err)
}
}()
}
for _, _glb := range []*gameListBox{&sm.layout.Active, &sm.layout.Unstarted} {
glb := _glb
glb.Up.f = func(interface{}) {
glb.Scroll.Up()
}
glb.Up.valid_func = func() bool {
return glb.Scroll.Height > glb.Scroll.Dy
}
glb.Down.f = func(interface{}) {
glb.Scroll.Down()
}
glb.Down.valid_func = func() bool {
return glb.Scroll.Height > glb.Scroll.Dy
}
glb.update = make(chan mrgnet.ListGamesResponse)
}
go func() {
var resp mrgnet.ListGamesResponse
mrgnet.DoAction("list", mrgnet.ListGamesRequest{Id: net_id, Unstarted: true}, &resp)
sm.layout.Unstarted.update <- resp
}()
go func() {
var resp mrgnet.ListGamesResponse
mrgnet.DoAction("list", mrgnet.ListGamesRequest{Id: net_id, Unstarted: false}, &resp)
sm.layout.Active.update <- resp
}()
sm.layout.User.Button.f = func(interface{}) {
var req mrgnet.UpdateUserRequest
req.Name = sm.layout.User.Entry.text
req.Id = net_id
var resp mrgnet.UpdateUserResponse
go func() {
mrgnet.DoAction("user", req, &resp)
<-sm.control.in
sm.layout.User.SetText(resp.Name)
sm.update_alpha = 1.0
sm.update_time = time.Now()
sm.control.out <- struct{}{}
}()
}
go func() {
var resp mrgnet.UpdateUserResponse
mrgnet.DoAction("user", mrgnet.UpdateUserRequest{Id: net_id}, &resp)
<-sm.control.in
sm.layout.User.SetText(resp.Name)
sm.update_alpha = 1.0
sm.update_time = time.Now()
sm.control.out <- struct{}{}
}()
ui.AddChild(&sm)
return nil
}
func main() {
defer func() {
if r := recover(); r != nil {
data := debug.Stack()
base.Error().Printf("PANIC: %v\n", r)
base.Error().Printf("PANIC: %s\n", string(data))
base.CloseLog()
fmt.Printf("PANIC: %s\n", string(data))
}
}()
base.Log().Printf("Version %s", Version())
sys.Startup()
sound.Init()
render.Init()
render.Queue(func() {
sys.CreateWindow(10, 10, wdx, wdy)
sys.EnableVSync(true)
err := gl.Init()
if err != nil {
panic(err)
}
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
})
base.InitShaders()
runtime.GOMAXPROCS(8)
ui, err := gui.Make(gin.In(), gui.Dims{wdx, wdy}, filepath.Join(datadir, "fonts", "skia.ttf"))
if err != nil {
panic(err.Error())
}
loadAllRegistries()
// TODO: Might want to be able to reload stuff, but this is sensitive because it
// is loading textures. We should probably redo the sprite system so that this
// is easier to safely handle.
game.LoadAllEntities()
// Set up editors
editors = map[string]house.Editor{
"room": house.MakeRoomEditorPanel(),
"house": house.MakeHouseEditorPanel(),
}
for name, editor := range editors {
path := base.GetStoreVal(fmt.Sprintf("last %s path", name))
path = filepath.Join(datadir, path)
if path != "" {
editor.Load(path)
}
}
editor_name = "room"
editor = editors[editor_name]
edit_mode := false
game.Restart = func() {
base.Log().Printf("Restarting...")
ui.RemoveChild(game_box)
game_box = &lowerLeftTable{gui.MakeAnchorBox(gui.Dims{1024, 768})}
err = game.InsertStartMenu(game_box)
if err != nil {
panic(err)
}
ui.AddChild(game_box)
base.Log().Printf("Restarted")
}
game.Restart()
if base.IsDevel() {
ui.AddChild(base.MakeConsole())
}
sys.Think()
// Wait until now to create the dictionary because the render thread needs
// to be running in advance.
render.Queue(func() {
ui.Draw()
})
render.Purge()
var profile_output *os.File
heap_prof_count := 0
for key_map["quit"].FramePressCount() == 0 {
sys.Think()
render.Queue(func() {
sys.SwapBuffers()
ui.Draw()
})
render.Purge()
for _, child := range game_box.GetChildren() {
if gp, ok := child.(*game.GamePanel); ok {
game_panel = gp
}
}
if base.IsDevel() {
if key_map["cpu profile"].FramePressCount() > 0 {
if profile_output == nil {
profile_output, err = os.Create(filepath.Join(datadir, "cpu.prof"))
if err == nil {
err = pprof.StartCPUProfile(profile_output)
if err != nil {
base.Log().Printf("Unable to start CPU profile: %v\n", err)
profile_output.Close()
profile_output = nil
}
base.Log().Printf("profout: %v\n", profile_output)
} else {
base.Log().Printf("Unable to start CPU profile: %v\n", err)
}
} else {
pprof.StopCPUProfile()
profile_output.Close()
profile_output = nil
}
}
if key_map["heap profile"].FramePressCount() > 0 {
out, err := os.Create(filepath.Join(datadir, fmt.Sprintf("heap-%d.prof", heap_prof_count)))
heap_prof_count++
if err == nil {
err = pprof.WriteHeapProfile(out)
out.Close()
if err != nil {
base.Warn().Printf("Unable to write heap profile: %v", err)
}
} else {
base.Warn().Printf("Unable to create heap profile: %v", err)
}
}
if key_map["manual mem"].FramePressCount() > 0 {
base.Log().Printf(memory.TotalAllocations())
}
if key_map["game mode"].FramePressCount()%2 == 1 {
base.Log().Printf("Game mode change: %t", edit_mode)
if edit_mode {
ui.RemoveChild(editor)
ui.AddChild(game_box)
} else {
ui.RemoveChild(game_box)
ui.AddChild(editor)
}
edit_mode = !edit_mode
if key_map["row up"].FramePressCount() > 0 {
house.Num_rows += 25
}
if key_map["row down"].FramePressCount() > 0 {
house.Num_rows -= 25
}
if key_map["steps up"].FramePressCount() > 0 {
house.Num_steps++
}
if key_map["steps down"].FramePressCount() > 0 {
house.Num_steps--
}
if key_map["noise up"].FramePressCount() > 0 {
house.Noise_rate += 10
}
if key_map["noise down"].FramePressCount() > 0 {
house.Noise_rate -= 10
}
if key_map["foo"].FramePressCount() > 0 {
house.Foo = (house.Foo + 1) % 2
}
}
if edit_mode {
editMode()
} else {
gameMode()
}
}
// Draw a cursor at the cursor - for testing an osx bug in glop.
// zx, zy := gin.In().GetCursor("Mouse").Point()
// render.Queue(func() {
// gl.Color4ub(255, 0, 0, 255)
// gl.Begin(gl.LINES)
// {
// gl.Vertex2i(int32(zx-25), int32(zy))
// gl.Vertex2i(int32(zx+25), int32(zy))
// gl.Vertex2i(int32(zx), int32(zy-25))
// gl.Vertex2i(int32(zx), int32(zy+25))
// }
// gl.End()
// })
}
}
func (sm *OnlineMenu) Think(g *gui.Gui, t int64) {
if sm.last_t == 0 {
sm.last_t = t
return
}
dt := t - sm.last_t
sm.last_t = t
if sm.mx == 0 && sm.my == 0 {
sm.mx, sm.my = gin.In().GetCursor("Mouse").Point()
}
done := false
for !done {
select {
case sm.control.in <- struct{}{}:
<-sm.control.out
default:
done = true
}
}
var net_id mrgnet.NetId
fmt.Sscanf(base.GetStoreVal("netid"), "%d", &net_id)
for i := range []*gameListBox{&sm.layout.Active, &sm.layout.Unstarted} {
glb := []*gameListBox{&sm.layout.Active, &sm.layout.Unstarted}[i]
select {
case list := <-glb.update:
glb.games = glb.games[0:0]
for j := range list.Games {
var b Button
var name string
base.Log().Printf("Adding button: %s", list.Games[j].Name)
b.Text.Justification = sm.layout.Text.Justification
b.Text.Size = sm.layout.Text.Size
if net_id == list.Games[j].Denizens_id {
name = list.Games[j].Name
} else {
name = list.Games[j].Name
}
b.Text.String = "Join!"
game_key := list.Game_keys[j]
active := (glb == &sm.layout.Active)
in_joingame := false
b.f = func(interface{}) {
if in_joingame {
return
}
in_joingame = true
if active {
go func() {
var req mrgnet.StatusRequest
req.Id = net_id
req.Game_key = game_key
var resp mrgnet.StatusResponse
done := make(chan bool, 1)
go func() {
mrgnet.DoAction("status", req, &resp)
done <- true
}()
select {
case <-done:
case <-time.After(5 * time.Second):
resp.Err = "Couldn't connect to server."
}
<-sm.control.in
defer func() {
in_joingame = false
sm.control.out <- struct{}{}
}()
if resp.Err != "" || resp.Game == nil {
sm.layout.Error.err = resp.Err
base.Error().Printf("Couldn't join game: %v", resp.Err)
return
}
sm.ui.RemoveChild(sm)
sm.ui.AddChild(MakeGamePanel("", nil, nil, game_key))
}()
} else {
go func() {
var req mrgnet.JoinGameRequest
req.Id = net_id
req.Game_key = game_key
var resp mrgnet.JoinGameResponse
done := make(chan bool, 1)
go func() {
mrgnet.DoAction("join", req, &resp)
done <- true
}()
select {
case <-done:
case <-time.After(5 * time.Second):
resp.Err = "Couldn't connect to server."
}
<-sm.control.in
defer func() {
in_joingame = false
sm.control.out <- struct{}{}
}()
if resp.Err != "" || !resp.Successful {
sm.layout.Error.err = resp.Err
base.Error().Printf("Couldn't join game: %v", resp.Err)
return
}
sm.ui.RemoveChild(sm)
sm.ui.AddChild(MakeGamePanel("", nil, nil, game_key))
}()
}
}
if active {
d := Button{}
d.Text.String = "Delete!"
d.Text.Justification = "right"
d.Text.Size = sm.layout.Text.Size
d.f = func(interface{}) {
go func() {
var req mrgnet.KillRequest
req.Id = net_id
req.Game_key = game_key
var resp mrgnet.KillResponse
done := make(chan bool, 1)
go func() {
mrgnet.DoAction("kill", req, &resp)
done <- true
}()
select {
case <-done:
case <-time.After(5 * time.Second):
resp.Err = "Couldn't connect to server."
}
<-sm.control.in
if resp.Err != "" {
sm.layout.Error.err = resp.Err
base.Error().Printf("Couldn't kill game: %v", resp.Err)
} else {
algorithm.Choose(&glb.games, func(gf gameField) bool {
return gf.key != req.Game_key
})
}
sm.control.out <- struct{}{}
}()
}
glb.games = append(glb.games, gameField{&b, &d, name, list.Game_keys[j], list.Games[j]})
} else {
glb.games = append(glb.games, gameField{&b, nil, name, list.Game_keys[j], list.Games[j]})
}
}
glb.Scroll.Height = int(base.GetDictionary(sm.layout.Text.Size).MaxHeight() * float64(len(list.Games)))
default:
}
sm.hover_game = nil
if (gui.Point{sm.mx, sm.my}.Inside(glb.Scroll.Region())) {
for i := range glb.games {
game := &glb.games[i]
var region gui.Region
region.X = game.join.(*Button).bounds.x
region.Y = game.join.(*Button).bounds.y
region.Dx = glb.Scroll.Dx
region.Dy = int(base.GetDictionary(sm.layout.Text.Size).MaxHeight())
if (gui.Point{sm.mx, sm.my}.Inside(region)) {
sm.hover_game = game
}
game.join.Think(sm.region.X, sm.region.Y, sm.mx, sm.my, dt)
if game.delete != nil {
game.delete.Think(sm.region.X, sm.region.Y, sm.mx, sm.my, dt)
}
}
} else {
for _, game := range glb.games {
game.join.Think(sm.region.X, sm.region.Y, 0, 0, dt)
if game.delete != nil {
game.delete.Think(sm.region.X, sm.region.Y, 0, 0, dt)
}
}
}
glb.Scroll.Think(dt)
}
if sm.update_alpha > 0.0 && time.Now().Sub(sm.update_time).Seconds() >= 2 {
sm.update_alpha = doApproach(sm.update_alpha, 0.0, dt)
}
for _, button := range sm.buttons {
button.Think(sm.region.X, sm.region.Y, sm.mx, sm.my, dt)
}
}