//SocketInit initializes the websocket connection for the provided socket
func SocketInit(so *wsevent.Client) error {
chelpers.AuthenticateSocket(so.ID, so.Request)
loggedIn := chelpers.IsLoggedInSocket(so.ID)
if loggedIn {
steamid := chelpers.GetSteamId(so.ID)
sessions.AddSocket(steamid, so)
}
if loggedIn {
hooks.AfterConnect(socket.AuthServer, so)
player, err := models.GetPlayerBySteamID(chelpers.GetSteamId(so.ID))
if err != nil {
logrus.Warning(
"User has a cookie with but a matching player record doesn't exist: %s",
chelpers.GetSteamId(so.ID))
chelpers.DeauthenticateSocket(so.ID)
hooks.AfterConnect(socket.UnauthServer, so)
return ErrRecordNotFound
}
hooks.AfterConnectLoggedIn(so, player)
} else {
hooks.AfterConnect(socket.UnauthServer, so)
so.EmitJSON(helpers.NewRequest("playerSettings", "{}"))
so.EmitJSON(helpers.NewRequest("playerProfile", "{}"))
}
so.EmitJSON(helpers.NewRequest("socketInitialized", "{}"))
return nil
}
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) PlayerSettingsSet(so *wsevent.Client, args struct {
Key *string `json:"key"`
Value *string `json:"value"`
}) interface{} {
player, _ := models.GetPlayerBySteamID(chelpers.GetSteamId(so.ID))
err := player.SetSetting(*args.Key, *args.Value)
if err != nil {
return helpers.NewTPErrorFromError(err)
}
switch *args.Key {
case "siteAlias":
profile := models.DecoratePlayerProfileJson(player)
so.EmitJSON(helpers.NewRequest("playerProfile", profile))
if lobbyID, _ := player.GetLobbyID(true); lobbyID != 0 {
lobby, _ := models.GetLobbyByID(lobbyID)
lobbyData := lobby.LobbyData(true)
lobbyData.Send()
}
case "mumbleNick":
if !reMumbleNick.MatchString(*args.Value) {
return helpers.NewTPError("Invalid Mumble nick.", -1)
}
}
return chelpers.EmptySuccessJS
}
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 (Player) PlayerProfile(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"`
}
err := chelpers.GetParams(data, &args)
if err != nil {
return helpers.NewTPErrorFromError(err).Encode()
}
steamid := args.Steamid
if steamid == "" {
steamid = chelpers.GetSteamId(so.Id())
}
player, playErr := models.GetPlayerWithStats(steamid)
if playErr != nil {
return playErr.Encode()
}
result := models.DecoratePlayerProfileJson(player)
resp, _ := chelpers.BuildSuccessJSON(result).Encode()
return resp
}
func (Player) PlayerNotReady(so *wsevent.Client, _ struct{}) interface{} {
player, tperr := models.GetPlayerBySteamID(chelpers.GetSteamId(so.ID))
if tperr != nil {
return tperr
}
lobbyid, tperr := player.GetLobbyID(false)
if tperr != nil {
return tperr
}
lobby, tperr := models.GetLobbyByID(lobbyid)
if tperr != nil {
return tperr
}
if lobby.State != models.LobbyStateReadyingUp {
return helpers.NewTPError("Lobby hasn't been filled up yet.", 4)
}
tperr = lobby.UnreadyPlayer(player)
lobby.RemovePlayer(player)
hooks.AfterLobbyLeave(lobby, player)
lobby.AddSpectator(player)
hooks.AfterLobbySpec(socket.AuthServer, so, lobby)
if tperr != nil {
return tperr
}
lobby.UnreadyAllPlayers()
return chelpers.EmptySuccessJS
}
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 (Lobby) LobbyLeave(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())
lob, player, tperr := removePlayerFromLobby(*args.Id, steamId)
if tperr != nil {
return tperr.Encode()
}
chelpers.AfterLobbyLeave(server, so, lob, player)
return chelpers.EmptySuccessJS
}
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 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 (Lobby) LobbyBan(so *wsevent.Client, args struct {
Id *uint `json:"id"`
Steamid *string `json:"steamid"`
}) interface{} {
steamId := *args.Steamid
selfSteamId := chelpers.GetSteamId(so.ID)
if steamId == selfSteamId {
return helpers.NewTPError("Player can't kick himself.", -1)
}
if ok, tperr := playerCanKick(*args.Id, selfSteamId); !ok {
return tperr
}
lob, player, tperr := removePlayerFromLobby(*args.Id, steamId)
if tperr != nil {
return tperr
}
lob.BanPlayer(player)
hooks.AfterLobbyLeave(lob, player)
// broadcaster.SendMessage(steamId, "sendNotification",
// fmt.Sprintf(`{"notification": "You have been removed from Lobby #%d"}`, *args.Id))
return chelpers.EmptySuccessJS
}
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 (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
}
//OnDisconnect is connected when a player with a given socketID disconnects
func OnDisconnect(socketID string) {
pprof.Clients.Add(-1)
defer chelpers.DeauthenticateSocket(socketID)
if chelpers.IsLoggedInSocket(socketID) {
steamid := chelpers.GetSteamId(socketID)
sessions.RemoveSocket(socketID, steamid)
player, tperr := models.GetPlayerBySteamID(steamid)
if tperr != nil || player == nil {
logrus.Error(tperr.Error())
return
}
ids, tperr := player.GetSpectatingIds()
if tperr != nil {
logrus.Error(tperr.Error())
return
}
for _, id := range ids {
//if this _specific_ socket is spectating this lobby, remove them from it
//player might be spectating other lobbies in another tab, but we don't care
if sessions.IsSpectating(socketID, id) {
lobby, _ := models.GetLobbyByID(id)
err := lobby.RemoveSpectator(player, true)
if err != nil {
logrus.Error(err.Error())
continue
}
sessions.RemoveSpectator(socketID)
//logrus.Debug("removing %s from %d", player.SteamId, id)
}
}
id, _ := player.GetLobbyID(true)
//if player is in a waiting lobby, and hasn't connected for > 30 seconds,
//remove him from it. Here, connected = player isn't connected from any tab/window
if id != 0 && sessions.ConnectedSockets(player.SteamID) == 0 {
time.AfterFunc(time.Second*30, func() {
if !sessions.IsConnected(player.SteamID) {
//player may have changed lobbies during this time
//fetch lobby ID again
id, err := player.GetLobbyID(true)
if err != nil {
return
}
lobby := &models.Lobby{}
db.DB.First(lobby, id)
lobby.RemovePlayer(player)
}
})
}
}
}
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 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 (Lobby) LobbyLeave(so *wsevent.Client, args struct {
Id *uint `json:"id"`
}) interface{} {
steamId := chelpers.GetSteamId(so.ID)
lob, player, tperr := removePlayerFromLobby(*args.Id, steamId)
if tperr != nil {
return tperr
}
hooks.AfterLobbyLeave(lob, player)
return chelpers.EmptySuccessJS
}
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 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 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 (Player) PlayerProfile(so *wsevent.Client, args struct {
Steamid *string `json:"steamid"`
}) interface{} {
steamid := *args.Steamid
if steamid == "" {
steamid = chelpers.GetSteamId(so.ID)
}
player, playErr := models.GetPlayerWithStats(steamid)
if playErr != nil {
return playErr
}
result := models.DecoratePlayerProfileJson(player)
return chelpers.NewResponse(result)
}
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) LobbyBan(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"`
Steamid *string `json:"steamid"`
}
if err := chelpers.GetParams(data, &args); err != nil {
return helpers.NewTPErrorFromError(err).Encode()
}
steamId := *args.Steamid
selfSteamId := chelpers.GetSteamId(so.Id())
if steamId == selfSteamId {
return helpers.NewTPError("Player can't kick himself.", -1).Encode()
}
if ok, tperr := playerCanKick(*args.Id, selfSteamId); !ok {
return tperr.Encode()
}
lob, player, tperr := removePlayerFromLobby(*args.Id, steamId)
if tperr != nil {
return tperr.Encode()
}
lob.BanPlayer(player)
so, _ = broadcaster.GetSocket(player.SteamId)
chelpers.AfterLobbyLeave(server, so, lob, player)
broadcaster.SendMessage(steamId, "sendNotification",
fmt.Sprintf(`{"notification": "You have been removed from Lobby #%d"}`, *args.Id))
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 PlayerProfile(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, playerProfileFilter,
func(params map[string]interface{}) string {
steamid := params["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 := models.DecoratePlayerProfileJson(player)
resp, _ := chelpers.BuildSuccessJSON(result).Encode()
return string(resp)
})
}
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 (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 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))
}
}
