func BroadcastLobby(lobby *Lobby) {
bytes, _ := DecorateLobbyDataJSON(lobby, true).Encode()
room := strconv.FormatUint(uint64(lobby.ID), 10)
broadcaster.SendMessageToRoom(room, "lobbyData", string(bytes))
broadcaster.SendMessageToRoom(fmt.Sprintf("%s_public", room), "lobbyData", string(bytes))
}
func BroadcastLobby(lobby *Lobby) {
//db.DB.Preload("Spectators").First(&lobby, lobby.ID)
bytes, _ := json.Marshal(DecorateLobbyData(lobby, true))
room := strconv.FormatUint(uint64(lobby.ID), 10)
broadcaster.SendMessageToRoom(room, "lobbyData", string(bytes))
broadcaster.SendMessageToRoom(fmt.Sprintf("%s_public", room), "lobbyData", string(bytes))
}
//BroadcastLobbyList broadcasts the lobby list to all users
func BroadcastLobbyList() {
lobbies := []Lobby{}
db.DB.Where("state = ?", LobbyStateWaiting).Order("id desc").Find(&lobbies)
broadcaster.SendMessageToRoom(
fmt.Sprintf("%s_public", config.GlobalChatRoom),
"lobbyListData", DecorateLobbyListData(lobbies))
}
func DebugLobbyFill(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, debugLobbyFillFilter,
func(param map[string]interface{}) string {
id := param["id"].(uint)
lobby, _ := models.GetLobbyById(id)
var players []*models.Player
for i := 1; i < int(lobby.Type)*2; i++ {
steamid := "DEBUG" + strconv.FormatUint(uint64(time.Now().Unix()), 10) + strconv.Itoa(i)
player, _ := models.NewPlayer(steamid)
player.Debug = true
player.Save()
players = append(players, player)
lobby.AddPlayer(player, i)
}
lobby.State = models.LobbyStateReadyingUp
lobby.Save()
room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobby.ID))
broadcaster.SendMessageToRoom(room, "lobbyReadyUp", "")
lobby.ReadyUpTimeoutCheck()
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
})
}
func BroadcastLobbyList() {
var lobbies []Lobby
db.DB.Where("state = ?", LobbyStateWaiting).Order("id desc").Find(&lobbies)
bytes, _ := json.Marshal(DecorateLobbyListData(lobbies))
broadcaster.SendMessageToRoom(
fmt.Sprintf("%s_public", config.Constants.GlobalChatRoom),
"lobbyListData", string(bytes))
}
//Close closes the lobby, which has the following effects:
//
// All unfilled substitutes for the lobby are "filled" (ie, their filled field is set to true)
// The corresponding ServerRecord is deleted
//
//If rpc == true, the log listener in Pauling for the corresponding server is stopped, this is
//used when the lobby is closed manually by a player
func (lobby *Lobby) Close(doRPC, matchEnded bool) {
var count int
db.DB.Preload("ServerInfo").First(lobby, lobby.ID)
db.DB.Model(&gameserver.ServerRecord{}).Where("host = ?", lobby.ServerInfo.Host).Count(&count)
if count != 0 {
gameserver.PutStoredServer(lobby.ServerInfo.Host)
}
lobby.SetState(Ended)
db.DB.First(lobby).UpdateColumn("match_ended", matchEnded)
//db.DB.Exec("DELETE FROM spectators_players_lobbies WHERE lobby_id = ?", lobby.ID)
if doRPC {
rpc.End(lobby.ID)
}
if matchEnded {
lobby.UpdateStats()
}
if lobby.ServemeID != 0 {
context := helpers.GetServemeContext(lobby.ServerInfo.Host)
err := context.Delete(lobby.ServemeID, lobby.CreatedBySteamID)
if err != nil {
logrus.Error(err)
}
if matchEnded {
time.AfterFunc(10*time.Second, func() {
lobby.DownloadDemo(context)
})
}
}
privateRoom := fmt.Sprintf("%d_private", lobby.ID)
broadcaster.SendMessageToRoom(privateRoom, "lobbyLeft", LobbyEvent{ID: lobby.ID})
publicRoom := fmt.Sprintf("%d_public", lobby.ID)
broadcaster.SendMessageToRoom(publicRoom, "lobbyClosed", DecorateLobbyClosed(lobby))
db.DB.Model(&gameserver.ServerRecord{}).Where("id = ?", lobby.ServerInfoID).Delete(&gameserver.ServerRecord{})
BroadcastSubList()
BroadcastLobby(lobby)
BroadcastLobbyList() // has to be done manually for now
rpc.FumbleLobbyEnded(lobby.ID)
lobby.deleteLock()
}
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 BroadcastLobbyList() {
var lobbies []Lobby
db.DB.Where("state = ?", LobbyStateWaiting).Order("id desc").Find(&lobbies)
list, err := DecorateLobbyListData(lobbies)
if err != nil {
helpers.Logger.Warning("Failed to send lobby list: %s", err.Error())
} else {
broadcaster.SendMessageToRoom(fmt.Sprintf("%s_public", config.Constants.GlobalChatRoom), "lobbyListData", list)
}
}
func (lobby *Lobby) Close(rpc bool) {
db.DB.Table("substitutes").Where("lobby_id = ?", lobby.ID).UpdateColumn("filled", true)
db.DB.First(&lobby).UpdateColumn("state", LobbyStateEnded)
db.DB.Delete(&lobby.ServerInfo)
db.DB.Exec("DELETE FROM spectators_players_lobbies WHERE lobby_id = ?", lobby.ID)
if rpc {
End(lobby.ID)
}
privateRoom := fmt.Sprintf("%d_private", lobby.ID)
bytesLobbyLeft, _ := json.Marshal(DecorateLobbyLeave(lobby))
broadcaster.SendMessageToRoom(privateRoom, "lobbyLeft", string(bytesLobbyLeft))
publicRoom := fmt.Sprintf("%d_public", lobby.ID)
bytesLobbyClosed, _ := json.Marshal(DecorateLobbyClosed(lobby))
broadcaster.SendMessageToRoom(publicRoom, "lobbyClosed", string(bytesLobbyClosed))
BroadcastLobby(lobby)
}
//Close closes the lobby, which has the following effects:
//
// All unfilled substitutes for the lobby are "filled" (ie, their filled field is set to true)
// The corresponding ServerRecord is deleted
//
//If rpc == true, the log listener in Pauling for the corresponding server is stopped, this is
//used when the lobby is closed manually by a player
func (lobby *Lobby) Close(rpc bool) {
db.DB.First(&lobby).UpdateColumn("state", LobbyStateEnded)
db.DB.Table("server_records").Where("id = ?", lobby.ServerInfoID).Delete(&ServerRecord{})
db.DB.Table("requirements").Where("lobby_id = ?", lobby.ID).Delete(&Requirement{})
//db.DB.Exec("DELETE FROM spectators_players_lobbies WHERE lobby_id = ?", lobby.ID)
if rpc {
End(lobby.ID)
}
privateRoom := fmt.Sprintf("%d_private", lobby.ID)
broadcaster.SendMessageToRoom(privateRoom, "lobbyLeft", DecorateLobbyLeave(lobby))
publicRoom := fmt.Sprintf("%d_public", lobby.ID)
broadcaster.SendMessageToRoom(publicRoom, "lobbyClosed", DecorateLobbyClosed(lobby))
BroadcastSubList()
BroadcastLobby(lobby)
BroadcastLobbyList() // has to be done manually for now
FumbleLobbyEnded(lobby)
}
func DebugRequestLobbyStart(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, debugRequestLobbyStartFilter,
func(params map[string]interface{}) string {
lobby, _ := models.GetLobbyById(params["id"].(uint))
bytes, _ := models.DecorateLobbyConnectJSON(lobby).Encode()
room := fmt.Sprintf("%s_private", chelpers.GetLobbyRoom(lobby.ID))
broadcaster.SendMessageToRoom(room,
"lobbyStart", string(bytes))
bytes, _ = chelpers.BuildSuccessJSON(simplejson.New()).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 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 matchEnded(lobbyID uint, logsID int) {
lobby, err := lobbypackage.GetLobbyByIDServer(lobbyID)
if err != nil {
logrus.Error(err)
return
}
lobby.Close(false, true)
logs := fmt.Sprintf("http://logs.tf/%d", logsID)
msg := fmt.Sprintf("Lobby Ended. Logs: %s", logs)
chat.SendNotification(msg, int(lobby.ID))
room := fmt.Sprintf("%d_private", lobby.ID)
broadcaster.SendMessageToRoom(room, "lobbyLogs", struct {
LobbyID uint `json:"lobbyID"`
Logs string `json:"logs"`
}{lobby.ID, logs})
lobby.UpdateHours(logsID)
}
func (Lobby) LobbyShuffle(so *wsevent.Client, args struct {
Id uint `json:"id"`
}) interface{} {
player := chelpers.GetPlayer(so.Token)
lob, err := lobby.GetLobbyByID(args.Id)
if err != nil {
return err
}
if player.SteamID != lob.CreatedBySteamID && (player.Role != helpers.RoleAdmin && player.Role != helpers.RoleMod) {
return errors.New("You aren't authorized to shuffle this lobby.")
}
if err = lob.ShuffleAllSlots(); err != nil {
return err
}
room := fmt.Sprintf("%s_private", hooks.GetLobbyRoom(args.Id))
broadcaster.SendMessageToRoom(room, "lobbyShuffled", args)
chat.NewBotMessage(fmt.Sprintf("Lobby shuffled by %s", player.Alias()), int(args.Id)).Send()
return emptySuccess
}
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
}
func eventListener(eventChanMap map[string](chan map[string]interface{})) {
for {
select {
case event := <-eventChanMap["playerDisc"]:
lobbyid := event["lobbyId"].(uint)
steamId := event["steamId"].(string)
player, _ := models.GetPlayerBySteamId(steamId)
lobby, _ := models.GetLobbyById(lobbyid)
lobby.SetNotInGame(player)
helpers.Logger.Debug("#%d, player %s<%s> disconnected",
lobby.ID, player.Name, player.SteamId)
room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid))
broadcaster.SendMessageToRoom(room,
"sendNotification",
fmt.Sprintf(`{"notification": "%s has disconected from the server."}`,
player.Name))
t := time.After(time.Minute * 2)
go func() {
<-t
lobby, _ := models.GetLobbyById(lobbyid)
ingame, err := lobby.IsPlayerInGame(player)
if err != nil {
helpers.Logger.Error(err.Error())
}
if !ingame {
sub, _ := models.NewSub(lobby.ID, player.SteamId)
db.DB.Save(sub)
models.BroadcastSubList()
lobby.RemovePlayer(player)
}
}()
case event := <-eventChanMap["playerConn"]:
lobbyid := event["lobbyId"].(uint)
steamId := event["steamId"].(string)
player, _ := models.GetPlayerBySteamId(steamId)
lobby, _ := models.GetLobbyById(lobbyid)
lobby.SetInGame(player)
case event := <-eventChanMap["playerSub"]:
lobbyid := event["lobbyId"].(uint)
steamId := event["steamId"].(string)
sub, err := models.NewSub(lobbyid, steamId)
if err != nil {
helpers.Logger.Error(err.Error())
continue
}
db.DB.Save(sub)
models.BroadcastSubList()
player, _ := models.GetPlayerBySteamId(steamId)
room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid))
broadcaster.SendMessageToRoom(room,
"sendNotification",
fmt.Sprintf(`{"notification": "%s has been reported."}`,
player.Name))
//helpers.Logger.Debug("#%d: Reported player %s<%s>",
// lobbyid, player.Name, player.SteamId)
case event := <-eventChanMap["discFromServer"]:
lobbyid := event["lobbyId"].(uint)
lobby, _ := models.GetLobbyByIdServer(lobbyid)
helpers.Logger.Debug("#%d: Lost connection to %s", lobby.ID, lobby.ServerInfo.Host)
lobby.Close(false)
room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid))
broadcaster.SendMessageToRoom(room,
"sendNotification", `{"notification": "Lobby Closed (Connection to server lost)."}`)
case event := <-eventChanMap["matchEnded"]:
lobbyid := event["lobbyId"].(uint)
lobby, _ := models.GetLobbyByIdServer(lobbyid)
helpers.Logger.Debug("#%d: Match Ended", lobbyid)
lobby.UpdateStats()
lobby.Close(false)
room := fmt.Sprintf("%s_public", chelpers.GetLobbyRoom(lobbyid))
broadcaster.SendMessageToRoom(room,
"sendNotification", `{"notification": ""Lobby Ended."}`)
case <-eventChanMap["getServers"]:
var lobbies []*models.Lobby
var activeStates = []models.LobbyState{models.LobbyStateWaiting, models.LobbyStateInProgress}
db.DB.Preload("ServerInfo").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 (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{} {
p := chelpers.GetPlayer(so.Token)
if banned, until := p.IsBannedWithTime(player.BanJoin); banned {
ban, _ := p.GetActiveBan(player.BanJoin)
return fmt.Errorf("You have been banned from joining lobbies till %s (%s)", until.Format(time.RFC822), ban.Reason)
}
//logrus.Debug("id %d class %s team %s", *args.Id, *args.Class, *args.Team)
lob, tperr := lobby.GetLobbyByID(*args.Id)
if tperr != nil {
return tperr
}
if lob.Mumble {
if banned, until := p.IsBannedWithTime(player.BanJoinMumble); banned {
ban, _ := p.GetActiveBan(player.BanJoinMumble)
return fmt.Errorf("You have been banned from joining Mumble lobbies till %s (%s)", until.Format(time.RFC822), ban.Reason)
}
}
if lob.State == lobby.Ended {
return errors.New("Cannot join a closed lobby.")
}
if lob.State == lobby.Initializing {
return errors.New("Lobby is being setup right now.")
}
if lob.RegionLock {
region, _ := helpers.GetRegion(chelpers.GetIPAddr(so.Request))
if region != lob.RegionCode {
return errors.New("This lobby is region locked.")
}
}
//Check if player is in the same lobby
var sameLobby bool
if id, err := p.GetLobbyID(false); err == nil && id == *args.Id {
sameLobby = true
}
slot, tperr := format.GetSlot(lob.Type, *args.Team, *args.Class)
if tperr != nil {
return tperr
}
if prevId, _ := p.GetLobbyID(false); prevId != 0 && !sameLobby {
lob, _ := lobby.GetLobbyByID(prevId)
hooks.AfterLobbyLeave(lob, p, false, false)
}
tperr = lob.AddPlayer(p, slot, *args.Password)
if tperr != nil {
return tperr
}
if !sameLobby {
hooks.AfterLobbyJoin(so, lob, p)
}
playersCnt := lob.GetPlayerNumber()
lastNotif, timerExists := lobbyJoinLastNotif[lob.ID]
if playersCnt >= notifThreshold[lob.Type] && !lob.IsEnoughPlayers(playersCnt) && (!timerExists || time.Since(lastNotif).Minutes() > 5) {
lob.DiscordNotif(fmt.Sprintf("Almost ready [%d/%d]", playersCnt, lob.RequiredPlayers()))
lobbyJoinLastNotif[lob.ID] = time.Now()
}
//check if lobby isn't already in progress (which happens when the player is subbing)
lob.Lock()
if lob.IsEnoughPlayers(playersCnt) && lob.State != lobby.InProgress && lob.State != lobby.ReadyingUp {
lob.State = lobby.ReadyingUp
lob.ReadyUpTimestamp = time.Now().Unix() + 30
lob.Save()
helpers.GlobalWait.Add(1)
time.AfterFunc(time.Second*30, func() {
state := lob.CurrentState()
//if all player's haven't readied up,
//remove unreadied players and unready the
//rest.
//don't do this when:
// lobby.State == Waiting (someone already unreadied up, so all players have been unreadied)
// lobby.State == InProgress (all players have readied up, so the lobby has started)
// lobby.State == Ended (the lobby has been closed)
if state != lobby.Waiting && state != lobby.InProgress && state != lobby.Ended {
lob.SetState(lobby.Waiting)
removeUnreadyPlayers(lob)
lob.UnreadyAllPlayers()
//get updated lobby object
lob, _ = lobby.GetLobbyByID(lob.ID)
lobby.BroadcastLobby(lob)
}
helpers.GlobalWait.Done()
})
room := fmt.Sprintf("%s_private",
hooks.GetLobbyRoom(lob.ID))
broadcaster.SendMessageToRoom(room, "lobbyReadyUp",
struct {
Timeout int `json:"timeout"`
}{30})
lobby.BroadcastLobbyList()
}
lob.Unlock()
if lob.State == lobby.InProgress { //this happens when the player is a substitute
db.DB.Preload("ServerInfo").First(lob, lob.ID)
so.EmitJSON(helpers.NewRequest("lobbyStart", lobby.DecorateLobbyConnect(lob, p, slot)))
}
return emptySuccess
}
func SendNotification(message string, room int) {
pub := fmt.Sprintf("%d_public", room)
broadcaster.SendMessageToRoom(pub, "chatReceive", NewBotMessage(message, room))
}
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 (m *ChatMessage) Send() {
broadcaster.SendMessageToRoom(fmt.Sprintf("%d_public", m.Room), "chatReceive", m)
if m.Room != 0 {
broadcaster.SendMessageToRoom(fmt.Sprintf("%d_private", m.Room), "chatReceive", m)
}
}
func (l LobbyData) Send() {
broadcaster.SendMessageToRoom(fmt.Sprintf("%d_public", l.ID), "lobbyData", l)
}
//BroadcastSubList broadcasts a the subtitute list to the room 0_public
func BroadcastSubList() {
subList := DecorateSubstituteList()
broadcaster.SendMessageToRoom("0_public", "subListData", subList)
}
//BroadcastLobbyList broadcasts the lobby list to all users
func BroadcastLobbyList() {
broadcaster.SendMessageToRoom(
"0_public",
"lobbyListData", DecorateLobbyListData(GetWaitingLobbies(), false))
}
//BroadcastLobby broadcasts the lobby to the lobby's public room (id_public)
func BroadcastLobby(lobby *Lobby) {
room := strconv.FormatUint(uint64(lobby.ID), 10)
broadcaster.SendMessageToRoom(fmt.Sprintf("%s_public", room), "lobbyData", DecorateLobbyData(lobby, true))
}
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)
})
}
func BroadcastSubList() {
allSubs := GetSubList()
bytes, _ := json.Marshal(allSubs)
broadcaster.SendMessageToRoom("0_public", "subListData", string(bytes))
}