net.qc File Reference

#include "net.qh"
#include <server/command/cmd.qh>

Include dependency graph for net.qc:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	GameTypeVote_ReadOption (int i)
void	GameTypeVote_WriteOption (int i)
	Sends a single gametype vote option to the client.
void	MapVote_Init_Client (int sf)
void	MapVote_Init_Server ()
void	MapVote_ReadMask ()
void	MapVote_ReadOption (int i)
void	MapVote_ReadPlayerVote (entity voter)
bool	MapVote_SendEntity (entity this, entity to, int sf)
void	MapVote_Spawn ()
void	MapVote_TouchMask ()
void	MapVote_Winner (int mappos)
void	MapVote_WriteMask ()
void	MapVote_WriteOption (int i)
	Sends a single map vote option to the client.
void	MapVote_WritePicture (entity to, int id)
void	MapVote_WritePlayerVote (int index)
	NET_HANDLE (ENT_CLIENT_MAPVOTE, bool isNew)
	NET_HANDLE (TE_CSQC_PICTURE, bool isNew)

Variables
entity	mapvote_ent
float	spamtime

Function Documentation

GameTypeVote_ReadOption()

void GameTypeVote_ReadOption

(

int

i

)

Definition at line 118 of file net.qc.

{
    TC(int, i);
    mv_entries[i] = strzone(ReadString());
    mv_flags[i] = ReadByte();
    mv_suggester[i] = "";
 
    string basetype = "";
 
    if (mv_flags[i] & GTV_CUSTOM)
    {
        string name = ReadString();
        if (strlen(name) < 1)
            name = mv_entries[i];
        mv_data[i] = strzone(name);
        mv_desc[i] = strzone(ReadString());
        basetype = strzone(ReadString());
    }
    else
    {
        Gametype type = MapInfo_Type_FromString(mv_entries[i], false, false);
        mv_data[i] = strzone(MapInfo_Type_ToText(type));
        mv_desc[i] = MapInfo_Type_Description(type);
    }
 
    string mv_picpath = sprintf("gfx/menu/%s/gametype_%s", autocvar_menu_skin, mv_entries[i]);
    if (precache_pic(mv_picpath) == "")
    {
        mv_picpath = strcat("gfx/menu/wickedx/gametype_", mv_entries[i]);
        if (precache_pic(mv_picpath) == "")
        {
            mv_picpath = sprintf("gfx/menu/%s/gametype_%s", autocvar_menu_skin, basetype);
            if (precache_pic(mv_picpath) == "")
                mv_picpath = strcat("gfx/menu/wickedx/gametype_", basetype);
        }
    }
    mv_pics[i] = strzone(mv_picpath);
    mv_preview[i] = PreviewExists(mv_pics[i]);
}

References autocvar_menu_skin, GTV_CUSTOM, MapInfo_Type_Description(), MapInfo_Type_FromString(), MapInfo_Type_ToText(), mv_data, mv_desc, mv_entries, mv_flags, mv_pics, mv_preview, mv_suggester, name, precache_pic(), PreviewExists(), ReadByte(), ReadString, strcat(), strlen, strzone(), and TC.

Referenced by MapVote_Init_Client().

GameTypeVote_WriteOption()

void GameTypeVote_WriteOption

(

int

i

)

Sends a single gametype vote option to the client.

Definition at line 105 of file net.qc.

{
    string type_name = mv_entries[i];
    WriteString(MSG_ENTITY, type_name);
    WriteByte(MSG_ENTITY, mv_flags[i]);
    if (mv_flags[i] & GTV_CUSTOM)
    {
        WriteString(MSG_ENTITY, cvar_string(strcat("sv_vote_gametype_", type_name, "_name")));
        WriteString(MSG_ENTITY, cvar_string(strcat("sv_vote_gametype_", type_name, "_description")));
        WriteString(MSG_ENTITY, cvar_string(strcat("sv_vote_gametype_", type_name, "_type")));
    }
}

References cvar_string(), GTV_CUSTOM, MSG_ENTITY, mv_entries, mv_flags, strcat(), WriteByte(), and WriteString().

