func AfterLobbyJoin(server *wsevent.Server, so *wsevent.Client, lobby *models.Lobby, player *models.Player) {
room := fmt.Sprintf("%s_private", GetLobbyRoom(lobby.ID))
server.AddClient(so, room)
bytes, _ := json.Marshal(models.DecorateLobbyData(lobby, false))
broadcaster.SendMessage(player.SteamId, "lobbyJoined", string(bytes))
}
//Not really broadcast, since it sends each client a different LobbyStart JSON
func BroadcastLobbyStart(lob *lobby.Lobby) {
for _, slot := range lob.GetAllSlots() {
player, _ := player.GetPlayerByID(slot.PlayerID)
connectInfo := lobby.DecorateLobbyConnect(lob, player, slot.Slot)
broadcaster.SendMessage(player.SteamID, "lobbyStart", connectInfo)
}
}
func AfterLobbyLeave(lobby *models.Lobby, player *models.Player) {
broadcaster.SendMessage(player.SteamID, "lobbyLeft", models.DecorateLobbyLeave(lobby))
sockets, _ := sessions.GetSockets(player.SteamID)
//player might have connected from multiple tabs, remove all of them from the room
for _, so := range sockets {
socket.AuthServer.RemoveClient(so, fmt.Sprintf("%s_private", GetLobbyRoom(lobby.ID)))
}
}
func AfterLobbyLeave(server *wsevent.Server, so *wsevent.Client, lobby *models.Lobby, player *models.Player) {
//pub := fmt.Sprintf("%s_public", GetLobbyRoom(lobby.ID))
// bytes, _ := json.Marshal(models.DecorateLobbyData(lobby, true))
// broadcaster.SendMessageToRoom(pub, "lobbyData", string(bytes))
bytes, _ := json.Marshal(models.DecorateLobbyLeave(lobby))
broadcaster.SendMessage(player.SteamId, "lobbyLeft", string(bytes))
server.RemoveClient(so.Id(), fmt.Sprintf("%s_private", GetLobbyRoom(lobby.ID)))
}
func AfterLobbyJoin(so *wsevent.Client, lobby *models.Lobby, player *models.Player) {
room := fmt.Sprintf("%s_private", GetLobbyRoom(lobby.ID))
//make all sockets join the private room, given the one the player joined the lobby on
//might close, so lobbyStart and lobbyReadyUp can be sent to other tabs
sockets, _ := sessions.GetSockets(player.SteamID)
for _, so := range sockets {
socket.AuthServer.AddClient(so, room)
}
broadcaster.SendMessage(player.SteamID, "lobbyJoined", models.DecorateLobbyData(lobby, false))
}
//Not really broadcast, since it sends each client a different LobbyStart JSON
func BroadcastLobbyStart(lobby *models.Lobby) {
var slots []*models.LobbySlot
db.DB.Table("lobby_slots").Where("lobby_id = ?", lobby.ID).Find(&slots)
for _, slot := range slots {
var player models.Player
db.DB.First(&player, slot.PlayerId)
bytes, _ := json.Marshal(models.DecorateLobbyConnect(lobby, player.Name, slot.Class))
broadcaster.SendMessage(player.SteamId, "lobbyStart", string(bytes))
}
}
//Not really broadcast, since it sends each client a different LobbyStart JSON
func BroadcastLobbyStart(lobby *models.Lobby) {
var slots []*models.LobbySlot
db.DB.Table("lobby_slots").Where("lobby_id = ?", lobby.ID).Find(&slots)
for _, slot := range slots {
var player models.Player
db.DB.First(&player, slot.PlayerID)
connectInfo := models.DecorateLobbyConnect(lobby, player.Name, slot.Slot)
broadcaster.SendMessage(player.SteamID, "lobbyStart", connectInfo)
}
}
func AfterConnectLoggedIn(so *wsevent.Client, player *models.Player) {
if time.Since(player.UpdatedAt) >= time.Hour*1 {
player.UpdatePlayerInfo()
player.Save()
}
lobbyID, err := player.GetLobbyID(false)
if err == nil {
lobby, _ := models.GetLobbyByIDServer(lobbyID)
AfterLobbyJoin(so, lobby, player)
AfterLobbySpec(socket.AuthServer, so, lobby)
models.BroadcastLobbyToUser(lobby, chelpers.GetSteamId(so.ID))
slot := &models.LobbySlot{}
err := db.DB.Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).First(slot).Error
if err == nil {
if lobby.State == models.LobbyStateInProgress {
broadcaster.SendMessage(player.SteamID, "lobbyStart", models.DecorateLobbyConnect(lobby, player.Name, slot.Slot))
} else if lobby.State == models.LobbyStateReadyingUp && !slot.Ready {
data := struct {
Timeout int64 `json:"timeout"`
}{lobby.ReadyUpTimeLeft()}
broadcaster.SendMessage(player.SteamID, "lobbyReadyUp", data)
}
}
}
settings, err2 := player.GetSettings()
if err2 == nil {
broadcaster.SendMessage(player.SteamID, "playerSettings", models.DecoratePlayerSettingsJson(settings))
}
profilePlayer, err3 := models.GetPlayerWithStats(player.SteamID)
if err3 == nil {
broadcaster.SendMessage(player.SteamID, "playerProfile", models.DecoratePlayerProfileJson(profilePlayer))
}
}
func AfterConnectLoggedIn(server *wsevent.Server, so *wsevent.Client, player *models.Player) {
lobbyIdPlaying, err := player.GetLobbyId()
if err == nil {
lobby, _ := models.GetLobbyByIdServer(lobbyIdPlaying)
AfterLobbyJoin(server, so, lobby, player)
AfterLobbySpec(server, so, lobby)
models.BroadcastLobbyToUser(lobby, GetSteamId(so.Id()))
slot := &models.LobbySlot{}
err := db.DB.Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).First(slot).Error
if err == nil {
if lobby.State == models.LobbyStateInProgress && !models.IsPlayerInServer(player.SteamId) {
bytes, _ := json.Marshal(models.DecorateLobbyConnect(lobby, player.Name, slot.Class))
broadcaster.SendMessage(player.SteamId, "lobbyStart", string(bytes))
} else if lobby.State == models.LobbyStateReadyingUp && !slot.Ready {
data := struct {
Timeout int64 `json:"timeout"`
}{lobby.ReadyUpTimeLeft()}
bytes, _ := json.Marshal(data)
broadcaster.SendMessage(player.SteamId, "lobbyReadyUp", string(bytes))
}
}
}
settings, err2 := player.GetSettings()
if err2 == nil {
bytes, _ := json.Marshal(models.DecoratePlayerSettingsJson(settings))
broadcaster.SendMessage(player.SteamId, "playerSettings", string(bytes))
}
profilePlayer, err3 := models.GetPlayerWithStats(player.SteamId)
if err3 == nil {
bytes, _ := json.Marshal(models.DecoratePlayerProfileJson(profilePlayer))
broadcaster.SendMessage(player.SteamId, "playerProfile", string(bytes))
}
}
func AfterConnectLoggedIn(so socketio.Socket, player *models.Player) {
lobbyIdPlaying, err := player.GetLobbyId()
if err == nil {
lobby, _ := models.GetLobbyById(lobbyIdPlaying)
AfterLobbyJoin(so, lobby, player)
AfterLobbySpec(so, lobby)
models.BroadcastLobbyToUser(lobby, GetSteamId(so.Id()))
slot := &models.LobbySlot{}
err := db.DB.Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).First(slot).Error
if err == nil {
if lobby.State == models.LobbyStateInProgress && !slot.InGame {
bytes, _ := models.DecorateLobbyConnectJSON(lobby).Encode()
broadcaster.SendMessage(player.SteamId, "lobbyStart", string(bytes))
} else if lobby.State == models.LobbyStateReadyingUp && !slot.Ready {
left := simplejson.New()
left.Set("timeout", lobby.ReadyUpTimeLeft())
bytes, _ := left.Encode()
broadcaster.SendMessage(player.SteamId, "lobbyReadyUp", string(bytes))
}
}
}
settings, err2 := player.GetSettings()
if err2 == nil {
json := models.DecoratePlayerSettingsJson(settings)
bytes, _ := json.Encode()
broadcaster.SendMessage(player.SteamId, "playerSettings", string(bytes))
}
profilePlayer, err3 := models.GetPlayerWithStats(player.SteamId)
if err3 == nil {
json := models.DecoratePlayerProfileJson(profilePlayer)
bytes, _ := json.Encode()
broadcaster.SendMessage(player.SteamId, "playerProfile", string(bytes))
}
}
func AfterLobbyLeave(lob *lobby.Lobby, player *player.Player, kicked bool, notReady bool) {
event := lobby.LobbyEvent{
ID: lob.ID,
Kicked: kicked,
NotReady: notReady,
}
broadcaster.SendMessage(player.SteamID, "lobbyLeft", event)
sockets, _ := sessions.GetSockets(player.SteamID)
//player might have connected from multiple tabs, remove all of them from the room
for _, so := range sockets {
socket.AuthServer.Leave(so, fmt.Sprintf("%s_private", GetLobbyRoom(lob.ID)))
}
}
func AfterLobbyJoin(so *wsevent.Client, lob *lobby.Lobby, player *player.Player) {
room := fmt.Sprintf("%s_private", GetLobbyRoom(lob.ID))
//make all sockets join the private room, given the one the player joined the lobby on
//might close, so lobbyStart and lobbyReadyUp can be sent to other tabs
sockets, _ := sessions.GetSockets(player.SteamID)
for _, so := range sockets {
socket.AuthServer.Join(so, room)
}
if lob.State == lobby.InProgress { // player is a substitute
lob.AfterPlayerNotInGameFunc(player, 5*time.Minute, func() {
// if player doesn't join game server in 5 minutes,
// substitute them
message := player.Alias() + " has been reported for not joining the game within 5 minutes"
chat.SendNotification(message, int(lob.ID))
lob.Substitute(player)
})
}
broadcaster.SendMessage(player.SteamID, "lobbyJoined", lobby.DecorateLobbyData(lob, false))
}
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 BroadcastLobbyToUser(lobby *Lobby, steamid string) {
db.DB.Preload("Spectators").First(&lobby, lobby.ID)
bytes, _ := DecorateLobbyDataJSON(lobby, true).Encode()
broadcaster.SendMessage(steamid, "lobbyData", string(bytes))
}
func BroadcastLobbyToUser(lobby *Lobby, steamid string) {
//db.DB.Preload("Spectators").First(&lobby, lobby.ID)
bytes, _ := json.Marshal(DecorateLobbyData(lobby, true))
broadcaster.SendMessage(steamid, "lobbyData", string(bytes))
}
func BroadcastLobbyToUser(lobby *Lobby, steamid string) {
bytes, _ := DecorateLobbyDataJSON(lobby, true).Encode()
broadcaster.SendMessage(steamid, "lobbyData", string(bytes))
}
func (l LobbyData) SendToPlayer(steamid string) {
broadcaster.SendMessage(steamid, "lobbyData", l)
}
//BroadcastLobbyToUser broadcasts the lobby to the a user with the given steamID
func BroadcastLobbyToUser(lobby *Lobby, steamid string) {
broadcaster.SendMessage(steamid, "lobbyData", DecorateLobbyData(lobby, true))
}
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 LobbyKick(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, lobbyKickFilters,
func(params map[string]interface{}) string {
steamid := params["steamid"].(string)
ban := params["ban"].(bool)
lobbyid := params["id"].(uint)
var self bool
selfSteamid := chelpers.GetSteamId(so.Id())
// TODO check authorization, currently can kick anyone
if steamid == "" {
self = true
steamid = selfSteamid
}
//player to kick
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 && selfSteamid != lob.CreatedBySteamID {
// TODO proper authorization checks
bytes, _ := chelpers.BuildFailureJSON(
"Not authorized to remove players", 1).Encode()
return string(bytes)
}
_, err := lob.GetPlayerSlot(player)
helpers.LockRecord(lob.ID, lob)
defer helpers.UnlockRecord(lob.ID, lob)
var spec bool
if err == nil {
lob.RemovePlayer(player)
} else if player.IsSpectatingId(lob.ID) {
spec = true
lob.RemoveSpectator(player)
} else {
bytes, _ := chelpers.BuildFailureJSON("Player neither playing nor spectating", 2).Encode()
return string(bytes)
}
if ban {
lob.BanPlayer(player)
}
if !spec {
chelpers.AfterLobbyLeave(so, lob, player)
} else {
chelpers.AfterLobbySpecLeave(so, lob)
}
if !self {
broadcaster.SendMessage(steamid, "sendNotification",
fmt.Sprintf("You have been removed from Lobby #%d", lobbyid))
}
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
})
}
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{}{})
}
}
}