intermission.qc

Go to the documentation of this file.

#include "intermission.qh"
 
#include <common/mapinfo.qh>
#include <common/mapvoting/_mod.qh>
#include <common/util.qh>
#include <server/bot/api.qh>
#include <server/bot/default/cvars.qh>
#include <server/campaign.qh>
#include <server/client.qh>
#include <server/scores_rules.qh>
#include <server/world.qh>
 
void Send_NextMap_To_Player(entity pl)
{
    stuffcmd(pl, sprintf("\nsettemp _nextmap %s\n", get_nextmap()));
}
 
void Set_NextMap(string mapname)
{
    if (mapname != "")
        strcpy(_nextmap, mapname);
    else
        strfree(_nextmap);
 
    FOREACH_CLIENT(IS_REAL_CLIENT(it), { Send_NextMap_To_Player(it); });
}
 
string GetGametype()
{
    return MapInfo_Type_ToString(MapInfo_LoadedGametype);
}
 
string GetMapname()
{
    return mapname;
}
 
int Map_Count, Map_Current;
 
// NOTE: this now expects the map list to be already tokenized and the count in Map_Count
int GetMaplistPosition()
{
    string map = GetMapname();
    int idx = autocvar_g_maplist_index;
 
    if(idx >= 0)
    {
        if(idx < Map_Count)
        {
            if(map == bufstr_get(maplist_buffer, idx))
            {
                return idx;
            }
        }
    }
 
    for(int pos = 0; pos < Map_Count; ++pos)
    {
        if(map == bufstr_get(maplist_buffer, pos))
            return pos;
    }
 
    // resume normal maplist rotation if current map is not in g_maplist
    return idx;
}
 
bool MapHasRightSize(string map)
{
    int minplayers = max(0, floor(autocvar_minplayers));
    if (teamplay)
        minplayers = max(0, floor(autocvar_minplayers_per_team) * AVAILABLE_TEAMS);
    if (autocvar_g_maplist_check_waypoints
        && (currentbots || autocvar_bot_number || player_count < minplayers))
    {
        string checkwp_msg = strcat("checkwp ", map);
        if(!fexists(strcat("maps/", map, ".waypoints")))
        {
            LOG_TRACE(checkwp_msg, ": no waypoints");
            return false;
        }
        LOG_TRACE(checkwp_msg, ": has waypoints");
    }
 
    if(autocvar_g_maplist_ignore_sizes)
        return true;
 
    // open map size restriction file (sets map_minplayers and map_maxplayers)
    if(!MapReadSizes(map))
        return true; // map has no size restrictions
 
    string checksize_msg = strcat("MapHasRightSize ", map);
    int pcount = player_count;
 
    if(!autocvar_g_maplist_sizes_count_bots)
        pcount -= currentbots;
    pcount -= rint(cvar("g_maplist_sizes_specparty") * pcount);
    if (autocvar_g_maplist_sizes_count_maxplayers)
        pcount = min(pcount, GetPlayerLimit()); // bind it to the player limit so that forced spectators don't influence the limits
 
    // ensure small maps can be selected when pcount is low
    if(map_minplayers <= (_MapInfo_GetTeamPlayBool(MapInfo_CurrentGametype()) ? 4 : 2))
        map_minplayers = 0;
 
    if(pcount < map_minplayers)
    {
        LOG_TRACE(checksize_msg, ": not enough");
        return false;
    }
    if(map_maxplayers && pcount > map_maxplayers)
    {
        LOG_TRACE(checksize_msg, ": too many");
        return false;
    }
    LOG_TRACE(checksize_msg, ": right size");
    return true;
}
 
string Map_Filename(string m)
{
    return strcat("maps/", m, ".bsp");
}
 
void Map_MarkAsRecent(string m)
{
    cvar_set("g_maplist_mostrecent", strwords(cons(m, autocvar_g_maplist_mostrecent), max(0, autocvar_g_maplist_mostrecent_count)));
}
 
bool Map_IsRecent(string m)
{
    if(autocvar_g_maplist_mostrecent == "")
        return false;
    return strhasword(autocvar_g_maplist_mostrecent, m);
}
 