Referenced by MapVote_Init_Server().

MapVote_Init_Client()

void MapVote_Init_Client

(

int

sf

)

Definition at line 194 of file net.qc.

{
    mv_active = true;
    if (!autocvar_hud_cursormode)
        mousepos = (eX * vid_conwidth + eY * vid_conheight) * 0.5;
    mv_selection = -1;
    mv_selection_keyboard = false;
 
    string s;
    int i;
    mv_ssdirs_count = ReadByte(); // will be < MAPVOTE_SSDIRS_COUNT
    for (i = 0; i < mv_ssdirs_count; ++i)
        mv_ssdirs[i] = ReadString();
 
    mv_count_real = mv_count = ReadByte(); // will be < MAPVOTE_COUNT
 
    mv_abstain = boolean(sf & SF_MV_ABSTAIN);
    if (mv_abstain)
        --mv_count_real;
    mv_detail = (sf & SF_MV_DETAIL_WINNER) ? 2 : ((sf & SF_MV_DETAIL_COUNTS) ? 1 : 0);
 
    mv_suggester_cache = "";
    mv_suggester_cachetime = 0;
 
    mv_ownvote = -1;
    mv_timeout = ReadFloat();
 
    int gametypevote_flags = ReadByte();
    gametypevote = (gametypevote_flags == SF_MV_GTV_NOW);
    if (gametypevote_flags != SF_MV_GTV_MAPS)
        mv_chosenmap = strzone(ReadString());
 
    MapVote_ReadMask();
    for (i = 0; i < mv_count; ++i)
        mv_flags_start[i] = mv_flags[i];
 
    // Assume mv_pk3list is NULL, there should only be 1 mapvote per round
    mv_pk3list = NULL; // I'm still paranoid!
 
    void(int) ReadOption = (gametypevote ? GameTypeVote_ReadOption : MapVote_ReadOption);
    for (i = 0; i < mv_count_real; ++i)
    {
        mv_votes[i] = 0;
        mv_select_lasttime[i] = 0;
        ReadOption(i);
    }
    if (mv_abstain)
        mv_entries[mv_count_real] = "";
 
    for (i = 0; i < mv_ssdirs_count; ++i)
        mv_ssdirs[mv_ssdirs_count] = string_null;
    mv_ssdirs_count = 0;
}

References autocvar_hud_cursormode, boolean, eX, eY, gametypevote, GameTypeVote_ReadOption(), MapVote_ReadMask(), MapVote_ReadOption(), mousepos, mv_abstain, mv_active, mv_chosenmap, mv_count, mv_count_real, mv_detail, mv_entries, mv_flags, mv_flags_start, mv_ownvote, mv_pk3list, mv_select_lasttime, mv_selection, mv_selection_keyboard, mv_ssdirs, mv_ssdirs_count, mv_suggester_cache, mv_suggester_cachetime, mv_timeout, mv_votes, NULL, ReadByte(), ReadFloat, ReadString, SF_MV_ABSTAIN, SF_MV_DETAIL_COUNTS, SF_MV_DETAIL_WINNER, SF_MV_GTV_MAPS, SF_MV_GTV_NOW, string_null, strzone(), vid_conheight, vid_conwidth, and void.

Referenced by NET_HANDLE().

MapVote_Init_Server()

void MapVote_Init_Server

(

)

Definition at line 160 of file net.qc.

