func TestNewSub(t *testing.T) {
testhelpers.CleanupDB()
lobby := testhelpers.CreateLobby()
lobby.Save()
player := testhelpers.CreatePlayer()
player.Save()
tperr := lobby.AddPlayer(player, 0, "red", "scout1")
assert.Nil(t, tperr)
sub, err := models.NewSub(lobby.ID, player.SteamId)
assert.Nil(t, err)
db.DB.Save(sub)
subs, err := models.GetPlayerSubs(player.SteamId)
assert.Nil(t, err)
assert.Equal(t, len(subs), 1)
assert.Equal(t, subs[0].LobbyID, lobby.ID)
player2 := testhelpers.CreatePlayer()
player2.Save()
tperr = lobby.AddPlayer(player2, 0, "red", "scout1")
assert.Nil(t, tperr)
err = db.DB.Where("lobby_id = ? AND steam_id = ?", lobby.ID, player.SteamId).First(sub).Error
assert.Nil(t, err)
assert.True(t, sub.Filled)
}
func DebugPlayerSub(server *wsevent.Server, so *wsevent.Client, data []byte) []byte {
reqerr := chelpers.FilterRequest(so, 0, true)
if reqerr != nil {
return reqerr.Encode()
}
var args struct {
Id *uint `json:"id"`
Team *string `json:"team"`
Class *string `json:"class"`
}
err := chelpers.GetParams(data, &args)
if err != nil {
return helpers.NewTPErrorFromError(err).Encode()
}
lob, tperr := models.GetLobbyById(*args.Id)
if tperr != nil {
return tperr.Encode()
}
s, tperr := models.LobbyGetPlayerSlot(lob.Type, *args.Team, *args.Class)
if tperr != nil {
return tperr.Encode()
}
slot := models.LobbySlot{}
err = db.DB.Where("slot = ?", s).First(&slot).Error
if err != nil {
helpers.Logger.Debug("", slot, s)
return helpers.NewTPErrorFromError(err).Encode()
}
player := models.Player{}
err = db.DB.First(&player, slot.PlayerId).Error
if err != nil {
helpers.Logger.Debug("", player)
return helpers.NewTPErrorFromError(err).Encode()
}
sub, _ := models.NewSub(*args.Id, player.SteamId)
db.DB.Save(sub)
models.BroadcastSubList()
return chelpers.EmptySuccessJS
}
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{}{})
}
}
}
}
