func (Lobby) LobbySpectatorJoin(server *wsevent.Server, so *wsevent.Client, data []byte) []byte {
reqerr := chelpers.FilterRequest(so, authority.AuthAction(0), true)
if reqerr != nil {
bytes, _ := json.Marshal(reqerr)
return bytes
}
var args struct {
Id *uint `json:"id"`
}
if err := chelpers.GetParams(data, &args); err != nil {
return helpers.NewTPErrorFromError(err).Encode()
}
var lob *models.Lobby
lob, tperr := models.GetLobbyById(*args.Id)
if tperr != nil {
return tperr.Encode()
}
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
return tperr.Encode()
}
var specSameLobby bool
arr, tperr := player.GetSpectatingIds()
if len(arr) != 0 {
for _, id := range arr {
if id == *args.Id {
specSameLobby = true
continue
}
lobby, _ := models.GetLobbyById(id)
lobby.RemoveSpectator(player, true)
server.RemoveClient(so.Id(), fmt.Sprintf("%d_public", id))
}
}
// If the player is already in the lobby (either joined a slot or is spectating), don't add them.
// Just Broadcast the lobby to them, so the frontend displays it.
if id, _ := player.GetLobbyId(); id != *args.Id && !specSameLobby {
tperr = lob.AddSpectator(player)
if tperr != nil {
return tperr.Encode()
}
chelpers.AfterLobbySpec(server, so, lob)
}
models.BroadcastLobbyToUser(lob, player.SteamId)
return chelpers.EmptySuccessJS
}
func (Lobby) LobbySpectatorJoin(so *wsevent.Client, args struct {
Id *uint `json:"id"`
}) interface{} {
var lob *models.Lobby
lob, tperr := models.GetLobbyByID(*args.Id)
if tperr != nil {
return tperr
}
player := chelpers.GetPlayerFromSocket(so.ID)
var specSameLobby bool
arr, tperr := player.GetSpectatingIds()
if len(arr) != 0 {
for _, id := range arr {
if id == *args.Id {
specSameLobby = true
continue
}
//a socket should only spectate one lobby, remove socket from
//any other lobby room
//multiple sockets from one player can spectatte multiple lobbies
socket.AuthServer.RemoveClient(so, fmt.Sprintf("%d_public", id))
}
}
// If the player is already in the lobby (either joined a slot or is spectating), don't add them.
// Just Broadcast the lobby to them, so the frontend displays it.
if id, _ := player.GetLobbyID(false); id != *args.Id && !specSameLobby {
tperr = lob.AddSpectator(player)
if tperr != nil {
return tperr
}
}
hooks.AfterLobbySpec(socket.AuthServer, so, lob)
models.BroadcastLobbyToUser(lob, player.SteamID)
return chelpers.EmptySuccessJS
}
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 LobbySpectatorJoin(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, lobbySpectatorJoinFilters,
func(params map[string]interface{}) string {
lobbyid := params["id"].(uint)
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
var lob *models.Lobby
lob, tperr = models.GetLobbyById(uint(lobbyid))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
if id, _ := player.GetLobbyId(); id != lobbyid {
helpers.LockRecord(lob.ID, lob)
tperr = lob.AddSpectator(player)
helpers.UnlockRecord(lob.ID, lob)
}
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
chelpers.AfterLobbySpec(so, lob)
models.BroadcastLobbyToUser(lob, player.SteamId)
return string(bytes)
})
}
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 AfterConnectLoggedIn(so socketio.Socket, player *models.Player) {
lobbyIdPlaying, err := player.GetLobbyId()
if err == nil {
lobby, _ := models.GetLobbyById(lobbyIdPlaying)
AfterLobbyJoin(so, lobby, player)
AfterLobbySpec(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 && !slot.InGame {
bytes, _ := models.DecorateLobbyConnectJSON(lobby).Encode()
broadcaster.SendMessage(player.SteamId, "lobbyStart", string(bytes))
} else if lobby.State == models.LobbyStateReadyingUp && !slot.Ready {
left := simplejson.New()
left.Set("timeout", lobby.ReadyUpTimeLeft())
bytes, _ := left.Encode()
broadcaster.SendMessage(player.SteamId, "lobbyReadyUp", string(bytes))
}
}
}
settings, err2 := player.GetSettings()
if err2 == nil {
json := models.DecoratePlayerSettingsJson(settings)
bytes, _ := json.Encode()
broadcaster.SendMessage(player.SteamId, "playerSettings", string(bytes))
}
profilePlayer, err3 := models.GetPlayerWithStats(player.SteamId)
if err3 == nil {
json := models.DecoratePlayerProfileJson(profilePlayer)
bytes, _ := json.Encode()
broadcaster.SendMessage(player.SteamId, "playerProfile", string(bytes))
}
}
func LobbyJoin(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, lobbyJoinFilters,
func(params map[string]interface{}) string {
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
lobbyid := params["id"].(uint)
classString := params["class"].(string)
teamString := params["team"].(string)
lob, tperr := models.GetLobbyById(uint(lobbyid))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
//Check if player is in the same lobby
var sameLobby bool
if id, err := player.GetLobbyId(); err == nil && id == lobbyid {
sameLobby = true
}
slot, tperr := models.LobbyGetPlayerSlot(lob.Type, teamString, classString)
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
helpers.LockRecord(lob.ID, lob)
defer helpers.UnlockRecord(lob.ID, lob)
tperr = lob.AddPlayer(player, slot)
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
if !sameLobby {
chelpers.AfterLobbyJoin(so, lob, player)
}
if lob.IsFull() {
lob.State = models.LobbyStateReadyingUp
lob.Save()
lob.ReadyUpTimeoutCheck()
room := fmt.Sprintf("%s_private",
chelpers.GetLobbyRoom(lob.ID))
broadcaster.SendMessageToRoom(room, "lobbyReadyUp",
`{"timeout":30}`)
models.BroadcastLobbyList()
}
models.BroadcastLobbyToUser(lob, player.SteamId)
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
})
}