//Not really broadcast, since it sends each client a different LobbyStart JSON func BroadcastLobbyStart(lobby *models.Lobby) { var slots []*models.LobbySlot db.DB.Table("lobby_slots").Where("lobby_id = ?", lobby.ID).Find(&slots) for _, slot := range slots { var player models.Player db.DB.First(&player, slot.PlayerID) connectInfo := models.DecorateLobbyConnect(lobby, player.Name, slot.Slot) broadcaster.SendMessage(player.SteamID, "lobbyStart", connectInfo) } }
//Not really broadcast, since it sends each client a different LobbyStart JSON func BroadcastLobbyStart(lobby *models.Lobby) { var slots []*models.LobbySlot db.DB.Table("lobby_slots").Where("lobby_id = ?", lobby.ID).Find(&slots) for _, slot := range slots { var player models.Player db.DB.First(&player, slot.PlayerId) bytes, _ := json.Marshal(models.DecorateLobbyConnect(lobby, player.Name, slot.Class)) broadcaster.SendMessage(player.SteamId, "lobbyStart", string(bytes)) } }
func AfterConnectLoggedIn(so *wsevent.Client, player *models.Player) { if time.Since(player.UpdatedAt) >= time.Hour*1 { player.UpdatePlayerInfo() player.Save() } lobbyID, err := player.GetLobbyID(false) if err == nil { lobby, _ := models.GetLobbyByIDServer(lobbyID) AfterLobbyJoin(so, lobby, player) AfterLobbySpec(socket.AuthServer, so, lobby) models.BroadcastLobbyToUser(lobby, chelpers.GetSteamId(so.ID)) slot := &models.LobbySlot{} err := db.DB.Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).First(slot).Error if err == nil { if lobby.State == models.LobbyStateInProgress { broadcaster.SendMessage(player.SteamID, "lobbyStart", models.DecorateLobbyConnect(lobby, player.Name, slot.Slot)) } else if lobby.State == models.LobbyStateReadyingUp && !slot.Ready { data := struct { Timeout int64 `json:"timeout"` }{lobby.ReadyUpTimeLeft()} broadcaster.SendMessage(player.SteamID, "lobbyReadyUp", data) } } } settings, err2 := player.GetSettings() if err2 == nil { broadcaster.SendMessage(player.SteamID, "playerSettings", models.DecoratePlayerSettingsJson(settings)) } profilePlayer, err3 := models.GetPlayerWithStats(player.SteamID) if err3 == nil { broadcaster.SendMessage(player.SteamID, "playerProfile", models.DecoratePlayerProfileJson(profilePlayer)) } }
func AfterConnectLoggedIn(server *wsevent.Server, so *wsevent.Client, player *models.Player) { lobbyIdPlaying, err := player.GetLobbyId() if err == nil { lobby, _ := models.GetLobbyByIdServer(lobbyIdPlaying) AfterLobbyJoin(server, so, lobby, player) AfterLobbySpec(server, so, lobby) models.BroadcastLobbyToUser(lobby, GetSteamId(so.Id())) slot := &models.LobbySlot{} err := db.DB.Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).First(slot).Error if err == nil { if lobby.State == models.LobbyStateInProgress && !models.IsPlayerInServer(player.SteamId) { bytes, _ := json.Marshal(models.DecorateLobbyConnect(lobby, player.Name, slot.Class)) broadcaster.SendMessage(player.SteamId, "lobbyStart", string(bytes)) } else if lobby.State == models.LobbyStateReadyingUp && !slot.Ready { data := struct { Timeout int64 `json:"timeout"` }{lobby.ReadyUpTimeLeft()} bytes, _ := json.Marshal(data) broadcaster.SendMessage(player.SteamId, "lobbyReadyUp", string(bytes)) } } } settings, err2 := player.GetSettings() if err2 == nil { bytes, _ := json.Marshal(models.DecoratePlayerSettingsJson(settings)) broadcaster.SendMessage(player.SteamId, "playerSettings", string(bytes)) } profilePlayer, err3 := models.GetPlayerWithStats(player.SteamId) if err3 == nil { bytes, _ := json.Marshal(models.DecoratePlayerProfileJson(profilePlayer)) broadcaster.SendMessage(player.SteamId, "playerProfile", string(bytes)) } }
func (Lobby) LobbyJoin(server *wsevent.Server, so *wsevent.Client, data []byte) []byte { reqerr := chelpers.FilterRequest(so, authority.AuthAction(0), true) if reqerr != nil { return reqerr.Encode() } var args struct { Id *uint `json:"id"` Class *string `json:"class"` Team *string `json:"team" valid:"red,blu"` } if err := chelpers.GetParams(data, &args); err != nil { return helpers.NewTPErrorFromError(err).Encode() } //helpers.Logger.Debug("id %d class %s team %s", *args.Id, *args.Class, *args.Team) player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { return tperr.Encode() } lob, tperr := models.GetLobbyById(*args.Id) if tperr != nil { return tperr.Encode() } if lob.State == models.LobbyStateEnded { return helpers.NewTPError("Cannot join a closed lobby.", -1).Encode() } //Check if player is in the same lobby var sameLobby bool if id, err := player.GetLobbyId(); err == nil && id == *args.Id { sameLobby = true } slot, tperr := models.LobbyGetPlayerSlot(lob.Type, *args.Team, *args.Class) if tperr != nil { return tperr.Encode() } if prevId, err := player.GetLobbyId(); err != nil { server.RemoveClient(so.Id(), fmt.Sprintf("%d_public", prevId)) server.RemoveClient(so.Id(), fmt.Sprintf("%d_private", prevId)) } tperr = lob.AddPlayer(player, slot, *args.Team, *args.Class) if tperr != nil { return tperr.Encode() } if !sameLobby { chelpers.AfterLobbyJoin(server, so, lob, player) } if lob.IsFull() { lob.State = models.LobbyStateReadyingUp lob.ReadyUpTimestamp = time.Now().Unix() + 30 lob.Save() tick := time.After(time.Second * 30) id := lob.ID stop := make(chan struct{}) go func() { select { case <-tick: lobby := &models.Lobby{} db.DB.First(lobby, id) if lobby.State != models.LobbyStateInProgress { err := lobby.RemoveUnreadyPlayers() if err != nil { helpers.Logger.Error("RemoveUnreadyPlayers: ", err.Error()) err = nil } err = lobby.UnreadyAllPlayers() if err != nil { helpers.Logger.Error("UnreadyAllPlayers: ", err.Error()) } lobby.State = models.LobbyStateWaiting lobby.Save() } case <-stop: return } }() room := fmt.Sprintf("%s_private", chelpers.GetLobbyRoom(lob.ID)) broadcaster.SendMessageToRoom(room, "lobbyReadyUp", `{"timeout":30}`) models.BroadcastLobbyList() } err := models.AllowPlayer(*args.Id, player.SteamId, *args.Team+*args.Class) if err != nil { helpers.Logger.Error(err.Error()) } if lob.State == models.LobbyStateInProgress { bytes, _ := json.Marshal(models.DecorateLobbyConnect(lob, player.Name, *args.Class)) broadcaster.SendMessage(player.SteamId, "lobbyStart", string(bytes)) } return chelpers.EmptySuccessJS }
func (Lobby) LobbyJoin(so *wsevent.Client, args struct { Id *uint `json:"id"` Class *string `json:"class"` Team *string `json:"team" valid:"red,blu"` Password *string `json:"password" empty:"-"` }) interface{} { player := chelpers.GetPlayerFromSocket(so.ID) if banned, until := player.IsBannedWithTime(models.PlayerBanJoin); banned { str := fmt.Sprintf("You have been banned from joining lobbies till %s", until.Format(time.RFC822)) return helpers.NewTPError(str, -1) } //logrus.Debug("id %d class %s team %s", *args.Id, *args.Class, *args.Team) lob, tperr := models.GetLobbyByID(*args.Id) if tperr != nil { return tperr } if lob.State == models.LobbyStateEnded { return helpers.NewTPError("Cannot join a closed lobby.", -1) } //Check if player is in the same lobby var sameLobby bool if id, err := player.GetLobbyID(false); err == nil && id == *args.Id { sameLobby = true } slot, tperr := models.LobbyGetPlayerSlot(lob.Type, *args.Team, *args.Class) if tperr != nil { return tperr } if prevId, _ := player.GetLobbyID(false); prevId != 0 && !sameLobby { lobby, _ := models.GetLobbyByID(prevId) hooks.AfterLobbyLeave(lobby, player) } tperr = lob.AddPlayer(player, slot, *args.Password) if tperr != nil { return tperr } if !sameLobby { hooks.AfterLobbyJoin(so, lob, player) } //check if lobby isn't already in progress (which happens when the player is subbing) if lob.IsFull() && lob.State != models.LobbyStateInProgress { lob.State = models.LobbyStateReadyingUp lob.ReadyUpTimestamp = time.Now().Unix() + 30 lob.Save() time.AfterFunc(time.Second*30, func() { lobby := &models.Lobby{} db.DB.First(lobby, lob.ID) //if all player's haven't readied up, //remove unreadied players and unready the //rest. if lobby.State != models.LobbyStateInProgress && lobby.State != models.LobbyStateEnded { removeUnreadyPlayers(lobby) lobby.State = models.LobbyStateWaiting lobby.Save() } }) room := fmt.Sprintf("%s_private", hooks.GetLobbyRoom(lob.ID)) broadcaster.SendMessageToRoom(room, "lobbyReadyUp", struct { Timeout int `json:"timeout"` }{30}) models.BroadcastLobbyList() } if lob.State == models.LobbyStateInProgress { //this happens when the player is a substitute db.DB.Preload("ServerInfo").First(lob, lob.ID) so.EmitJSON(helpers.NewRequest("lobbyStart", models.DecorateLobbyConnect(lob, player.Name, slot))) } return chelpers.EmptySuccessJS }