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 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 removePlayerFromLobby(lobbyId uint, steamId string) (*models.Lobby, *models.Player, *helpers.TPError) {
player, tperr := models.GetPlayerBySteamId(steamId)
if tperr != nil {
return nil, nil, tperr
}
lob, tperr := models.GetLobbyById(lobbyId)
if tperr != nil {
return nil, nil, tperr
}
switch lob.State {
case models.LobbyStateInProgress:
return lob, player, helpers.NewTPError("Lobby is in progress.", 1)
case models.LobbyStateEnded:
return lob, player, helpers.NewTPError("Lobby has closed.", 1)
}
_, err := lob.GetPlayerSlot(player)
if err != nil {
return lob, player, helpers.NewTPError("Player not playing", 2)
}
if err := lob.RemovePlayer(player); err != nil {
return lob, player, err
}
return lob, player, lob.AddSpectator(player)
}
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 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) 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 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 (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 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 TestPlayerBanning(t *testing.T) {
testhelpers.CleanupDB()
player, _ := models.NewPlayer("76561197999073985")
player.Save()
assert.False(t, player.IsBanned(models.PlayerBanJoin))
assert.False(t, player.IsBanned(models.PlayerBanCreate))
assert.False(t, player.IsBanned(models.PlayerBanChat))
assert.False(t, player.IsBanned(models.PlayerBanFull))
past := time.Now().Add(time.Second * -10)
player.BanUntil(past, models.PlayerBanJoin, "they suck")
assert.False(t, player.IsBanned(models.PlayerBanJoin))
future := time.Now().Add(time.Second * 10)
player.BanUntil(future, models.PlayerBanJoin, "they suck")
player.BanUntil(future, models.PlayerBanFull, "they suck")
player2, _ := models.GetPlayerBySteamId(player.SteamId)
assert.False(t, player2.IsBanned(models.PlayerBanCreate))
assert.False(t, player2.IsBanned(models.PlayerBanChat))
isBannedFull, untilFull := player2.IsBannedWithTime(models.PlayerBanFull)
assert.True(t, isBannedFull)
assert.True(t, future.Sub(untilFull) < time.Second)
assert.True(t, untilFull.Sub(future) < time.Second)
log.Println(future.Sub(untilFull))
isBannedJoin, untilJoin := player2.IsBannedWithTime(models.PlayerBanJoin)
assert.True(t, isBannedJoin)
assert.True(t, future.Sub(untilJoin) < time.Second)
assert.True(t, untilJoin.Sub(future) < time.Second)
future2 := time.Now().Add(time.Second * 20)
player2.BanUntil(future2, models.PlayerBanJoin, "they suck")
isBannedJoin2, untilJoin2 := player2.IsBannedWithTime(models.PlayerBanJoin)
assert.True(t, isBannedJoin2)
assert.True(t, future2.Sub(untilJoin2) < time.Second)
assert.True(t, untilJoin.Sub(future2) < time.Second)
bans, err := player2.GetActiveBans()
assert.Nil(t, err)
assert.Equal(t, 3, len(bans))
player2.Unban(models.PlayerBanJoin)
player2.Unban(models.PlayerBanFull)
assert.False(t, player2.IsBanned(models.PlayerBanJoin))
assert.False(t, player2.IsBanned(models.PlayerBanCreate))
assert.False(t, player2.IsBanned(models.PlayerBanChat))
assert.False(t, player2.IsBanned(models.PlayerBanFull))
}
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 playerCanKick(lobbyId uint, steamId string) (bool, *helpers.TPError) {
lob, tperr := models.GetLobbyById(lobbyId)
if tperr != nil {
return false, tperr
}
player, tperr2 := models.GetPlayerBySteamId(steamId)
if tperr2 != nil {
return false, tperr2
}
if steamId != lob.CreatedBySteamID && player.Role != helpers.RoleAdmin {
return false, helpers.NewTPError("Not authorized to kick players", 1)
}
return true, nil
}
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 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 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 (Admin) AdminChangeRole(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"`
Role *string `json:"role"`
}
err := chelpers.GetParams(data, &args)
if err != nil {
return helpers.NewTPErrorFromError(err).Encode()
}
role, ok := helpers.RoleMap[*args.Role]
if !ok || role == helpers.RoleAdmin {
return helpers.NewTPError("Invalid role parameter", 0).Encode()
}
otherPlayer, err := models.GetPlayerBySteamId(*args.Steamid)
if err != nil {
return helpers.NewTPError("Player not found.", 0).Encode()
}
currPlayer, _ := chelpers.GetPlayerSocket(so.Id())
models.LogAdminAction(currPlayer.ID, helpers.ActionChangeRole, otherPlayer.ID)
// actual change happens
otherPlayer.Role = role
db.DB.Save(&otherPlayer)
// rewrite session data. THIS WON'T WRITE A COOKIE SO IT ONLY WORKS WITH
// STORES THAT STORE DATA IN COOKIES (AND NOT ONLY SESSION ID).
session, sesserr := chelpers.GetSessionHTTP(so.Request())
if sesserr == nil {
session.Values["role"] = role
session.Save(so.Request(), FakeResponseWriter{})
}
return chelpers.EmptySuccessJS
}
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) 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 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 (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 LobbySpectatorJoin(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, lobbySpectatorJoinFilters,
func(params map[string]interface{}) string {
lobbyid := params["id"].(uint)
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
var lob *models.Lobby
lob, tperr = models.GetLobbyById(uint(lobbyid))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
if id, _ := player.GetLobbyId(); id != lobbyid {
helpers.LockRecord(lob.ID, lob)
tperr = lob.AddSpectator(player)
helpers.UnlockRecord(lob.ID, lob)
}
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
chelpers.AfterLobbySpec(so, lob)
models.BroadcastLobbyToUser(lob, player.SteamId)
return string(bytes)
})
}
func AdminChangeRole(so socketio.Socket) func(string) string {
return chelpers.FilterRequest(so, adminChangeRoleFilter,
func(params map[string]interface{}) string {
roleString := params["role"].(string)
steamid := params["steamid"].(string)
role, ok := helpers.RoleMap[roleString]
if !ok || role == helpers.RoleAdmin {
bytes, _ := chelpers.BuildFailureJSON("Invalid role parameter", 0).Encode()
return string(bytes)
}
otherPlayer, err := models.GetPlayerBySteamId(steamid)
if err != nil {
bytes, _ := chelpers.BuildFailureJSON("Player not found.", 0).Encode()
return string(bytes)
}
currPlayer, _ := chelpers.GetPlayerSocket(so.Id())
models.LogAdminAction(currPlayer.ID, helpers.ActionChangeRole, otherPlayer.ID)
// actual change happens
otherPlayer.Role = role
db.DB.Save(&otherPlayer)
// rewrite session data. THiS WON'T WRITE A COOKIE SO IT ONLY WORKS WITH
// STORES THAT STORE DATA IN COOKIES (AND NOT ONLY SESSION ID).
session, sesserr := chelpers.GetSessionHTTP(so.Request())
if sesserr == nil {
session.Values["role"] = role
session.Save(so.Request(), FakeResponseWriter{})
}
return chelpers.BuildEmptySuccessString()
})
}
func (Player) PlayerNotReady(_ *wsevent.Server, so *wsevent.Client, data []byte) []byte {
reqerr := chelpers.FilterRequest(so, authority.AuthAction(0), true)
if reqerr != nil {
return reqerr.Encode()
}
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
return tperr.Encode()
}
lobbyid, tperr := player.GetLobbyId()
if tperr != nil {
return tperr.Encode()
}
lobby, tperr := models.GetLobbyById(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.UnreadyPlayer(player)
lobby.RemovePlayer(player)
if tperr != nil {
return tperr.Encode()
}
lobby.UnreadyAllPlayers()
return chelpers.EmptySuccessJS
}
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 SocketInit(so socketio.Socket) {
chelpers.AuthenticateSocket(so.Id(), so.Request())
if chelpers.IsLoggedInSocket(so.Id()) {
steamid := chelpers.GetSteamId(so.Id())
SteamIdSocketMap[steamid] = &so
}
so.On("disconnection", func() {
chelpers.DeauthenticateSocket(so.Id())
if chelpers.IsLoggedInSocket(so.Id()) {
steamid := chelpers.GetSteamId(so.Id())
delete(SteamIdSocketMap, steamid)
}
helpers.Logger.Debug("on disconnect")
})
so.On("authenticationTest", chelpers.AuthFilter(so.Id(), func(val string) string {
return "authenticated"
}))
helpers.Logger.Debug("on connection")
so.Join("-1") //room for global chat
if chelpers.IsLoggedInSocket(so.Id()) {
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()))
return
}
lobbyid, err := player.GetLobbyId()
if err != nil {
so.Join(strconv.FormatUint(uint64(lobbyid), 10))
}
}
var lobbyCreateParams = map[string]chelpers.Param{
"mapName": chelpers.Param{Type: chelpers.PTypeString},
"type": chelpers.Param{Type: chelpers.PTypeString},
"server": chelpers.Param{Type: chelpers.PTypeString},
"rconpwd": chelpers.Param{Type: chelpers.PTypeString},
"whitelist": chelpers.Param{Type: chelpers.PTypeInt},
"mumbleRequired": chelpers.Param{Type: chelpers.PTypeBool},
}
so.On("lobbyCreate", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(lobbyCreateParams, func(js *simplejson.Json) string {
player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
mapName, _ := js.Get("mapName").String()
lobbytypestring, _ := js.Get("type").String()
server, _ := js.Get("server").String()
rconPwd, _ := js.Get("rconpwd").String()
whitelist, err := js.Get("whitelist").Int()
var playermap = map[string]models.LobbyType{
"sixes": models.LobbyTypeSixes,
"highlander": models.LobbyTypeHighlander,
}
lobbytype, ok := playermap[lobbytypestring]
if !ok {
bytes, _ := chelpers.BuildFailureJSON("Lobby type invalid.", -1).Encode()
return string(bytes)
}
//mumble, _ := js.Get("mumbleRequired").Bool()
//TODO: Configure server here
//TODO what if playermap[lobbytype] is nil?
lob := models.NewLobby(mapName, lobbytype,
models.ServerRecord{Host: server, RconPassword: rconPwd}, whitelist)
lob.CreatedBy = *player
err = lob.Save()
if err != nil {
bytes, _ := err.(*helpers.TPError).ErrorJSON().Encode()
return string(bytes)
}
// setup server info
go func() {
err := lob.TrySettingUp()
if err != nil {
SendMessage(chelpers.GetSteamId(so.Id()), "sendNotification", err.Error())
} else {
// for debug
SendMessage(chelpers.GetSteamId(so.Id()), "sendNotification", fmt.Sprintf("Lobby %d created successfully", lob.ID))
}
}()
lobby_id := simplejson.New()
lobby_id.Set("id", lob.ID)
bytes, _ := chelpers.BuildSuccessJSON(lobby_id).Encode()
return string(bytes)
})))
var lobbyCloseParams = map[string]chelpers.Param{
"id": chelpers.Param{Type: chelpers.PTypeInt},
}
so.On("lobbyClose", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(lobbyCloseParams, func(js *simplejson.Json) string {
player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
lobbyid, _ := js.Get("id").Uint64()
lob, tperr := models.GetLobbyById(uint(lobbyid))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
if player.ID != lob.CreatedByID {
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)
}
lob.Close()
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
})))
var lobbyJoinParams = map[string]chelpers.Param{
"id": chelpers.Param{Type: chelpers.PTypeInt},
"class": chelpers.Param{Type: chelpers.PTypeString},
"team": chelpers.Param{Type: chelpers.PTypeString},
}
so.On("lobbyJoin", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(lobbyJoinParams, func(js *simplejson.Json) string {
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
lobbyid, _ := js.Get("id").Uint64()
classString, _ := js.Get("class").String()
teamString, _ := js.Get("team").String()
lob, tperr := models.GetLobbyById(uint(lobbyid))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
slot, tperr := chelpers.GetPlayerSlot(lob.Type, teamString, classString)
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
tperr = lob.AddPlayer(player, slot)
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
so.Join(strconv.FormatUint(lobbyid, 10))
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
})))
var lobbyRemovePlayerParams = map[string]chelpers.Param{
"id": chelpers.Param{Type: chelpers.PTypeInt},
"steamid": chelpers.Param{Type: chelpers.PTypeString, Default: ""},
"ban": chelpers.Param{Type: chelpers.PTypeBool, Default: false},
}
so.On("lobbyRemovePlayer", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(lobbyRemovePlayerParams, func(js *simplejson.Json) string {
steamid, _ := js.Get("steamid").String()
ban, _ := js.Get("ban").Bool()
lobbyid, _ := js.Get("id").Int()
self := false
// TODO check authorization, currently can kick anyone
if steamid == "" || steamid == chelpers.GetSteamId(so.Id()) {
self = true
steamid = chelpers.GetSteamId(so.Id())
}
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 && lob.CreatedByID != player.ID {
// TODO proper authorization checks
bytes, _ := chelpers.BuildFailureJSON("Not authorized to remove players", 1).Encode()
return string(bytes)
}
_, err := lob.GetPlayerSlot(player)
if err == nil {
lob.RemovePlayer(player)
} else if player.IsSpectatingId(lob.ID) {
lob.RemoveSpectator(player)
} else {
bytes, _ := chelpers.BuildFailureJSON("Player neither playing nor spectating", 2).Encode()
return string(bytes)
}
if ban {
lob.BanPlayer(player)
}
so.Leave(strconv.FormatInt(int64(lobbyid), 10))
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
})))
so.On("playerReady", chelpers.AuthFilter(so.Id(), func(val string) 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)
}
tperr = lobby.ReadyPlayer(player)
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
if lobby.IsEveryoneReady() {
bytes, _ := decorators.GetLobbyConnectJSON(lobby).Encode()
SendMessageToRoom(strconv.FormatUint(uint64(lobby.ID), 10),
"lobbyStart", string(bytes))
}
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
}))
so.On("playerUnready", chelpers.AuthFilter(so.Id(), func(val string) 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)
}
tperr = lobby.UnreadyPlayer(player)
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(bytes)
}))
var lobbyJoinSpectatorParams = map[string]chelpers.Param{
"id": chelpers.Param{Type: chelpers.PTypeInt},
}
so.On("lobbySpectatorJoin", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(lobbyJoinSpectatorParams, func(js *simplejson.Json) string {
lobbyid, _ := js.Get("id").Uint64()
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
lob, tperr := models.GetLobbyById(uint(lobbyid))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
bytes, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
tperr = lob.AddSpectator(player)
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
lob.Save()
return string(bytes)
})))
var playerSettingsGetParams = map[string]chelpers.Param{
"key": chelpers.Param{Type: chelpers.PTypeString, Default: ""},
}
so.On("playerSettingsGet", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(playerSettingsGetParams, func(js *simplejson.Json) string {
player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
key, _ := js.Get("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 := decorators.GetPlayerSettingsJson(settings)
resp, _ := chelpers.BuildSuccessJSON(result).Encode()
return string(resp)
})))
var playerSettingsSetParams = map[string]chelpers.Param{
"key": chelpers.Param{Type: chelpers.PTypeString},
"value": chelpers.Param{Type: chelpers.PTypeString},
}
so.On("playerSettingsSet", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(playerSettingsSetParams, func(js *simplejson.Json) string {
player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
key, _ := js.Get("key").String()
value, _ := js.Get("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)
})))
var playerProfileParams = map[string]chelpers.Param{
"steamid": chelpers.Param{Type: chelpers.PTypeString, Default: ""},
}
so.On("playerProfile", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(playerProfileParams, func(js *simplejson.Json) string {
steamid, _ := js.Get("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 := decorators.GetPlayerProfileJson(player)
resp, _ := chelpers.BuildSuccessJSON(result).Encode()
return string(resp)
})))
var chatSendParams = map[string]chelpers.Param{
"message": chelpers.Param{Type: chelpers.PTypeString},
"room": chelpers.Param{Type: chelpers.PTypeInt},
}
so.On("chatSend", chelpers.AuthFilter(so.Id(),
chelpers.JsonVerifiedFilter(chatSendParams, func(js *simplejson.Json) string {
message, _ := js.Get("message").String()
room, _ := js.Get("room").Int()
player, tperr := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
}
//Check if player has either joined, or is spectating lobby
lobbyId, tperr := player.GetLobbyId()
if room > 0 {
// if room is a lobby room
if tperr != nil {
bytes, _ := tperr.ErrorJSON().Encode()
return string(bytes)
} else if lobbyId != uint(room) && !player.IsSpectatingId(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 = -1
}
t := time.Now()
chatMessage := simplejson.New()
// TODO send proper timestamps
chatMessage.Set("timestamp", strconv.Itoa(t.Hour())+strconv.Itoa(t.Minute()))
chatMessage.Set("message", html.EscapeString(message))
chatMessage.Set("room", room)
user := simplejson.New()
user.Set("id", player.SteamId)
user.Set("name", player.Name)
chatMessage.Set("user", user)
bytes, _ := chatMessage.Encode()
so.BroadcastTo(strconv.Itoa(room), "chatReceive", string(bytes))
resp, _ := chelpers.BuildSuccessJSON(simplejson.New()).Encode()
return string(resp)
})))
}
func (Lobby) LobbyCreate(_ *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 {
Map *string `json:"map"`
Type *string `json:"type" valid:"debug,6s,highlander,4v4,ultiduo,bball"`
League *string `json:"league" valid:"ugc,etf2l,esea,asiafortress,ozfortress"`
Server *string `json:"server"`
RconPwd *string `json:"rconpwd"`
WhitelistID *uint `json:"whitelistID"`
Mumble *bool `json:"mumbleRequired"`
}
err := chelpers.GetParams(data, &args)
if err != nil {
return helpers.NewTPErrorFromError(err).Encode()
}
player, _ := models.GetPlayerBySteamId(chelpers.GetSteamId(so.Id()))
var playermap = map[string]models.LobbyType{
"debug": models.LobbyTypeDebug,
"6s": models.LobbyTypeSixes,
"highlander": models.LobbyTypeHighlander,
"ultiduo": models.LobbyTypeUltiduo,
"bball": models.LobbyTypeBball,
"4v4": models.LobbyTypeFours,
}
lobbyType := playermap[*args.Type]
var count int
db.DB.Table("server_records").Where("host = ?", *args.Server).Count(&count)
if count != 0 {
return helpers.NewTPError("A lobby is already using this server.", -1).Encode()
}
randBytes := make([]byte, 6)
rand.Read(randBytes)
serverPwd := base64.URLEncoding.EncodeToString(randBytes)
//TODO what if playermap[lobbytype] is nil?
info := models.ServerRecord{
Host: *args.Server,
RconPassword: *args.RconPwd,
ServerPassword: serverPwd}
// err = models.VerifyInfo(info)
// if err != nil {
// bytes, _ := helpers.NewTPErrorFromError(err).Encode()
// return string(bytes)
// }
lob := models.NewLobby(*args.Map, lobbyType, *args.League, info, int(*args.WhitelistID), *args.Mumble)
lob.CreatedBySteamID = player.SteamId
lob.RegionCode, lob.RegionName = chelpers.GetRegion(*args.Server)
if (lob.RegionCode == "" || lob.RegionName == "") && config.Constants.GeoIP != "" {
return helpers.NewTPError("Couldn't find region server.", 1).Encode()
}
lob.Save()
err = lob.SetupServer()
if err != nil {
qerr := db.DB.Where("id = ?", lob.ID).Delete(&models.Lobby{}).Error
if qerr != nil {
helpers.Logger.Warning(qerr.Error())
}
db.DB.Delete(&lob.ServerInfo)
return helpers.NewTPErrorFromError(err).Encode()
}
lob.State = models.LobbyStateWaiting
lob.Save()
reply_str := struct {
ID uint `json:"id"`
}{lob.ID}
models.FumbleLobbyCreated(lob)
bytes, _ := chelpers.BuildSuccessJSON(reply_str).Encode()
return bytes
}
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 SocketInit(so socketio.Socket) {
chelpers.AuthenticateSocket(so.Id(), so.Request())
if chelpers.IsLoggedInSocket(so.Id()) {
steamid := chelpers.GetSteamId(so.Id())
broadcaster.SetSocket(steamid, so)
}
so.On("disconnection", func() {
chelpers.DeauthenticateSocket(so.Id())
if chelpers.IsLoggedInSocket(so.Id()) {
steamid := chelpers.GetSteamId(so.Id())
broadcaster.RemoveSocket(steamid)
}
helpers.Logger.Debug("on disconnect")
})
so.On("authenticationTest", chelpers.FilterRequest(so, chelpers.FilterParams{FilterLogin: true},
func(_ map[string]interface{}) string {
return "authenticated"
}))
helpers.Logger.Debug("on connection")
chelpers.AfterConnect(so)
loggedIn := chelpers.IsLoggedInSocket(so.Id())
if loggedIn {
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()))
return
}
chelpers.AfterConnectLoggedIn(so, player)
} else {
so.Emit("playerSettings", "{}")
so.Emit("playerProfile", "{}")
}
// LOBBY CREATE
so.On("lobbyCreate", handler.LobbyCreate(so))
so.On("serverVerify", handler.ServerVerify(so))
so.On("lobbyClose", handler.LobbyClose(so))
so.On("lobbyJoin", handler.LobbyJoin(so))
if loggedIn {
so.On("lobbySpectatorJoin", handler.LobbySpectatorJoin(so))
} else {
so.On("lobbySpectatorJoin", handler.LobbyNoLoginSpectatorJoin(so))
}
so.On("lobbyKick", handler.LobbyKick(so))
so.On("playerReady", handler.PlayerReady(so))
so.On("playerNotReady", handler.PlayerNotReady(so))
so.On("playerSettingsGet", handler.PlayerSettingsGet(so))
so.On("playerSettingsSet", handler.PlayerSettingsSet(so))
so.On("playerProfile", handler.PlayerProfile(so))
so.On("chatSend", handler.ChatSend(so))
so.On("adminChangeRole", handler.AdminChangeRole(so))
so.On("requestLobbyListData", handler.RequestLobbyListData(so))
//Debugging handlers
if config.Constants.ServerMockUp {
so.On("debugLobbyFill", handler.DebugLobbyFill(so))
so.On("debugLobbyReady", handler.DebugLobbyReady(so))
so.On("debugGetAllLobbies", handler.DebugRequestAllLobbies(so))
so.On("debugRequestLobbyStart", handler.DebugRequestLobbyStart(so))
}
so.Emit("socketInitialized", "")
}