bool Map_Check(string m, int pass)
{
    if(pass <= 1)
    {
        if(Map_IsRecent(m))
            return false;
    }
    if(MapInfo_CheckMap(m))
    {
        if(pass == 2)
            return true;
        // MapInfo_Map_flags was set by MapInfo_CheckMap()
        if (MapInfo_Map_flags & MAPINFO_FLAG_DONOTWANT)
            return false;
        if(MapHasRightSize(m))
            return true;
        return false;
    }
    else
    {
        string filename = Map_Filename(m);
        LOG_DEBUG( "Couldn't select '", filename, "'..." );
    }
 
    return false;
}
 
void Map_Goto_SetStr(string nextmapname)
{
    if(getmapname_stored != "")
        strunzone(getmapname_stored);
    if(nextmapname == "")
        getmapname_stored = "";
    else
        getmapname_stored = strzone(nextmapname);
}
 
void Map_Goto_SetIndex(int position)
{
    Map_Current = position;
    cvar_set("g_maplist_index", ftos(position));
    Map_Goto_SetStr(bufstr_get(maplist_buffer, position));
}
 
void Map_Goto(float reinit)
{
    MapInfo_LoadMap(getmapname_stored, reinit);
}
 
// return codes of map selectors:
//   -1 = temporary failure (that is, try some method that is guaranteed to succeed)
//   -2 = permanent failure
int MaplistMethod_Iterate(void) // usual method
{
    int attempts = 42; // skip advanced checks if this many maps fail
 
    LOG_TRACE("Trying MaplistMethod_Iterate");
 
    for(int i = 1; i < Map_Count; ++i)
    {
        int mapindex = (i + Map_Current) % Map_Count;
        if(Map_Check(bufstr_get(maplist_buffer, mapindex), 1))
            return mapindex;
 
        --attempts;
        if(attempts <= 0)
        {
            LOG_DEBUG("MaplistMethod_Iterate: Couldn't find a suitable map, falling back to next valid");
            break;
        }
    }
 
    // failing that, just accept the next map in the list
    int mapindex = (1 + Map_Current) % Map_Count;
    return mapindex;
}
 
int MaplistMethod_Repeat(void) // fallback method
{
    LOG_TRACE("Trying MaplistMethod_Repeat");
 
    if(Map_Check(bufstr_get(maplist_buffer, Map_Current), 2))
        return Map_Current;
    return -2;
}
 
int MaplistMethod_Random(void) // random map selection
{
    int i, imax;
 
    LOG_TRACE("Trying MaplistMethod_Random");
 
    imax = 42;
 
    for(i = 0; i <= imax; ++i)
    {
        int mapindex = (Map_Current + floor(random() * (Map_Count - 1) + 1)) % Map_Count; // any OTHER map
        if(Map_Check(bufstr_get(maplist_buffer, mapindex), 1))
            return mapindex;
    }
    return -1;
}
 
// NOTE: call Maplist_Close when you're done!
int Maplist_Init(void)
{
    bool have_maps = false;
    if(autocvar_g_maplist != "")
    {
        // make sure there is at least one playable map in the list
        bool needtrim = false;
        FOREACH_WORD(autocvar_g_maplist, true,
        {
            if(!fexists(Map_Filename(it)))
            {
                needtrim = true;
                if(have_maps)
                    break;
                continue;
            }
            if(have_maps || !Map_Check(it, 2))
                continue;
            have_maps = true;
            if(needtrim)
                break;
        });
 
        // additionally trim any non-existent maps
        if(needtrim)
        {
            int trimmedmaps = 0;
            string newmaplist = "";
            FOREACH_WORD(autocvar_g_maplist, true,
            {
                if(!fexists(Map_Filename(it)))
                {
                    ++trimmedmaps;
                    continue;
                }
                newmaplist = cons(newmaplist, it);
            });
            cvar_set("g_maplist", newmaplist);
            LOG_DEBUGF("Maplist_Init: trimmed %d missing maps from the list", trimmedmaps);
        }
    }
 
    if (!have_maps)
    {
        bprint( "Maplist contains no usable maps!  Resetting it to default map list.\n" );
        cvar_set("g_maplist", MapInfo_ListAllowedMaps(MapInfo_CurrentGametype(), MapInfo_RequiredFlags(), MapInfo_ForbiddenFlags()));
        if(!autocvar_sv_dedicated)
            localcmd("\nmenu_cmd sync\n");
    }
 
    maplist_buffer = buf_create();
 
    int _cnt = 0;
    FOREACH_WORD(autocvar_g_maplist, Map_Check(it, 2),
    {
        // NOTE: inlined maplist_shuffle function to avoid a second buffer, keep both in sync
        if(autocvar_g_maplist_shuffle)
        {
            int _j = floor(random() * (_cnt + 1));
            if(_j != _cnt)
                bufstr_set(maplist_buffer, _cnt, bufstr_get(maplist_buffer, _j));
            bufstr_set(maplist_buffer, _j, it);
            ++_cnt;
        }
        else
            bufstr_set(maplist_buffer, i, it);
    });
 
    Map_Count = buf_getsize(maplist_buffer);
 
    if(Map_Count == 0)
        error("empty maplist, cannot select a new map");
 
    Map_Current = bound(0, GetMaplistPosition(), Map_Count - 1);
 
    return Map_Count;
}
 
