sv_minigames.qh File Reference

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

Go to the source code of this file.

Macros
#define	REGISTER_MINIGAME(name, nicename)

Enumerations
enum	{   MINIGAME_COMMON_CMD_ID_CREATE , MINIGAME_COMMON_CMD_ID_JOIN , MINIGAME_COMMON_CMD_ID_LIST , MINIGAME_COMMON_CMD_ID_LIST_SESSIONS ,   MINIGAME_COMMON_CMD_ID_END , MINIGAME_COMMON_CMD_ID_PART , MINIGAME_COMMON_CMD_ID_INVITE , MINIGAME_COMMON_CMD_COUNT }

Functions
void	ClientCommand_minigame (entity caller, int request, int argc, string command)
void	end_minigame (entity minigame_session)
void	end_minigames ()
string	invite_minigame (entity inviter, entity player)
	Invite a player to join in a minigame.
entity	join_minigame (entity player, string game_id)
	Join an existing minigame session.
bool	minigame_CheckSend (entity this, entity client)
entity	minigame_find_player (entity client)
bool	minigame_SendEntity (entity this, entity to, int sf)
bool	MinigameImpulse (entity this, int imp)
void	part_minigame (entity player)
entity	start_minigame (entity player, string minigame)
	Create a new minigame session.

Variables
entity	active_minigame
	For players: Minigame being played.
bool	autocvar_sv_minigames
bool	autocvar_sv_minigames_observer
string	MINIGAME_COMMON_CMD [MINIGAME_COMMON_CMD_COUNT]
entity	minigame_players
	For minigame sessions: list of players For minigame_player: client entity.
entity	minigame_sessions

Macro Definition Documentation

REGISTER_MINIGAME

#define REGISTER_MINIGAME	(		name,
			nicename )

Value:

REGISTER(Minigames, MINIGAME_##name, m_id, new_pure(minigame_descriptor)); \
int name##_server_event(entity, string, ...); \
REGISTER_INIT(MINIGAME_##name) { \
    this.netname = strzone(strtolower(#name)); \
    this.message = nicename; \
    this.minigame_event = name##_server_event; \
} \
REGISTER_INIT(MINIGAME_##name)

Definition at line 70 of file sv_minigames.qh.

#define REGISTER_MINIGAME(name,nicename) \
    REGISTER(Minigames, MINIGAME_##name, m_id, new_pure(minigame_descriptor)); \
    int name##_server_event(entity, string, ...); \
    REGISTER_INIT(MINIGAME_##name) { \
        this.netname = strzone(strtolower(#name)); \
        this.message = nicename; \
        this.minigame_event = name##_server_event; \
    } \
    REGISTER_INIT(MINIGAME_##name)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MINIGAME_COMMON_CMD_ID_CREATE
MINIGAME_COMMON_CMD_ID_JOIN
MINIGAME_COMMON_CMD_ID_LIST
MINIGAME_COMMON_CMD_ID_LIST_SESSIONS
MINIGAME_COMMON_CMD_ID_END
MINIGAME_COMMON_CMD_ID_PART
MINIGAME_COMMON_CMD_ID_INVITE
MINIGAME_COMMON_CMD_COUNT

Definition at line 3 of file sv_minigames.qh.

{
    MINIGAME_COMMON_CMD_ID_CREATE,
    MINIGAME_COMMON_CMD_ID_JOIN,
    MINIGAME_COMMON_CMD_ID_LIST,
    MINIGAME_COMMON_CMD_ID_LIST_SESSIONS,
    MINIGAME_COMMON_CMD_ID_END,
    MINIGAME_COMMON_CMD_ID_PART,
    MINIGAME_COMMON_CMD_ID_INVITE,
    MINIGAME_COMMON_CMD_COUNT
};

Function Documentation

ClientCommand_minigame()

void ClientCommand_minigame	(	entity	caller,
		int	request,
		int	argc,
		string	command )

Definition at line 316 of file sv_minigames.qc.

{
    if ( !autocvar_sv_minigames )
    {
        sprint(caller,"Minigames are not enabled!\n");
        return;
    }
 
    if (autocvar_g_playban_minigames && PlayerInList(caller, autocvar_g_playban_list)) // playban
    {
        Send_Notification(NOTIF_ONE_ONLY, caller, MSG_CENTER, CENTER_JOIN_PLAYBAN);
        sprint(caller, "You aren't allowed to play minigames because you are banned from them in this server.\n");
        return;
    }
 
    if (request == CMD_REQUEST_COMMAND )
    {
        string minig_cmd = argv(1);
        if ( minig_cmd == MINIGAME_CMD(CREATE) && argc > 2 )
        {
            entity minig = start_minigame(caller, argv(2));
            if ( minig )
                sprint(caller,"Created minigame session: ",minig.netname,"\n");
            else
                sprint(caller,"Cannot start minigame session!\n");
            return;
        }
        else if ( minig_cmd == MINIGAME_CMD(JOIN) && argc > 2 )
        {
            entity minig = join_minigame(caller, argv(2));
            if ( minig )
                sprint(caller,"Joined: ",minig.netname,"\n");
            else
            {
                Send_Notification(NOTIF_ONE, caller, MSG_CENTER, CENTER_JOIN_PREVENT_MINIGAME);
                sprint(caller,"Cannot join given minigame session!\n");
            }
            return;
        }
        else if ( minig_cmd == MINIGAME_CMD(LIST) )
        {
            FOREACH(Minigames, true, sprint(caller, it.netname, " (", it.message, ") ", "\n"));
            return;
        }
        else if ( minig_cmd == MINIGAME_CMD(LIST_SESSIONS) )
        {
            entity e;
            for ( e = minigame_sessions; e != NULL; e = e.list_next )
                sprint(caller,e.netname,"\n");
            return;
        }
        else if ( minig_cmd == MINIGAME_CMD(END) || minig_cmd == MINIGAME_CMD(PART) )
        {
            if ( CS(caller).active_minigame )
            {
                part_minigame(caller);
                sprint(caller,"Left minigame session\n");
            }
            else
                sprint(caller,"You aren't playing any minigame...\n");
            return;
        }
        else if ( minig_cmd == MINIGAME_CMD(INVITE) && argc > 2 )
        {
            if ( CS(caller).active_minigame )
            {
                entity client = GetIndexedEntity(argc, 2);
                string error = invite_minigame(caller,client);
                if ( error == "" )
                {
                    sprint(caller,"You have invited ",client.netname,
                        " to join your game of ", CS(caller).active_minigame.descriptor.message, "\n");
                }
                else
                    sprint(caller,"Could not invite: ", error, ".\n");
            }
            else
                sprint(caller,"You aren't playing any minigame...\n");
            return;
        }
        else if ( CS(caller).active_minigame )
        {
            entity e = minigame_find_player(caller);
            string subcommand = substring(command,argv_end_index(0),-1);
            int arg_c = tokenize_console(subcommand);
            if ( CS(caller).active_minigame.minigame_event(CS(caller).active_minigame,"cmd",e,arg_c,subcommand) )
                return;
 
        }
        else sprint(caller,strcat("Wrong command:^1 ",command,"\n"));
    }
 
    sprint(caller, "\nUsage:^3 cmd minigame create <minigame>\n");
    sprint(caller, "  Start a new minigame session\n");
    sprint(caller, "Usage:^3 cmd minigame join <session>\n");
    sprint(caller, "  Join an exising minigame session\n");
    sprint(caller, "Usage:^3 cmd minigame list\n");
    sprint(caller, "  List available minigames\n");
    sprint(caller, "Usage:^3 cmd minigame list-sessions\n");
    sprint(caller, "  List available minigames sessions\n");
    sprint(caller, "Usage:^3 cmd minigame part|end\n");
    sprint(caller, "  Leave the current minigame\n");
    sprint(caller, "Usage:^3 cmd minigame invite <player>\n");
    sprint(caller, "  Invite the given player to join you in a minigame\n");
}

References active_minigame, argv(), argv_end_index, autocvar_g_playban_list, autocvar_g_playban_minigames, autocvar_sv_minigames, CMD_REQUEST_COMMAND, CS(), entity(), error, FOREACH, GetIndexedEntity(), invite_minigame(), join_minigame(), MINIGAME_CMD, minigame_find_player(), minigame_sessions, NULL, part_minigame(), PlayerInList(), Send_Notification(), sprint(), start_minigame(), strcat(), substring(), and tokenize_console.

Referenced by CLIENT_COMMAND().

end_minigame()

void end_minigame

(

entity

minigame_session

)

Definition at line 230 of file sv_minigames.qc.

{
    if ( minigame_session.owner )
        minigame_session.owner.list_next = minigame_session.list_next;
    else
        minigame_sessions = minigame_session.list_next;
 
    minigame_session.minigame_event(minigame_session,"end");
    GameLogEcho(strcat(":minigame:end:",minigame_session.netname));
 
 
    entity e = NULL;
    while( (e = findentity(e, owner, minigame_session)) )
        if ( e.minigame_autoclean )
        {
            LOG_TRACE("SV Auto-cleaned: ",ftos(etof(e)), " (",e.classname,")");
            delete(e);
        }
 
    entity p;
    for ( e = minigame_session.minigame_players; e != NULL; e = p )
    {
        p = e.list_next;
        player_clear_minigame(e.minigame_players);
        delete(e);
    }
 
    strfree(minigame_session.netname);
    delete(minigame_session);
}

References entity(), etof, findentity(), ftos(), GameLogEcho(), LOG_TRACE, minigame_sessions, NULL, owner, player_clear_minigame(), strcat(), and strfree.

Referenced by end_minigames(), minigame_rmplayer(), and start_minigame().

end_minigames()

void end_minigames

(

)

Definition at line 261 of file sv_minigames.qc.

{
    while ( minigame_sessions )
    {
        end_minigame(minigame_sessions);
    }
}

References end_minigame(), and minigame_sessions.

invite_minigame()

string invite_minigame	(	entity	inviter,
		entity	player )

Invite a player to join in a minigame.

Returns

Error string

Definition at line 269 of file sv_minigames.qc.

{
    if ( !inviter || !CS(inviter).active_minigame )
        return "Invalid minigame";
    if ( VerifyClientEntity(player, true, false) <= 0 )
        return "Invalid player";
    if ( inviter == player )
        return "You can't invite yourself";
    if (autocvar_g_playban_minigames && PlayerInList(player, autocvar_g_playban_list)) // playban
        return "You can't invite a banned player";
    if ( CS(player).active_minigame == CS(inviter).active_minigame )
        return strcat(player.netname," is already playing");
 
    Send_Notification(NOTIF_ONE, player, MSG_INFO, INFO_MINIGAME_INVITE,
        CS(inviter).active_minigame.netname, inviter.netname );
 
    GameLogEcho(strcat(":minigame:invite:",CS(inviter).active_minigame.netname,":",
        ftos(etof(player)),":",player.netname));
 
    return "";
}

References active_minigame, autocvar_g_playban_list, autocvar_g_playban_minigames, CS(), entity(), etof, ftos(), GameLogEcho(), PlayerInList(), Send_Notification(), strcat(), and VerifyClientEntity().

Referenced by ClientCommand_minigame().

join_minigame()

entity join_minigame	(	entity	player,
		string	game_id )

Join an existing minigame session.

Returns

minigame session entity

Definition at line 206 of file sv_minigames.qc.

{
    if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
        return NULL;
 
    entity minig;
    for ( minig = minigame_sessions; minig != NULL; minig = minig.list_next )
    {
        if ( minig.netname == game_id )
        if ( minigame_addplayer(minig,player) )
            return minig;
    }
 
    return NULL;
}

References autocvar_sv_minigames, entity(), IS_REAL_CLIENT, minigame_addplayer(), minigame_sessions, and NULL.

Referenced by ClientCommand_minigame().

minigame_CheckSend()

bool minigame_CheckSend	(	entity	this,
		entity	client )

Definition at line 124 of file sv_minigames.qc.

{
    entity e;
    for ( e = this.owner.minigame_players; e != NULL; e = e.list_next )
        if ( e.minigame_players == client )
            return true;
    return false;
}

References entity(), NULL, and owner.

Referenced by minigame_addplayer(), and msle_spawn().

minigame_find_player()

entity minigame_find_player

(

entity

client

)

Definition at line 291 of file sv_minigames.qc.

{
    if ( ! CS(client).active_minigame )
        return NULL;
    entity e;
    for ( e = CS(client).active_minigame.minigame_players; e; e = e.list_next )
        if ( e.minigame_players == client )
            return e;
    return NULL;
}

References active_minigame, CS(), entity(), and NULL.

Referenced by ClientCommand_minigame(), and MinigameImpulse().

minigame_SendEntity()

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

Definition at line 70 of file sv_minigames.qc.

{
    WriteHeader(MSG_ENTITY, ENT_CLIENT_MINIGAME);
    WriteByte(MSG_ENTITY, sf);
 
    if ( sf & MINIG_SF_CREATE )
    {
        WriteShort(MSG_ENTITY,msle_id(this.classname));
        WriteString(MSG_ENTITY,this.netname);
    }
 
    entity minigame_ent = this.owner;
 
    if ( this.classname == "minigame" )
    {
        minigame_ent = this;
 
        if ( sf & MINIG_SF_CREATE )
            WriteString(MSG_ENTITY,this.descriptor.netname);
 
        if ( sf & MINIG_SF_UPDATE )
            WriteLong(MSG_ENTITY,this.minigame_flags);
    }
    else if ( this.classname == "minigame_player" )
    {
        if ( sf & MINIG_SF_CREATE )
        {
            WriteString(MSG_ENTITY,this.owner.netname);
            WriteLong(MSG_ENTITY,etof(this.minigame_players));
        }
        if ( sf & MINIG_SF_UPDATE )
            WriteByte(MSG_ENTITY,this.team);
    }
    MINIGAME_SIMPLELINKED_ENTITIES
 
    minigame_ent.minigame_event(minigame_ent,"network_send",this,sf);
 
    return true;
 
}

References classname, descriptor, entity(), etof, MINIG_SF_CREATE, MINIG_SF_UPDATE, minigame_flags, minigame_players, MINIGAME_SIMPLELINKED_ENTITIES, MSG_ENTITY, msle_id(), netname, owner, team, WriteByte(), WriteHeader, WriteLong(), WriteShort(), and WriteString().

Referenced by minigame_addplayer(), msle_spawn(), and start_minigame().

MinigameImpulse()

bool MinigameImpulse	(	entity	this,
		int	imp )

Definition at line 302 of file sv_minigames.qc.

{
    if (!CS(this).active_minigame) return false;
    entity e = minigame_find_player(this);
    if ( imp && CS(this).active_minigame && e )
    {
        return CS(this).active_minigame.minigame_event(CS(this).active_minigame,"impulse",e,imp);
    }
    return false;
}

References active_minigame, CS(), entity(), imp, and minigame_find_player().

Referenced by ImpulseCommands(), and ObserverOrSpectatorThink().

part_minigame()

void part_minigame

(

entity

player

)

Definition at line 222 of file sv_minigames.qc.

{
    entity minig = CS(player).active_minigame;
 
    if ( minig && minig.classname == "minigame" )
        minigame_rmplayer(minig,player);
}

References CS(), entity(), and minigame_rmplayer().

Referenced by BanCommand_playban(), ClientCommand_minigame(), and ClientDisconnect().

start_minigame()

entity start_minigame	(	entity	player,
		string	minigame )

Create a new minigame session.

Returns

minigame session entity

Definition at line 170 of file sv_minigames.qc.

{
    if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
        return NULL;
 
    entity e = minigame_get_descriptor(minigame);
    if ( e )
    {
        entity minig = new(minigame);
        minig.netname = strzone(strcat(e.netname,"_",ftos(etof(minig))));
        minig.descriptor = e;
        minig.minigame_event = e.minigame_event;
        minig.minigame_event(minig,"start");
        GameLogEcho(strcat(":minigame:start:",minig.netname));
        if ( ! minigame_addplayer(minig,player) )
        {
            LOG_TRACE("Minigame ",minig.netname," rejected the first player join!");
            end_minigame(minig);
            return NULL;
        }
        Net_LinkEntity(minig, false, 0, minigame_SendEntity);
 
        if ( !minigame_sessions )
            minigame_sessions = minig;
        else
        {
            minigame_sessions.owner = minig;
            minig.list_next = minigame_sessions;
            minigame_sessions = minig;
        }
        return minig;
    }
 
    return NULL;
}

References autocvar_sv_minigames, end_minigame(), entity(), etof, ftos(), GameLogEcho(), IS_REAL_CLIENT, LOG_TRACE, minigame_addplayer(), minigame_get_descriptor(), minigame_SendEntity(), minigame_sessions, Net_LinkEntity(), NULL, strcat(), and strzone().

Referenced by ClientCommand_minigame().

Variable Documentation

active_minigame

entity active_minigame

For players: Minigame being played.

Definition at line 55 of file sv_minigames.qh.

autocvar_sv_minigames

bool autocvar_sv_minigames

Definition at line 17 of file sv_minigames.qh.

Referenced by ClientCommand_minigame(), join_minigame(), and start_minigame().

autocvar_sv_minigames_observer

bool autocvar_sv_minigames_observer

Definition at line 18 of file sv_minigames.qh.

Referenced by minigame_addplayer().

MINIGAME_COMMON_CMD

string MINIGAME_COMMON_CMD[MINIGAME_COMMON_CMD_COUNT]

Initial value:

                       =
{"create", "join", "list", "list-sessions", "end", "part", "invite"}

Definition at line 14 of file sv_minigames.qh.

                                                        {"create", "join", "list", "list-sessions", "end", "part", "invite"};

Referenced by SV_ParseClientCommand().

minigame_players

entity minigame_players

For minigame sessions: list of players For minigame_player: client entity.

Definition at line 59 of file sv_minigames.qh.

Referenced by minigame_SendEntity().

minigame_sessions

entity minigame_sessions

Definition at line 61 of file sv_minigames.qh.

Referenced by ClientCommand_minigame(), end_minigame(), end_minigames(), join_minigame(), and start_minigame().