func IsAllowed(userid uint32, lobbyid uint, channelname string) (bool, string) { var lobbyType, slot int db.QueryRow("SELECT type FROM lobbies WHERE id = $1", lobbyid).Scan(&lobbyType) err := db.QueryRow("SELECT slot FROM lobby_slots WHERE player_id = $1 AND lobby_id = $2", userid, lobbyid).Scan(&slot) if err == sql.ErrNoRows { return false, "You're not in this lobby" } else if err != nil { log.Println(err) return false, "Internal fumble error" } if channelname[0] == 'L' { // channel name is "Lobby..." return true, "" } //channel name is either "RED" or "BLU" team, _, err := format.GetSlotTeamClass(format.Format(lobbyType), slot) if err != nil { log.Println(err) } if team != strings.ToLower(channelname) { return false, "You're in team " + strings.ToUpper(team) + ", not " + channelname } return true, "" }
func (player *Player) SetMumbleUsername(lobbyType format.Format, slot int) { _, class, _ := format.GetSlotTeamClass(lobbyType, slot) username := strings.ToUpper(class) + "_" alias := player.GetSetting("siteAlias") switch { case isClean(alias): username += strings.Replace(alias, " ", "_", -1) case isClean(player.Name): username += strings.Replace(player.Name, " ", "_", -1) case reSteamProfileID.MatchString(player.Profileurl): m := reSteamProfileID.FindStringSubmatch(player.Profileurl) username += m[1] default: username += player.SteamID } var count int db.DB.Model(&Player{}).Where("mumble_username = ? AND id <> ?", username, player.ID).Count(&count) for count != 0 { username += "_" db.DB.Model(&Player{}).Where("mumble_username = ? AND id <> ?", username, player.ID).Count(&count) } db.DB.Model(&Player{}).Where("id = ?", player.ID).UpdateColumn("mumble_username", username) }
func GetTeam(lobbyID uint, lobbyType format.Format, commID string) (team string) { var slot int err := db.QueryRow("SELECT lobby_slots.slot FROM lobby_slots INNER JOIN players ON lobby_slots.player_id = players.id WHERE lobby_slots.lobby_id = $1 AND players.steam_id = $2", lobbyID, commID).Scan(&slot) if err != nil { helpers.Logger.Error(err.Error()) } team, _, _ = format.GetSlotTeamClass(lobbyType, slot) return }
func GetCurrentLobby(userid uint32) (uint, string) { var lobbyID uint var slot int var lobbyFormat format.Format err := db.QueryRow("SELECT lobby_slots.lobby_id, lobby_slots.slot, lobbies.type FROM lobbies INNER JOIN lobby_slots ON lobbies.id = lobby_slots.lobby_id WHERE lobby_slots.player_id = $1 AND lobbies.state <> $2 AND lobbies.state <> $3", userid, lobby.Ended, lobby.Initializing).Scan(&lobbyID, &slot, &lobbyFormat) if err != nil && err != sql.ErrNoRows { // if err == ErrNoRows, player isn't in any active lobby log.Println(err) } team, _, _ := format.GetSlotTeamClass(lobbyFormat, slot) return lobbyID, team }
func DecorateLobbyConnect(lob *Lobby, player *player.Player, slot int) LobbyConnectData { l := LobbyConnectData{} l.ID = lob.ID l.Time = lob.CreatedAt.Unix() l.Pass = lob.ServerInfo.ServerPassword l.Game.Host = lob.ServerInfo.Host l.Mumble.Address = config.Constants.MumbleAddr l.Mumble.Password = player.MumbleAuthkey team, _, _ := format.GetSlotTeamClass(lob.Type, slot) l.Mumble.Channel = fmt.Sprintf("Lobby #%d/%s", lob.ID, strings.ToUpper(team)) if lob.Discord { if team == "red" { l.DiscordChannel = lob.DiscordRedChannel } else { l.DiscordChannel = lob.DiscordBluChannel } } return l }
func DecorateSubstitute(slot *LobbySlot) SubstituteData { lobby, _ := GetLobbyByID(slot.LobbyID) substitute := SubstituteData{ LobbyID: lobby.ID, Format: format.FriendlyNamesMap[lobby.Type], MapName: lobby.MapName, Mumble: lobby.Mumble, TwitchChannel: lobby.TwitchChannel, SteamGroup: lobby.PlayerWhitelist, RegionLock: lobby.RegionLock, } req, _ := lobby.GetSlotRequirement(slot.Slot) if req != nil { substitute.Password = req.Password != "" } substitute.Region.Name = lobby.RegionName substitute.Region.Code = lobby.RegionCode substitute.Team, substitute.Class, _ = format.GetSlotTeamClass(lobby.Type, slot.Slot) return substitute }
func (ps *PlayerStats) IncreaseClassCount(f format.Format, slot int) { _, class, _ := format.GetSlotTeamClass(f, slot) switch class { case "scout", "scout1", "scout2": ps.Scout++ case "roamer", "pocket", "soldier", "soldier1", "soldier2": ps.Soldier++ case "pyro": ps.Pyro++ case "engineer": ps.Engineer++ case "heavy": ps.Heavy++ case "demoman": ps.Demoman++ case "sniper": ps.Sniper++ case "medic": ps.Medic++ case "spy": ps.Spy++ } database.DB.Save(ps) }
//AddPlayer adds the given player to lobby, If the player occupies a slot in the lobby already, switch slots. //If the player is in another lobby, removes them from that lobby before adding them. func (lobby *Lobby) AddPlayer(p *player.Player, slot int, password string) error { /* Possible errors while joining * Slot has been filled * Player has already joined a lobby * anything else? */ //Check if player is banned if lobby.IsPlayerBanned(p) { return ErrLobbyBan } if slot >= 2*format.NumberOfClassesMap[lobby.Type] || slot < 0 { return ErrBadSlot } isSubstitution := lobby.SlotNeedsSubstitute(slot) //Check whether the slot is occupied if !isSubstitution && lobby.IsSlotOccupied(slot) { return ErrFilled } if lobby.HasSlotRequirement(slot) { //check if player fits the requirements for the slot if ok, err := lobby.FitsRequirements(p, slot); !ok { return err } req, _ := lobby.GetSlotRequirement(slot) if password != req.Password { return ErrInvalidPassword } } var slotChange bool //Check if the player is currently in another lobby if currLobbyID, err := p.GetLobbyID(false); err == nil { if currLobbyID != lobby.ID { //if the player is in a different lobby, remove them from that lobby //plus substitute them curLobby, _ := GetLobbyByID(currLobbyID) if curLobby.State == InProgress { curLobby.Substitute(p) } else { curLobby.Lock() db.DB.Where("player_id = ? AND lobby_id = ?", p.ID, curLobby.ID).Delete(&LobbySlot{}) curLobby.Unlock() } } else { //player is in the same lobby, they're changing their slots //assign the player to a new slot if isSubstitution { //the slot needs a substitute (which happens when the lobby is in progress), //so players already in the lobby cannot fill it. return ErrNeedsSub } lobby.Lock() db.DB.Where("player_id = ? AND lobby_id = ?", p.ID, lobby.ID).Delete(&LobbySlot{}) lobby.Unlock() slotChange = true } } if !slotChange { //check if the player is in the steam group whitelist url := fmt.Sprintf(`http://steamcommunity.com/groups/%s/memberslistxml/?xml=1`, lobby.PlayerWhitelist) if lobby.PlayerWhitelist != "" && !helpers.IsWhitelisted(p.SteamID, url) { return ErrNotWhitelisted } //check if player has been subbed to the twitch channel (if any) //allow channel owners if lobby.TwitchChannel != "" && p.TwitchName != lobby.TwitchChannel { //check if player has connected their twitch account if p.TwitchAccessToken == "" { return errors.New("You need to connect your Twitch Account first to join the lobby.") } if lobby.TwitchRestriction == TwitchSubscribers && !p.IsSubscribed(lobby.TwitchChannel) { return fmt.Errorf("You aren't subscribed to %s", lobby.TwitchChannel) } if lobby.TwitchRestriction == TwitchFollowers && !p.IsFollowing(lobby.TwitchChannel) { return fmt.Errorf("You aren't following %s", lobby.TwitchChannel) } } } // Check if player is a substitute (the slot needs a subtitute) if isSubstitution { //get previous slot, to kick them from game prevPlayerID, _ := lobby.GetPlayerIDBySlot(slot) prevPlayer, _ := player.GetPlayerByID(prevPlayerID) lobby.Lock() db.DB.Where("lobby_id = ? AND slot = ?", lobby.ID, slot).Delete(&LobbySlot{}) lobby.Unlock() go func() { //kicks previous slot occupant if they're in-game, resets their !rep count, removes them from the lobby rpc.DisallowPlayer(lobby.ID, prevPlayer.SteamID, prevPlayer.ID) BroadcastSubList() //since the sub slot has been deleted, broadcast the updated substitute list //notify players in game server of subtitute class, team, _ := format.GetSlotTeamClass(lobby.Type, slot) rpc.Say(lobby.ID, fmt.Sprintf("Substitute found for %s %s: %s (%s)", team, class, p.Name, p.SteamID)) }() //allow player in mumble } //try to remove them from spectators lobby.RemoveSpectator(p, true) newSlotObj := &LobbySlot{ PlayerID: p.ID, LobbyID: lobby.ID, Slot: slot, } lobby.Lock() db.DB.Create(newSlotObj) lobby.Unlock() if !slotChange { if p.TwitchName != "" { rpc.TwitchBotAnnouce(p.TwitchName, lobby.ID) } } lobby.OnChange(true) p.SetMumbleUsername(lobby.Type, slot) return nil }