{
    int i;
 
    WriteByte(MSG_ENTITY, mv_ssdirs_count);
    for (i = 0; i < mv_ssdirs_count; ++i)
        WriteString(MSG_ENTITY, mv_ssdirs[i]);
    WriteByte(MSG_ENTITY, mv_count);
    WriteFloat(MSG_ENTITY, mv_timeout);
 
    if (gametypevote)
    {
        WriteByte(MSG_ENTITY, SF_MV_GTV_NOW); // gametypevote_flags: gametype vote
        WriteString(MSG_ENTITY, get_nextmap());
    }
    else if (autocvar_sv_vote_gametype)
    {
        WriteByte(MSG_ENTITY, SF_MV_GTV_DONE); // gametypevote_flags: map vote but gametype has been chosen via voting screen
        string voted_gametype_name = (voted_gametype_string == MapInfo_Type_ToString(voted_gametype))
            ? MapInfo_Type_ToText(voted_gametype)
            : cvar_string(strcat("sv_vote_gametype_", voted_gametype_string, "_name"));
        WriteString(MSG_ENTITY, voted_gametype_name);
    }
    else
        WriteByte(MSG_ENTITY, SF_MV_GTV_MAPS); // gametypevote_flags: map vote
 
    MapVote_WriteMask();
 
    // Send data for the vote options
    void(int) WriteOption = (gametypevote ? GameTypeVote_WriteOption : MapVote_WriteOption);
    for (i = 0; i < mv_count_real; ++i)
        WriteOption(i);
}

References autocvar_sv_vote_gametype, cvar_string(), gametypevote, GameTypeVote_WriteOption(), get_nextmap, MapInfo_Type_ToString(), MapInfo_Type_ToText(), MapVote_WriteMask(), MapVote_WriteOption(), MSG_ENTITY, mv_count, mv_count_real, mv_ssdirs, mv_ssdirs_count, mv_timeout, SF_MV_GTV_DONE, SF_MV_GTV_MAPS, SF_MV_GTV_NOW, strcat(), void, voted_gametype, voted_gametype_string, WriteByte(), and WriteString().

Referenced by MapVote_SendEntity().

MapVote_ReadMask()

void MapVote_ReadMask

(

)

Definition at line 63 of file net.qc.

{
    int b, B, i;
    for (i = 0; i < mv_count_real; )
        for (B = ReadByte(), b = BIT(0); b < BIT(8) && i < mv_count_real; b <<= 1, ++i)
        {
            if (B & b)
                mv_flags[i] |= GTV_AVAILABLE;
            else
                mv_flags[i] &= ~GTV_AVAILABLE;
        }
    if (mv_abstain) // make abstain available
        mv_flags[mv_count_real] |= GTV_AVAILABLE;
}

References BIT, GTV_AVAILABLE, mv_abstain, mv_count_real, mv_flags, and ReadByte().

Referenced by MapVote_Init_Client(), and NET_HANDLE().

MapVote_ReadOption()

void MapVote_ReadOption

(

int

i

)

Definition at line 89 of file net.qc.

{
    TC(int, i);
    mv_entries[i] = strzone(ReadString());
    mv_data[i] = strzone(ReadString());
    mv_suggester[i] = strzone(ReadString());
    mv_flags[i] = GTV_AVAILABLE;
 
    mv_pics[i] = strzone(strcat(mv_ssdirs[ReadByte()], "/", mv_entries[i]));
    mv_preview[i] = false;
    MapVote_CheckPic(mv_pics[i], mv_data[i], i);
}

References GTV_AVAILABLE, MapVote_CheckPic(), mv_data, mv_entries, mv_flags, mv_pics, mv_preview, mv_ssdirs, mv_suggester, ReadByte(), ReadString, strcat(), strzone(), and TC.

Referenced by MapVote_Init_Client().

MapVote_ReadPlayerVote()

void MapVote_ReadPlayerVote

(

entity

voter

)

Definition at line 27 of file net.qc.

{
    // clear possibly invalid vote
    if (!(mv_flags[voter.mapvote - 1] & GTV_AVAILABLE))
        voter.mapvote = 0;
    // use impulse as new vote
    if (CS(voter).impulse >= 1 && CS(voter).impulse <= mv_count // valid impulse
    && (mv_flags[CS(voter).impulse - 1] & GTV_AVAILABLE) // map/gametype is available
    && !ClientCommand_antispam(voter, strcat("impulse ", itos(CS(voter).impulse)), spamtime, 0.5, 2)) // not spamming
    {
        voter.mapvote = CS(voter).impulse;
        mapvote_ent.SendFlags |= SF_MV_VOTES;
    }
    CS(voter).impulse = 0;
}

References ClientCommand_antispam(), CS(), entity(), GTV_AVAILABLE, impulse, itos, mapvote_ent, mv_count, mv_flags, SF_MV_VOTES, spamtime, and strcat().

