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) 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 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 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{}{})
}
}
}
}