void Maplist_Close()
{
    buf_del(maplist_buffer);
}
 
// NOTE: call Maplist_Init() before making GetNextMap() call(s)
string GetNextMap(void)
{
    int nextMap = -1;
 
    if(nextMap == -1 && autocvar_g_maplist_selectrandom)
        nextMap = MaplistMethod_Random();
 
    if(nextMap == -1)
        nextMap = MaplistMethod_Iterate();
 
    if(nextMap == -1)
        nextMap = MaplistMethod_Repeat();
 
    if(nextMap >= 0)
    {
        Map_Goto_SetIndex(nextMap);
        return getmapname_stored;
    }
 
    return "";
}
 
float DoNextMapOverride(float reinit)
{
    if(autocvar_g_campaign)
    {
        CampaignPostIntermission();
        alreadychangedlevel = true;
        return true;
    }
    if(autocvar_quit_when_empty)
    {
        if(player_count <= currentbots)
        {
            localcmd("quit\n");
            alreadychangedlevel = true;
            return true;
        }
    }
    if(autocvar_quit_and_redirect != "")
    {
        redirection_target = strzone(autocvar_quit_and_redirect);
        alreadychangedlevel = true;
        return true;
    }
    if (!reinit && autocvar_samelevel) // if samelevel is set, stay on same level
    {
        localcmd("restart\n");
        alreadychangedlevel = true;
        return true;
    }
    if(get_nextmap() != "")
    {
        string m = GameTypeVote_MapInfo_FixName(get_nextmap());
        if (m != get_nextmap())
            Set_NextMap(m);
 
        if(!m || gametypevote)
            return false;
        if(autocvar_sv_vote_gametype)
        {
            Map_Goto_SetStr(m);
            return false;
        }
 
        if(MapInfo_CheckMap(m))
        {
            Map_Goto_SetStr(m);
            Map_Goto(reinit);
            alreadychangedlevel = true;
            return true;
        }
    }
    if(!reinit && autocvar_lastlevel)
    {
        cvar_settemp_restore();
        localcmd("set lastlevel 0\ntogglemenu 1\n");
        alreadychangedlevel = true;
        return true;
    }
    return false;
}
 
void GotoNextMap(float reinit)
{
    //string nextmap;
    //float n, nummaps;
    //string s;
    if (alreadychangedlevel)
        return;
    alreadychangedlevel = true;
 
    Maplist_Init();
    string nextMap = GetNextMap();
    Maplist_Close();
    if(nextMap == "")
        error("Everything is broken - cannot find a next map. Please report this to the developers.");
    Map_Goto(reinit);
}
 