Referenced by MapVote_Tick().

MapVote_SendEntity()

bool MapVote_SendEntity	(	entity	this,
		entity	to,
		int	sf )

Definition at line 250 of file net.qc.

{
    int i;
    if (!mv_winner_time)
        sf &= ~SF_MV_WINNER; // no winner yet
 
    // Pack some extra data into sf
    sf &= ~(SF_MV_ABSTAIN | SF_MV_DETAIL_COUNTS | SF_MV_DETAIL_WINNER);
    if (mv_abstain)
        sf |= SF_MV_ABSTAIN;
    if (mv_detail == 1)
        sf |= SF_MV_DETAIL_COUNTS;
    else if (mv_detail == 2)
        sf |= SF_MV_DETAIL_WINNER;
 
    WriteHeader(MSG_ENTITY, ENT_CLIENT_MAPVOTE);
    WriteByte(MSG_ENTITY, sf);
    if (sf & SF_MV_INIT)
        MapVote_Init_Server();
    else if (sf & SF_MV_MASK) // else if, since init already writes the mask
        MapVote_WriteMask();
 
    if (sf & SF_MV_VOTES)
    {
        if (mv_detail)
        {
            int i;
            for (i = 0; i < mv_count; ++i)
                if (mv_flags[i] & GTV_AVAILABLE)
                    WriteByte(MSG_ENTITY, mv_votes[i]);
 
            if (mv_detail == 2) // tell the client what the tie winner will be
                i = mv_ranked[0];
            else if (mv_votes[mv_ranked[0]] == 0) // no votes yet, don't draw a winner (-1)
                i = -1;
            else // figure out winners yourself (-2)
                i = -2;
            WriteByte(MSG_ENTITY, i + 2);
        }
 
        WriteByte(MSG_ENTITY, to.mapvote);
    }
 
    if (sf & SF_MV_WINNER)
        WriteByte(MSG_ENTITY, mv_winner + 1);
 
    return true;
}

References entity(), GTV_AVAILABLE, MapVote_Init_Server(), MapVote_WriteMask(), MSG_ENTITY, mv_abstain, mv_count, mv_detail, mv_flags, mv_ranked, mv_votes, mv_winner, mv_winner_time, SF_MV_ABSTAIN, SF_MV_DETAIL_COUNTS, SF_MV_DETAIL_WINNER, SF_MV_INIT, SF_MV_MASK, SF_MV_VOTES, SF_MV_WINNER, WriteByte(), and WriteHeader.

Referenced by MapVote_Spawn().

MapVote_Spawn()

void MapVote_Spawn

(

)

Definition at line 8 of file net.qc.

{
    Net_LinkEntity(mapvote_ent = new(mapvote_ent), false, 0, MapVote_SendEntity);
}

References mapvote_ent, MapVote_SendEntity(), and Net_LinkEntity().

Referenced by GameTypeVote_Start(), and MapVote_Init().

MapVote_TouchMask()

void MapVote_TouchMask

(

)

Definition at line 13 of file net.qc.

{
    mapvote_ent.SendFlags |= SF_MV_MASK;
}

References mapvote_ent, and SF_MV_MASK.

Referenced by MapVote_CheckRules_decide().

MapVote_Winner()

void MapVote_Winner

(

int

mappos

)

Definition at line 17 of file net.qc.

{
    mapvote_ent.SendFlags |= SF_MV_WINNER;
    mv_winner_time = time;
    mv_winner = mappos;
}

References mapvote_ent, mv_winner, mv_winner_time, SF_MV_WINNER, and time.

Referenced by MapVote_Finished().

MapVote_WriteMask()

void MapVote_WriteMask

(

)

Definition at line 51 of file net.qc.

{
    for (int b, B, i = 0; i < mv_count_real; )
    {
        B = 0;
        for (b = BIT(0); b < BIT(8) && i < mv_count_real; b <<= 1, ++i)
            if (mv_flags[i] & GTV_AVAILABLE)
                B |= b;
        WriteByte(MSG_ENTITY, B);
    }
}

