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 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 (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 (Player) PlayerReady(so *wsevent.Client, _ struct{}) interface{} {
steamid := chelpers.GetSteamId(so.ID)
player, tperr := models.GetPlayerBySteamID(steamid)
if tperr != nil {
return tperr
}
lobbyid, tperr := player.GetLobbyID(false)
if tperr != nil {
return tperr
}
lobby, tperr := models.GetLobbyByIDServer(lobbyid)
if tperr != nil {
return tperr
}
if lobby.State != models.LobbyStateReadyingUp {
return helpers.NewTPError("Lobby hasn't been filled up yet.", 4)
}
tperr = lobby.ReadyPlayer(player)
if tperr != nil {
return tperr
}
if lobby.IsEveryoneReady() {
lobby.Start()
hooks.BroadcastLobbyStart(lobby)
models.BroadcastLobbyList()
}
return chelpers.EmptySuccessJS
}
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 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)
})
}