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 onDisconnect(id string) { //defer helpers.Logger.Debug("Disconnected from Socket") defer chelpers.DeauthenticateSocket(id) if chelpers.IsLoggedInSocket(id) { steamid := chelpers.GetSteamId(id) broadcaster.RemoveSocket(steamid) player, tperr := models.GetPlayerBySteamId(steamid) if tperr != nil || player == nil { helpers.Logger.Error(tperr.Error()) return } ids, tperr := player.GetSpectatingIds() if tperr != nil { helpers.Logger.Error(tperr.Error()) return } for _, id := range ids { lobby, _ := models.GetLobbyById(id) err := lobby.RemoveSpectator(player, true) if err != nil { helpers.Logger.Error(err.Error()) continue } //helpers.Logger.Debug("removing %s from %d", player.SteamId, id) } } }
func removePlayerFromLobby(lobbyId uint, steamId string) (*models.Lobby, *models.Player, *helpers.TPError) { player, tperr := models.GetPlayerBySteamId(steamId) if tperr != nil { return nil, nil, tperr } lob, tperr := models.GetLobbyById(lobbyId) if tperr != nil { return nil, nil, tperr } switch lob.State { case models.LobbyStateInProgress: return lob, player, helpers.NewTPError("Lobby is in progress.", 1) case models.LobbyStateEnded: return lob, player, helpers.NewTPError("Lobby has closed.", 1) } _, err := lob.GetPlayerSlot(player) if err != nil { return lob, player, helpers.NewTPError("Player not playing", 2) } if err := lob.RemovePlayer(player); err != nil { return lob, player, err } return lob, player, lob.AddSpectator(player) }
func (Player) PlayerSettingsSet(server *wsevent.Server, so *wsevent.Client, data []byte) []byte { reqerr := chelpers.FilterRequest(so, 0, true) if reqerr != nil { return reqerr.Encode() } var args struct { Key string `json:"key"` Value string `json:"value"` } err := chelpers.GetParams(data, &args) if err != nil { return helpers.NewTPErrorFromError(err).Encode() } player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) err = player.SetSetting(args.Key, args.Value) if err != nil { return helpers.NewTPErrorFromError(err).Encode() } return chelpers.EmptySuccessJS }
func SocketInit(server *wsevent.Server, noauth *wsevent.Server, so *wsevent.Client) error { chelpers.AuthenticateSocket(so.Id(), so.Request()) loggedIn := chelpers.IsLoggedInSocket(so.Id()) if loggedIn { steamid := chelpers.GetSteamId(so.Id()) broadcaster.SetSocket(steamid, so) } if loggedIn { chelpers.AfterConnect(server, so) player, err := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if err != nil { helpers.Logger.Warning( "User has a cookie with but a matching player record doesn't exist: %s", chelpers.GetSteamId(so.Id())) chelpers.DeauthenticateSocket(so.Id()) so.Close() return ErrRecordNotFound } chelpers.AfterConnectLoggedIn(server, so, player) } else { chelpers.AfterConnect(noauth, so) so.EmitJSON(helpers.NewRequest("playerSettings", "{}")) so.EmitJSON(helpers.NewRequest("playerProfile", "{}")) } so.EmitJSON(helpers.NewRequest("socketInitialized", "{}")) return nil }
func LobbyClose(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, lobbyCloseFilters, func(params map[string]interface{}) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) lobbyid := params["id"].(uint) lob, tperr := models.GetLobbyById(uint(lobbyid)) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if player.SteamId != lob.CreatedBySteamID && player.Role != helpers.RoleAdmin { bytes, _ := chelpers.BuildFailureJSON("Player not authorized to close lobby.", 1).Encode() return string(bytes) } if lob.State == models.LobbyStateEnded { bytes, _ := chelpers.BuildFailureJSON("Lobby already closed.", -1).Encode() return string(bytes) } helpers.LockRecord(lob.ID, lob) lob.Close(true) helpers.UnlockRecord(lob.ID, lob) chelpers.StopLogger(lobbyid) models.BroadcastLobbyList() // has to be done manually for now bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) }) }
func (Player) PlayerSettingsGet(server *wsevent.Server, so *wsevent.Client, data []byte) []byte { reqerr := chelpers.FilterRequest(so, 0, true) if reqerr != nil { return reqerr.Encode() } var args struct { Key string `json:"key"` } err := chelpers.GetParams(data, &args) if err != nil { return helpers.NewTPErrorFromError(err).Encode() } player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) var settings []models.PlayerSetting var setting models.PlayerSetting if args.Key == "*" { settings, err = player.GetSettings() } else { setting, err = player.GetSetting(args.Key) settings = append(settings, setting) } if err != nil { return helpers.NewTPErrorFromError(err).Encode() } result := models.DecoratePlayerSettingsJson(settings) resp, _ := chelpers.BuildSuccessJSON(result).Encode() return resp }
func PlayerSettingsGet(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, playerSettingsGetFilter, func(params map[string]interface{}) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) key := params["key"].(string) var err error var settings []models.PlayerSetting var setting models.PlayerSetting if key == "" { settings, err = player.GetSettings() } else { setting, err = player.GetSetting(key) settings = append(settings, setting) } if err != nil { bytes, _ := chelpers.BuildFailureJSON(err.Error(), 0).Encode() return string(bytes) } result := models.DecoratePlayerSettingsJson(settings) resp, _ := chelpers.BuildSuccessJSON(result).Encode() return string(resp) }) }
func (Chat) ChatSend(server *wsevent.Server, so *wsevent.Client, data []byte) []byte { reqerr := chelpers.FilterRequest(so, 0, true) if reqerr != nil { return reqerr.Encode() } var args struct { Message *string `json:"message"` Room *int `json:"room"` } err := chelpers.GetParams(data, &args) if err != nil { return helpers.NewTPErrorFromError(err).Encode() } player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { return tperr.Encode() } //helpers.Logger.Debug("received chat message: %s %s", *args.Message, player.Name) if *args.Room > 0 { spec := player.IsSpectatingId(uint(*args.Room)) //Check if player has either joined, or is spectating lobby lobbyId, tperr := player.GetLobbyId() if tperr != nil && !spec && lobbyId != uint(*args.Room) { return helpers.NewTPError("Player is not in the lobby.", 5).Encode() } } else { // else room is the lobby list room *args.Room, _ = strconv.Atoi(config.Constants.GlobalChatRoom) } if (*args.Message)[0] == '\n' { return helpers.NewTPError("Cannot send messages prefixed with newline", 4).Encode() } if len(*args.Message) > 120 { return helpers.NewTPError("Message too long", 4).Encode() } message := models.NewChatMessage(*args.Message, *args.Room, player) db.DB.Save(message) bytes, _ := json.Marshal(message) broadcaster.SendMessageToRoom(fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(uint(*args.Room))), "chatReceive", string(bytes)) if strings.HasPrefix(*args.Message, "!admin") { chelpers.SendToSlack(*args.Message, player.Name, player.SteamId) } return chelpers.EmptySuccessJS }
func LobbyCreate(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, lobbyCreateFilters, func(params map[string]interface{}) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) mapName := params["mapName"].(string) lobbytypestring := params["type"].(string) league := params["league"].(string) server := params["server"].(string) rconPwd := params["rconpwd"].(string) whitelist := int(params["whitelist"].(uint)) mumble := params["mumbleRequired"].(bool) var playermap = map[string]models.LobbyType{ "debug": models.LobbyTypeDebug, "sixes": models.LobbyTypeSixes, "highlander": models.LobbyTypeHighlander, } lobbytype, _ := playermap[lobbytypestring] randBytes := make([]byte, 6) rand.Read(randBytes) serverPwd := base64.URLEncoding.EncodeToString(randBytes) //TODO what if playermap[lobbytype] is nil? info := models.ServerRecord{ Host: server, RconPassword: rconPwd, ServerPassword: serverPwd} err := models.VerifyInfo(info) if err != nil { return err.Error() } lob := models.NewLobby(mapName, lobbytype, league, info, whitelist, mumble) lob.CreatedBySteamID = player.SteamId lob.Save() err = lob.SetupServer() if err != nil { bytes, _ := err.(*helpers.TPError).ErrorJSON().Encode() return string(bytes) } lob.State = models.LobbyStateWaiting lob.Save() lobby_id := simplejson.New() lobby_id.Set("id", lob.ID) bytes, _ := chelpers.BuildSuccessJSON(lobby_id).Encode() return string(bytes) }) }
func TestPlayerBanning(t *testing.T) { testhelpers.CleanupDB() player, _ := models.NewPlayer("76561197999073985") player.Save() assert.False(t, player.IsBanned(models.PlayerBanJoin)) assert.False(t, player.IsBanned(models.PlayerBanCreate)) assert.False(t, player.IsBanned(models.PlayerBanChat)) assert.False(t, player.IsBanned(models.PlayerBanFull)) past := time.Now().Add(time.Second * -10) player.BanUntil(past, models.PlayerBanJoin, "they suck") assert.False(t, player.IsBanned(models.PlayerBanJoin)) future := time.Now().Add(time.Second * 10) player.BanUntil(future, models.PlayerBanJoin, "they suck") player.BanUntil(future, models.PlayerBanFull, "they suck") player2, _ := models.GetPlayerBySteamId(player.SteamId) assert.False(t, player2.IsBanned(models.PlayerBanCreate)) assert.False(t, player2.IsBanned(models.PlayerBanChat)) isBannedFull, untilFull := player2.IsBannedWithTime(models.PlayerBanFull) assert.True(t, isBannedFull) assert.True(t, future.Sub(untilFull) < time.Second) assert.True(t, untilFull.Sub(future) < time.Second) log.Println(future.Sub(untilFull)) isBannedJoin, untilJoin := player2.IsBannedWithTime(models.PlayerBanJoin) assert.True(t, isBannedJoin) assert.True(t, future.Sub(untilJoin) < time.Second) assert.True(t, untilJoin.Sub(future) < time.Second) future2 := time.Now().Add(time.Second * 20) player2.BanUntil(future2, models.PlayerBanJoin, "they suck") isBannedJoin2, untilJoin2 := player2.IsBannedWithTime(models.PlayerBanJoin) assert.True(t, isBannedJoin2) assert.True(t, future2.Sub(untilJoin2) < time.Second) assert.True(t, untilJoin.Sub(future2) < time.Second) bans, err := player2.GetActiveBans() assert.Nil(t, err) assert.Equal(t, 3, len(bans)) player2.Unban(models.PlayerBanJoin) player2.Unban(models.PlayerBanFull) assert.False(t, player2.IsBanned(models.PlayerBanJoin)) assert.False(t, player2.IsBanned(models.PlayerBanCreate)) assert.False(t, player2.IsBanned(models.PlayerBanChat)) assert.False(t, player2.IsBanned(models.PlayerBanFull)) }
func PlayerReady(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, playerReadyFilter, func(_ map[string]interface{}) string { steamid := chelpers.GetSteamId(so.Id()) player, tperr := models.GetPlayerBySteamId(steamid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobbyid, tperr := player.GetLobbyId() if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobby, tperr := models.GetLobbyById(lobbyid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if lobby.State != models.LobbyStateReadyingUp { bytes, _ := helpers.NewTPError("Lobby hasn't been filled up yet.", 4).ErrorJSON().Encode() return string(bytes) } helpers.LockRecord(lobby.ID, lobby) tperr = lobby.ReadyPlayer(player) defer helpers.UnlockRecord(lobby.ID, lobby) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if lobby.IsEveryoneReady() { lobby.State = models.LobbyStateInProgress lobby.Save() bytes, _ := models.DecorateLobbyConnectJSON(lobby).Encode() room := fmt.Sprintf("%s_private", chelpers.GetLobbyRoom(lobby.ID)) broadcaster.SendMessageToRoom(room, "lobbyStart", string(bytes)) models.BroadcastLobbyList() } bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) }) }
func playerCanKick(lobbyId uint, steamId string) (bool, *helpers.TPError) { lob, tperr := models.GetLobbyById(lobbyId) if tperr != nil { return false, tperr } player, tperr2 := models.GetPlayerBySteamId(steamId) if tperr2 != nil { return false, tperr2 } if steamId != lob.CreatedBySteamID && player.Role != helpers.RoleAdmin { return false, helpers.NewTPError("Not authorized to kick players", 1) } return true, nil }
func ChatSend(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, chatSendFilter, func(params map[string]interface{}) string { message := params["message"].(string) room := params["room"].(int) player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } helpers.Logger.Debug("received chat message: %s %s", message, player.Name) spec := player.IsSpectatingId(uint(room)) //Check if player has either joined, or is spectating lobby lobbyId, tperr := player.GetLobbyId() if room > 0 { if tperr != nil && !spec && lobbyId != uint(room) { bytes, _ := chelpers.BuildFailureJSON("Player is not in the lobby.", 5).Encode() return string(bytes) } } else { // else room is the lobby list room room, _ = strconv.Atoi(config.Constants.GlobalChatRoom) } chatMessage := simplejson.New() // TODO send proper timestamps chatMessage.Set("timestamp", time.Now().Unix()) chatMessage.Set("message", message) chatMessage.Set("room", room) chatMessage.Set("player", models.DecoratePlayerSummaryJson(player)) bytes, _ := chatMessage.Encode() broadcaster.SendMessageToRoom(fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(uint(room))), "chatReceive", string(bytes)) resp, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() chelpers.LogChat(uint(room), player.Name, player.SteamId, message) chelpers.AddScrollbackMessage(uint(room), string(bytes)) return string(resp) }) }
func PlayerNotReady(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, playerUnreadyFilter, func(_ map[string]interface{}) string { player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobbyid, tperr := player.GetLobbyId() if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobby, tperr := models.GetLobbyById(lobbyid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if lobby.State != models.LobbyStateReadyingUp { bytes, _ := helpers.NewTPError("Lobby hasn't been filled up yet.", 4).ErrorJSON().Encode() return string(bytes) } helpers.LockRecord(lobby.ID, lobby) tperr = lobby.UnreadyPlayer(player) lobby.RemovePlayer(player) helpers.UnlockRecord(lobby.ID, lobby) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobby.UnreadyAllPlayers() bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) }) }
func PlayerSettingsSet(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, playerSettingsSetFilter, func(params map[string]interface{}) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) key := params["key"].(string) value := params["value"].(string) err := player.SetSetting(key, value) if err != nil { bytes, _ := chelpers.BuildFailureJSON(err.Error(), 0).Encode() return string(bytes) } resp, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(resp) }) }
func (Admin) AdminChangeRole(server *wsevent.Server, so *wsevent.Client, data []byte) []byte { reqerr := chelpers.FilterRequest(so, 0, true) if reqerr != nil { return reqerr.Encode() } var args struct { Steamid *string `json:"steamid"` Role *string `json:"role"` } err := chelpers.GetParams(data, &args) if err != nil { return helpers.NewTPErrorFromError(err).Encode() } role, ok := helpers.RoleMap[*args.Role] if !ok || role == helpers.RoleAdmin { return helpers.NewTPError("Invalid role parameter", 0).Encode() } otherPlayer, err := models.GetPlayerBySteamId(*args.Steamid) if err != nil { return helpers.NewTPError("Player not found.", 0).Encode() } currPlayer, _ := chelpers.GetPlayerSocket(so.Id()) models.LogAdminAction(currPlayer.ID, helpers.ActionChangeRole, otherPlayer.ID) // actual change happens otherPlayer.Role = role db.DB.Save(&otherPlayer) // rewrite session data. THIS WON'T WRITE A COOKIE SO IT ONLY WORKS WITH // STORES THAT STORE DATA IN COOKIES (AND NOT ONLY SESSION ID). session, sesserr := chelpers.GetSessionHTTP(so.Request()) if sesserr == nil { session.Values["role"] = role session.Save(so.Request(), FakeResponseWriter{}) } return chelpers.EmptySuccessJS }
func (Player) PlayerReady(_ *wsevent.Server, so *wsevent.Client, data []byte) []byte { reqerr := chelpers.FilterRequest(so, authority.AuthAction(0), true) if reqerr != nil { return reqerr.Encode() } steamid := chelpers.GetSteamId(so.Id()) player, tperr := models.GetPlayerBySteamId(steamid) if tperr != nil { return tperr.Encode() } lobbyid, tperr := player.GetLobbyId() if tperr != nil { return tperr.Encode() } lobby, tperr := models.GetLobbyByIdServer(lobbyid) if tperr != nil { return tperr.Encode() } if lobby.State != models.LobbyStateReadyingUp { return helpers.NewTPError("Lobby hasn't been filled up yet.", 4).Encode() } tperr = lobby.ReadyPlayer(player) if tperr != nil { return tperr.Encode() } if lobby.IsEveryoneReady() { db.DB.Table("lobbies").Where("id = ?", lobby.ID).Update("state", models.LobbyStateInProgress) chelpers.BroadcastLobbyStart(lobby) models.BroadcastLobbyList() models.FumbleLobbyStarted(lobby) } return chelpers.EmptySuccessJS }
func (Lobby) LobbyServerReset(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"` } if err := chelpers.GetParams(data, &args); err != nil { return helpers.NewTPErrorFromError(err).Encode() } player, err := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if err != nil { return err.Encode() } lobby, tperr := models.GetLobbyById(*args.ID) if player.SteamId != lobby.CreatedBySteamID { return helpers.NewTPError("Player not authorized to close lobby.", -1).Encode() } if tperr != nil { return tperr.Encode() } if lobby.State == models.LobbyStateEnded { return helpers.NewTPError("Lobby has ended", 1).Encode() } if err := models.ReExecConfig(lobby.ID); err != nil { return helpers.NewTPErrorFromError(err).Encode() } return chelpers.EmptySuccessJS }
func (Lobby) LobbySpectatorLeave(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"` } if err := chelpers.GetParams(data, &args); err != nil { return helpers.NewTPErrorFromError(err).Encode() } steamId := chelpers.GetSteamId(so.Id()) player, tperr := models.GetPlayerBySteamId(steamId) if tperr != nil { return tperr.Encode() } lob, tperr := models.GetLobbyById(*args.Id) if tperr != nil { return tperr.Encode() } if !player.IsSpectatingId(lob.ID) { if id, _ := player.GetLobbyId(); id == *args.Id { chelpers.AfterLobbySpecLeave(server, so, lob) return chelpers.EmptySuccessJS } return helpers.NewTPError("Player is not spectating", -1).Encode() } lob.RemoveSpectator(player, true) chelpers.AfterLobbySpecLeave(server, so, lob) return chelpers.EmptySuccessJS }
func PlayerUnready(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, playerUnreadyFilter, func(_ map[string]interface{}) string { player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobbyid, tperr := player.GetLobbyId() if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobby, tperr := models.GetLobbyById(lobbyid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } helpers.LockRecord(lobby.ID, lobby) tperr = lobby.UnreadyPlayer(player) helpers.UnlockRecord(lobby.ID, lobby) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) }) }
func (Lobby) LobbyClose(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"` } if err := chelpers.GetParams(data, &args); err != nil { return helpers.NewTPErrorFromError(err).Encode() } player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) lob, tperr := models.GetLobbyByIdServer(uint(*args.Id)) if tperr != nil { return tperr.Encode() } if player.SteamId != lob.CreatedBySteamID && player.Role != helpers.RoleAdmin { return helpers.NewTPError("Player not authorized to close lobby.", -1).Encode() } if lob.State == models.LobbyStateEnded { return helpers.NewTPError("Lobby already closed.", -1).Encode() } models.FumbleLobbyEnded(lob) lob.Close(true) models.BroadcastLobbyList() // has to be done manually for now return chelpers.EmptySuccessJS }
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 AdminChangeRole(so socketio.Socket) func(string) string { return chelpers.FilterRequest(so, adminChangeRoleFilter, func(params map[string]interface{}) string { roleString := params["role"].(string) steamid := params["steamid"].(string) role, ok := helpers.RoleMap[roleString] if !ok || role == helpers.RoleAdmin { bytes, _ := chelpers.BuildFailureJSON("Invalid role parameter", 0).Encode() return string(bytes) } otherPlayer, err := models.GetPlayerBySteamId(steamid) if err != nil { bytes, _ := chelpers.BuildFailureJSON("Player not found.", 0).Encode() return string(bytes) } currPlayer, _ := chelpers.GetPlayerSocket(so.Id()) models.LogAdminAction(currPlayer.ID, helpers.ActionChangeRole, otherPlayer.ID) // actual change happens otherPlayer.Role = role db.DB.Save(&otherPlayer) // rewrite session data. THiS WON'T WRITE A COOKIE SO IT ONLY WORKS WITH // STORES THAT STORE DATA IN COOKIES (AND NOT ONLY SESSION ID). session, sesserr := chelpers.GetSessionHTTP(so.Request()) if sesserr == nil { session.Values["role"] = role session.Save(so.Request(), FakeResponseWriter{}) } return chelpers.BuildEmptySuccessString() }) }
func (Player) PlayerNotReady(_ *wsevent.Server, so *wsevent.Client, data []byte) []byte { reqerr := chelpers.FilterRequest(so, authority.AuthAction(0), true) if reqerr != nil { return reqerr.Encode() } player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { return tperr.Encode() } lobbyid, tperr := player.GetLobbyId() if tperr != nil { return tperr.Encode() } lobby, tperr := models.GetLobbyById(lobbyid) if tperr != nil { return tperr.Encode() } if lobby.State != models.LobbyStateReadyingUp { return helpers.NewTPError("Lobby hasn't been filled up yet.", 4).Encode() } tperr = lobby.UnreadyPlayer(player) lobby.RemovePlayer(player) if tperr != nil { return tperr.Encode() } lobby.UnreadyAllPlayers() return chelpers.EmptySuccessJS }
func handleEvent(event map[string]interface{}) { switch event["name"] { case "playerDisc": slot := &models.LobbySlot{} lobbyid := event["lobbyId"].(uint) steamId := event["steamId"].(string) player, _ := models.GetPlayerBySteamId(steamId) db.DB.Where("player_id = ? AND lobby_id = ?", player.ID, lobbyid).First(slot) helpers.LockRecord(slot.ID, slot) slot.InGame = false db.DB.Save(slot) helpers.UnlockRecord(slot.ID, slot) room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid)) broadcaster.SendMessageToRoom(room, "sendNotification", fmt.Sprintf("%s has disconected from the server .", player.Name)) go func() { t := time.After(time.Minute * 2) <-t lobby, _ := models.GetLobbyById(lobbyid) slot := &models.LobbySlot{} db.DB.Where("player_id = ? AND lobby_id = ?", player.ID, lobbyid).First(slot) if !slot.InGame { helpers.LockRecord(lobby.ID, lobby) defer helpers.UnlockRecord(lobby.ID, lobby) lobby.RemovePlayer(player) broadcaster.SendMessage(player.SteamId, "sendNotification", "You have been removed from the lobby.") } }() case "playerConn": slot := &models.LobbySlot{} lobbyid := event["lobbyId"].(uint) steamId := event["steamId"].(string) player, _ := models.GetPlayerBySteamId(steamId) err := db.DB.Where("player_id = ? AND lobby_id = ?", player.ID, lobbyid).First(slot).Error if err == nil { //else, player isn't in the lobby, will be kicked by Pauling helpers.LockRecord(slot.ID, slot) slot.InGame = true db.DB.Save(slot) helpers.UnlockRecord(slot.ID, slot) } case "playerRep": lobbyid := event["lobbyId"].(uint) steamId := event["steamId"].(string) player, _ := models.GetPlayerBySteamId(steamId) var slot *models.LobbySlot db.DB.Where("player_id = ? AND lobby_id = ?", player.ID, lobbyid).Find(slot) slot.NeedSub = true db.DB.Save(slot) room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid)) broadcaster.SendMessageToRoom(room, "sendNotification", fmt.Sprintf("%s has been reported.", player.Name)) case "discFromServer": lobbyid := event["lobbyId"].(uint) lobby, _ := models.GetLobbyById(lobbyid) helpers.LockRecord(lobby.ID, lobby) lobby.Close(false) helpers.UnlockRecord(lobby.ID, lobby) room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid)) broadcaster.SendMessageToRoom(room, "sendNotification", "Disconnected from Server.") case "matchEnded": lobbyid := event["lobbyId"].(uint) lobby, _ := models.GetLobbyById(lobbyid) helpers.LockRecord(lobby.ID, lobby) lobby.UpdateStats() lobby.Close(false) helpers.UnlockRecord(lobby.ID, lobby) room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid)) broadcaster.SendMessageToRoom(room, "sendNotification", "Lobby Ended.") case "getServers": var lobbies []*models.Lobby var activeStates = []models.LobbyState{models.LobbyStateWaiting, models.LobbyStateInProgress} db.DB.Model(&models.Lobby{}).Where("state IN (?)", activeStates).Find(&lobbies) for _, lobby := range lobbies { info := models.ServerBootstrap{ LobbyId: lobby.ID, Info: lobby.ServerInfo, } for _, player := range lobby.BannedPlayers { info.BannedPlayers = append(info.BannedPlayers, player.SteamId) } for _, slot := range lobby.Slots { var player *models.Player db.DB.Find(player, slot.PlayerId) info.Players = append(info.Players, player.SteamId) } models.Pauling.Call("Pauling.SetupVerifier", &info, &struct{}{}) } } }
func SocketInit(so socketio.Socket) { chelpers.AuthenticateSocket(so.Id(), so.Request()) if chelpers.IsLoggedInSocket(so.Id()) { steamid := chelpers.GetSteamId(so.Id()) SteamIdSocketMap[steamid] = &so } so.On("disconnection", func() { chelpers.DeauthenticateSocket(so.Id()) if chelpers.IsLoggedInSocket(so.Id()) { steamid := chelpers.GetSteamId(so.Id()) delete(SteamIdSocketMap, steamid) } helpers.Logger.Debug("on disconnect") }) so.On("authenticationTest", chelpers.AuthFilter(so.Id(), func(val string) string { return "authenticated" })) helpers.Logger.Debug("on connection") so.Join("-1") //room for global chat if chelpers.IsLoggedInSocket(so.Id()) { player, err := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if err != nil { helpers.Logger.Warning("User has a cookie with but a matching player record doesn't exist: %s", chelpers.GetSteamId(so.Id())) return } lobbyid, err := player.GetLobbyId() if err != nil { so.Join(strconv.FormatUint(uint64(lobbyid), 10)) } } var lobbyCreateParams = map[string]chelpers.Param{ "mapName": chelpers.Param{Type: chelpers.PTypeString}, "type": chelpers.Param{Type: chelpers.PTypeString}, "server": chelpers.Param{Type: chelpers.PTypeString}, "rconpwd": chelpers.Param{Type: chelpers.PTypeString}, "whitelist": chelpers.Param{Type: chelpers.PTypeInt}, "mumbleRequired": chelpers.Param{Type: chelpers.PTypeBool}, } so.On("lobbyCreate", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(lobbyCreateParams, func(js *simplejson.Json) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) mapName, _ := js.Get("mapName").String() lobbytypestring, _ := js.Get("type").String() server, _ := js.Get("server").String() rconPwd, _ := js.Get("rconpwd").String() whitelist, err := js.Get("whitelist").Int() var playermap = map[string]models.LobbyType{ "sixes": models.LobbyTypeSixes, "highlander": models.LobbyTypeHighlander, } lobbytype, ok := playermap[lobbytypestring] if !ok { bytes, _ := chelpers.BuildFailureJSON("Lobby type invalid.", -1).Encode() return string(bytes) } //mumble, _ := js.Get("mumbleRequired").Bool() //TODO: Configure server here //TODO what if playermap[lobbytype] is nil? lob := models.NewLobby(mapName, lobbytype, models.ServerRecord{Host: server, RconPassword: rconPwd}, whitelist) lob.CreatedBy = *player err = lob.Save() if err != nil { bytes, _ := err.(*helpers.TPError).ErrorJSON().Encode() return string(bytes) } // setup server info go func() { err := lob.TrySettingUp() if err != nil { SendMessage(chelpers.GetSteamId(so.Id()), "sendNotification", err.Error()) } else { // for debug SendMessage(chelpers.GetSteamId(so.Id()), "sendNotification", fmt.Sprintf("Lobby %d created successfully", lob.ID)) } }() lobby_id := simplejson.New() lobby_id.Set("id", lob.ID) bytes, _ := chelpers.BuildSuccessJSON(lobby_id).Encode() return string(bytes) }))) var lobbyCloseParams = map[string]chelpers.Param{ "id": chelpers.Param{Type: chelpers.PTypeInt}, } so.On("lobbyClose", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(lobbyCloseParams, func(js *simplejson.Json) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) lobbyid, _ := js.Get("id").Uint64() lob, tperr := models.GetLobbyById(uint(lobbyid)) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if player.ID != lob.CreatedByID { bytes, _ := chelpers.BuildFailureJSON("Player not authorized to close lobby.", 1).Encode() return string(bytes) } if lob.State == models.LobbyStateEnded { bytes, _ := chelpers.BuildFailureJSON("Lobby already closed.", -1).Encode() return string(bytes) } lob.Close() bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) }))) var lobbyJoinParams = map[string]chelpers.Param{ "id": chelpers.Param{Type: chelpers.PTypeInt}, "class": chelpers.Param{Type: chelpers.PTypeString}, "team": chelpers.Param{Type: chelpers.PTypeString}, } so.On("lobbyJoin", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(lobbyJoinParams, func(js *simplejson.Json) string { player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobbyid, _ := js.Get("id").Uint64() classString, _ := js.Get("class").String() teamString, _ := js.Get("team").String() lob, tperr := models.GetLobbyById(uint(lobbyid)) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } slot, tperr := chelpers.GetPlayerSlot(lob.Type, teamString, classString) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } tperr = lob.AddPlayer(player, slot) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } so.Join(strconv.FormatUint(lobbyid, 10)) bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) }))) var lobbyRemovePlayerParams = map[string]chelpers.Param{ "id": chelpers.Param{Type: chelpers.PTypeInt}, "steamid": chelpers.Param{Type: chelpers.PTypeString, Default: ""}, "ban": chelpers.Param{Type: chelpers.PTypeBool, Default: false}, } so.On("lobbyRemovePlayer", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(lobbyRemovePlayerParams, func(js *simplejson.Json) string { steamid, _ := js.Get("steamid").String() ban, _ := js.Get("ban").Bool() lobbyid, _ := js.Get("id").Int() self := false // TODO check authorization, currently can kick anyone if steamid == "" || steamid == chelpers.GetSteamId(so.Id()) { self = true steamid = chelpers.GetSteamId(so.Id()) } player, tperr := models.GetPlayerBySteamId(steamid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lob, tperr := models.GetLobbyById(uint(lobbyid)) if tperr != nil { bytes, _ := chelpers.BuildFailureJSON(tperr.Error(), -1).Encode() return string(bytes) } if !self && lob.CreatedByID != player.ID { // TODO proper authorization checks bytes, _ := chelpers.BuildFailureJSON("Not authorized to remove players", 1).Encode() return string(bytes) } _, err := lob.GetPlayerSlot(player) if err == nil { lob.RemovePlayer(player) } else if player.IsSpectatingId(lob.ID) { lob.RemoveSpectator(player) } else { bytes, _ := chelpers.BuildFailureJSON("Player neither playing nor spectating", 2).Encode() return string(bytes) } if ban { lob.BanPlayer(player) } so.Leave(strconv.FormatInt(int64(lobbyid), 10)) bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) }))) so.On("playerReady", chelpers.AuthFilter(so.Id(), func(val string) string { steamid := chelpers.GetSteamId(so.Id()) player, tperr := models.GetPlayerBySteamId(steamid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobbyid, tperr := player.GetLobbyId() if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobby, tperr := models.GetLobbyById(lobbyid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } tperr = lobby.ReadyPlayer(player) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if lobby.IsEveryoneReady() { bytes, _ := decorators.GetLobbyConnectJSON(lobby).Encode() SendMessageToRoom(strconv.FormatUint(uint64(lobby.ID), 10), "lobbyStart", string(bytes)) } bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) })) so.On("playerUnready", chelpers.AuthFilter(so.Id(), func(val string) string { player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobbyid, tperr := player.GetLobbyId() if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lobby, tperr := models.GetLobbyById(lobbyid) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } tperr = lobby.UnreadyPlayer(player) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(bytes) })) var lobbyJoinSpectatorParams = map[string]chelpers.Param{ "id": chelpers.Param{Type: chelpers.PTypeInt}, } so.On("lobbySpectatorJoin", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(lobbyJoinSpectatorParams, func(js *simplejson.Json) string { lobbyid, _ := js.Get("id").Uint64() player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lob, tperr := models.GetLobbyById(uint(lobbyid)) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() tperr = lob.AddSpectator(player) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } lob.Save() return string(bytes) }))) var playerSettingsGetParams = map[string]chelpers.Param{ "key": chelpers.Param{Type: chelpers.PTypeString, Default: ""}, } so.On("playerSettingsGet", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(playerSettingsGetParams, func(js *simplejson.Json) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) key, _ := js.Get("key").String() var err error var settings []models.PlayerSetting var setting models.PlayerSetting if key == "" { settings, err = player.GetSettings() } else { setting, err = player.GetSetting(key) settings = append(settings, setting) } if err != nil { bytes, _ := chelpers.BuildFailureJSON(err.Error(), 0).Encode() return string(bytes) } result := decorators.GetPlayerSettingsJson(settings) resp, _ := chelpers.BuildSuccessJSON(result).Encode() return string(resp) }))) var playerSettingsSetParams = map[string]chelpers.Param{ "key": chelpers.Param{Type: chelpers.PTypeString}, "value": chelpers.Param{Type: chelpers.PTypeString}, } so.On("playerSettingsSet", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(playerSettingsSetParams, func(js *simplejson.Json) string { player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) key, _ := js.Get("key").String() value, _ := js.Get("value").String() err := player.SetSetting(key, value) if err != nil { bytes, _ := chelpers.BuildFailureJSON(err.Error(), 0).Encode() return string(bytes) } resp, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(resp) }))) var playerProfileParams = map[string]chelpers.Param{ "steamid": chelpers.Param{Type: chelpers.PTypeString, Default: ""}, } so.On("playerProfile", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(playerProfileParams, func(js *simplejson.Json) string { steamid, _ := js.Get("steamid").String() if steamid == "" { steamid = chelpers.GetSteamId(so.Id()) } player, playErr := models.GetPlayerWithStats(steamid) if playErr != nil { bytes, _ := chelpers.BuildFailureJSON(playErr.Error(), 0).Encode() return string(bytes) } result := decorators.GetPlayerProfileJson(player) resp, _ := chelpers.BuildSuccessJSON(result).Encode() return string(resp) }))) var chatSendParams = map[string]chelpers.Param{ "message": chelpers.Param{Type: chelpers.PTypeString}, "room": chelpers.Param{Type: chelpers.PTypeInt}, } so.On("chatSend", chelpers.AuthFilter(so.Id(), chelpers.JsonVerifiedFilter(chatSendParams, func(js *simplejson.Json) string { message, _ := js.Get("message").String() room, _ := js.Get("room").Int() player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } //Check if player has either joined, or is spectating lobby lobbyId, tperr := player.GetLobbyId() if room > 0 { // if room is a lobby room if tperr != nil { bytes, _ := tperr.ErrorJSON().Encode() return string(bytes) } else if lobbyId != uint(room) && !player.IsSpectatingId(uint(room)) { bytes, _ := chelpers.BuildFailureJSON("Player is not in the lobby.", 5).Encode() return string(bytes) } } else { // else room is the lobby list room room = -1 } t := time.Now() chatMessage := simplejson.New() // TODO send proper timestamps chatMessage.Set("timestamp", strconv.Itoa(t.Hour())+strconv.Itoa(t.Minute())) chatMessage.Set("message", html.EscapeString(message)) chatMessage.Set("room", room) user := simplejson.New() user.Set("id", player.SteamId) user.Set("name", player.Name) chatMessage.Set("user", user) bytes, _ := chatMessage.Encode() so.BroadcastTo(strconv.Itoa(room), "chatReceive", string(bytes)) resp, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode() return string(resp) }))) }
func (Lobby) LobbyCreate(_ *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 { Map *string `json:"map"` Type *string `json:"type" valid:"debug,6s,highlander,4v4,ultiduo,bball"` League *string `json:"league" valid:"ugc,etf2l,esea,asiafortress,ozfortress"` Server *string `json:"server"` RconPwd *string `json:"rconpwd"` WhitelistID *uint `json:"whitelistID"` Mumble *bool `json:"mumbleRequired"` } err := chelpers.GetParams(data, &args) if err != nil { return helpers.NewTPErrorFromError(err).Encode() } player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) var playermap = map[string]models.LobbyType{ "debug": models.LobbyTypeDebug, "6s": models.LobbyTypeSixes, "highlander": models.LobbyTypeHighlander, "ultiduo": models.LobbyTypeUltiduo, "bball": models.LobbyTypeBball, "4v4": models.LobbyTypeFours, } lobbyType := playermap[*args.Type] var count int db.DB.Table("server_records").Where("host = ?", *args.Server).Count(&count) if count != 0 { return helpers.NewTPError("A lobby is already using this server.", -1).Encode() } randBytes := make([]byte, 6) rand.Read(randBytes) serverPwd := base64.URLEncoding.EncodeToString(randBytes) //TODO what if playermap[lobbytype] is nil? info := models.ServerRecord{ Host: *args.Server, RconPassword: *args.RconPwd, ServerPassword: serverPwd} // err = models.VerifyInfo(info) // if err != nil { // bytes, _ := helpers.NewTPErrorFromError(err).Encode() // return string(bytes) // } lob := models.NewLobby(*args.Map, lobbyType, *args.League, info, int(*args.WhitelistID), *args.Mumble) lob.CreatedBySteamID = player.SteamId lob.RegionCode, lob.RegionName = chelpers.GetRegion(*args.Server) if (lob.RegionCode == "" || lob.RegionName == "") && config.Constants.GeoIP != "" { return helpers.NewTPError("Couldn't find region server.", 1).Encode() } lob.Save() err = lob.SetupServer() if err != nil { qerr := db.DB.Where("id = ?", lob.ID).Delete(&models.Lobby{}).Error if qerr != nil { helpers.Logger.Warning(qerr.Error()) } db.DB.Delete(&lob.ServerInfo) return helpers.NewTPErrorFromError(err).Encode() } lob.State = models.LobbyStateWaiting lob.Save() reply_str := struct { ID uint `json:"id"` }{lob.ID} models.FumbleLobbyCreated(lob) bytes, _ := chelpers.BuildSuccessJSON(reply_str).Encode() return 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 SocketInit(so socketio.Socket) { chelpers.AuthenticateSocket(so.Id(), so.Request()) if chelpers.IsLoggedInSocket(so.Id()) { steamid := chelpers.GetSteamId(so.Id()) broadcaster.SetSocket(steamid, so) } so.On("disconnection", func() { chelpers.DeauthenticateSocket(so.Id()) if chelpers.IsLoggedInSocket(so.Id()) { steamid := chelpers.GetSteamId(so.Id()) broadcaster.RemoveSocket(steamid) } helpers.Logger.Debug("on disconnect") }) so.On("authenticationTest", chelpers.FilterRequest(so, chelpers.FilterParams{FilterLogin: true}, func(_ map[string]interface{}) string { return "authenticated" })) helpers.Logger.Debug("on connection") chelpers.AfterConnect(so) loggedIn := chelpers.IsLoggedInSocket(so.Id()) if loggedIn { player, err := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id())) if err != nil { helpers.Logger.Warning("User has a cookie with but a matching player record doesn't exist: %s", chelpers.GetSteamId(so.Id())) return } chelpers.AfterConnectLoggedIn(so, player) } else { so.Emit("playerSettings", "{}") so.Emit("playerProfile", "{}") } // LOBBY CREATE so.On("lobbyCreate", handler.LobbyCreate(so)) so.On("serverVerify", handler.ServerVerify(so)) so.On("lobbyClose", handler.LobbyClose(so)) so.On("lobbyJoin", handler.LobbyJoin(so)) if loggedIn { so.On("lobbySpectatorJoin", handler.LobbySpectatorJoin(so)) } else { so.On("lobbySpectatorJoin", handler.LobbyNoLoginSpectatorJoin(so)) } so.On("lobbyKick", handler.LobbyKick(so)) so.On("playerReady", handler.PlayerReady(so)) so.On("playerNotReady", handler.PlayerNotReady(so)) so.On("playerSettingsGet", handler.PlayerSettingsGet(so)) so.On("playerSettingsSet", handler.PlayerSettingsSet(so)) so.On("playerProfile", handler.PlayerProfile(so)) so.On("chatSend", handler.ChatSend(so)) so.On("adminChangeRole", handler.AdminChangeRole(so)) so.On("requestLobbyListData", handler.RequestLobbyListData(so)) //Debugging handlers if config.Constants.ServerMockUp { so.On("debugLobbyFill", handler.DebugLobbyFill(so)) so.On("debugLobbyReady", handler.DebugLobbyReady(so)) so.On("debugGetAllLobbies", handler.DebugRequestAllLobbies(so)) so.On("debugRequestLobbyStart", handler.DebugRequestLobbyStart(so)) } so.Emit("socketInitialized", "") }