References BIT, GTV_AVAILABLE, MSG_ENTITY, mv_count_real, mv_flags, and WriteByte().

Referenced by MapVote_Init_Server(), and MapVote_SendEntity().

MapVote_WriteOption()

void MapVote_WriteOption

(

int

i

)

Sends a single map vote option to the client.

Definition at line 81 of file net.qc.

{
    WriteString(MSG_ENTITY, mv_entries[i]);
    WriteString(MSG_ENTITY, mv_pakfile[i]);
    WriteString(MSG_ENTITY, mv_show_suggester ? mv_suggester[i] : "");
    WriteByte(MSG_ENTITY, mv_ssdir_i[i]);
}

References MSG_ENTITY, mv_entries, mv_pakfile, mv_show_suggester, mv_ssdir_i, mv_suggester, WriteByte(), and WriteString().

Referenced by MapVote_Init_Server().

MapVote_WritePicture()

void MapVote_WritePicture	(	entity	to,
		int	id )

Definition at line 342 of file net.qc.

{
    msg_entity = to;
    WriteHeader(MSG_ONE, TE_CSQC_PICTURE);
    WriteByte(MSG_ONE, id);
    WritePicture(MSG_ONE, strcat(mv_ssdirs[mv_ssdir_i[id]], "/", mv_entries[id]), 3072);
}

References entity(), msg_entity, MSG_ONE, mv_entries, mv_ssdir_i, mv_ssdirs, strcat(), WriteByte(), and WriteHeader.

Referenced by ClientCommand_mv_getpicture().

MapVote_WritePlayerVote()

void MapVote_WritePlayerVote

(

int

index

)

Definition at line 43 of file net.qc.

{
    TC(int, index);
    localcmd("\nimpulse ", itos(index + 1), "\n");
}

References itos, localcmd(), and TC.

Referenced by MapVote_InputEvent().

NET_HANDLE() [1/2]

NET_HANDLE	(	ENT_CLIENT_MAPVOTE	,
		bool	isNew )

Definition at line 299 of file net.qc.

{
    int sf = ReadByte();
 
    if (sf & SF_MV_INIT)
        MapVote_Init_Client(sf);
    else if (sf & SF_MV_MASK)
    {
        MapVote_ReadMask();
        mv_reduce_time = time;
    }
 
    if (sf & SF_MV_VOTES)
    {
        for (int i = 0; i < mv_count; ++i)
        {
            if (mv_flags[i] & GTV_AVAILABLE)
            {
                if (mv_detail)
                    mv_votes[i] = ReadByte();
                else
                    mv_votes[i] = 0;
            }
            else
                mv_votes[i] = -1;
        }
        if (mv_detail)
            mv_tie_winner = ReadByte() - 2;
 
        mv_ownvote = ReadByte() - 1;
    }
 
    if (sf & SF_MV_WINNER)
    {
        mv_winner = ReadByte();
        mv_winner_time = time;
    }
 
    return true;
}

References GTV_AVAILABLE, MapVote_Init_Client(), MapVote_ReadMask(), mv_count, mv_detail, mv_flags, mv_ownvote, mv_reduce_time, mv_tie_winner, mv_votes, mv_winner, mv_winner_time, ReadByte(), SF_MV_INIT, SF_MV_MASK, SF_MV_VOTES, SF_MV_WINNER, and time.

NET_HANDLE() [2/2]

NET_HANDLE	(	TE_CSQC_PICTURE	,
		bool	isNew )

Definition at line 350 of file net.qc.

{
    int type = ReadByte();
    mv_preview[type] = true;
    mv_pics[type] = strzone(ReadPicture());
    return true;
}

References mv_pics, mv_preview, ReadByte(), and strzone().

Variable Documentation

mapvote_ent

entity mapvote_ent

Definition at line 7 of file net.qc.

Referenced by MapVote_ReadPlayerVote(), MapVote_Spawn(), MapVote_TouchMask(), and MapVote_Winner().

spamtime

float spamtime

Definition at line 26 of file net.qc.

Referenced by MapVote_ReadPlayerVote().