string GotoMap(string m)
{
    m = GameTypeVote_MapInfo_FixName(m);
    if (!m)
        return "The map you suggested is not available on this server.";
    if (!autocvar_sv_vote_gametype)
    if (!MapInfo_CheckMap(m))
        return "The map you suggested does not support the current gametype.";
    if (m != get_nextmap())
        Set_NextMap(m);
    if (!intermission_running)
        cvar_set("_endmatch", "1");
    if (mapvote_initialized || alreadychangedlevel)
    {
        if(DoNextMapOverride(0))
            return "Map switch initiated.";
        else
            return "Hm... no. For some reason I like THIS map more.";
    }
    else
        return "Map switch will happen after scoreboard.";
}
 
 
/*
============
IntermissionThink
 
When the player presses attack or jump, change to the next level
============
*/
.float autoscreenshot;
void IntermissionThink(entity this)
{
    FixIntermissionClient(this);
 
    float server_screenshot = (autocvar_sv_autoscreenshot && CS_CVAR(this).cvar_cl_autoscreenshot);
    float client_screenshot = (CS_CVAR(this).cvar_cl_autoscreenshot == 2);
 
    if( (server_screenshot || client_screenshot)
        && ((this.autoscreenshot > 0) && (time > this.autoscreenshot)) )
    {
        this.autoscreenshot = -1;
        if(IS_REAL_CLIENT(this))
        {
            // in old clients "cl_autoscreenshot_screenshot_s %s %s;" takes the screenshot
            // "cl_autoscreenshot_screenshot %s %s;" does nothing because the cl_autoscreenshot_screenshot alias
            // doesn't exist; the cl_autoscreenshot_screenshot dummy cvar is created
            // so that "cl_autoscreenshot_screenshot %s %s" doesn't print any warning in console
 
            // in new clients "cl_autoscreenshot_screenshot %s %s;" takes the screenshot
            // even if the cl_autoscreenshot_screenshot cvar is created, only the cl_autoscreenshot_screenshot alias
            // is executed since only the alias is executed if a cvar with the same name exists
            // cl_autoscreenshot_screenshot_s is not run as cl_autoscreenshot_screenshot alias clears it
            // (it doesn't delete it so that "unalias cl_autoscreenshot_screenshot_s;" doesn't print any warning)
 
            // this stuffcmd is needed only for Xonotic 0.8.6 or lower
            // the s in cl_autoscreenshot_screenshot_s stands for server alias (alias name can't be longer than 32)
            stuffcmd(this, sprintf("\n"
                "alias cl_autoscreenshot_screenshot_s \"screenshot screenshots/autoscreenshot/%s-%s.jpg\";"
                "set cl_autoscreenshot_screenshot 0;", GetMapname(), matchid));
 
            // keep only this stuffcmd after the next release
            stuffcmd(this, sprintf("\ncl_autoscreenshot_screenshot %s %s;"
                "echo \"^5A screenshot has been taken at request of the server.\"\n", GetMapname(), matchid));
 
            // this stuffcmd is needed only for Xonotic 0.8.6 or lower
            stuffcmd(this, "\n"
                "cl_autoscreenshot_screenshot_s %s %s;"
                "unset cl_autoscreenshot_screenshot;"
                "unalias cl_autoscreenshot_screenshot_s;");
        }
        return;
    }
 
    if (time < intermission_exittime)
        return;
 
    if(!mapvote_initialized)
        if (time < intermission_exittime + 10 && !(PHYS_INPUT_BUTTON_ATCK(this) || PHYS_INPUT_BUTTON_JUMP(this) || PHYS_INPUT_BUTTON_ATCK2(this) || PHYS_INPUT_BUTTON_HOOK(this) || PHYS_INPUT_BUTTON_USE(this)))
            return;
 
    MapVote_Start();
}
 
void FixIntermissionClient(entity e)
{
    if(!e.autoscreenshot) // initial call
    {
        e.autoscreenshot = time + 0.1;
        SetResourceExplicit(e, RES_HEALTH, -2342); // health in the first intermission phase
        for (int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
        {
            .entity weaponentity = weaponentities[slot];
            if(e.(weaponentity))
            {
                e.(weaponentity).effects = EF_NODRAW;
                if (e.(weaponentity).weaponchild)
                    e.(weaponentity).weaponchild.effects = EF_NODRAW;
            }
        }
        if(IS_REAL_CLIENT(e))
        {
            stuffcmd(e, "\nscr_printspeed 1000000\n");
            RandomSelection_Init();
            FOREACH_WORD(autocvar_sv_intermission_cdtrack, true, {
                RandomSelection_AddString(it, 1, 1);
            });
            if (RandomSelection_chosen_string != "")
            {
                stuffcmd(e, sprintf("\ncd loop %s\n", RandomSelection_chosen_string));
            }
            msg_entity = e;
            WriteByte(MSG_ONE, SVC_INTERMISSION);
        }
    }
}