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)

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. More...
entity	join_minigame (entity player, string game_id)
	Join an existing minigame session. More...
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. More...

Variables
entity	active_minigame
	For players: Minigame being played. More...
bool	autocvar_sv_minigames
bool	autocvar_sv_minigames_observer
entity	minigame_players
	For minigame sessions: list of players For minigame_player: client entity. More...
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 56 of file sv_minigames.qh.

Function Documentation

ClientCommand_minigame()

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

Definition at line 307 of file sv_minigames.qc.

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

{
    if ( !autocvar_sv_minigames )
    {
        sprint(caller,"Minigames are not enabled!\n");
        return;
    }

    if (request == CMD_REQUEST_COMMAND )
    {
        string minig_cmd = argv(1);
        if ( minig_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 == "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 == "list" )
        {
            FOREACH(Minigames, true, sprint(caller, it.netname, " (", it.message, ") ", "\n"));
            return;
        }
        else if ( minig_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 == "end" || minig_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 == "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");
}

Here is the call graph for this function:

end_minigame()

void end_minigame

(

entity

minigame_session

)

Definition at line 224 of file sv_minigames.qc.

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().

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

end_minigames()

void end_minigames

(

)

Definition at line 255 of file sv_minigames.qc.

References end_minigame(), and minigame_sessions.

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

Here is the call graph for this function:

invite_minigame()

string invite_minigame	(	entity	inviter,
		entity	player
	)

Invite a player to join in a minigame.

Returns

Error string

Definition at line 263 of file sv_minigames.qc.

References active_minigame, CS(), etof(), ftos(), GameLogEcho(), strcat(), and VerifyClientEntity().

Referenced by ClientCommand_minigame().

{
    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 ( 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 "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

join_minigame()

entity join_minigame	(	entity	player,
		string	game_id
	)

Join an existing minigame session.

Returns

minigame session entity

Definition at line 200 of file sv_minigames.qc.

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

Referenced by ClientCommand_minigame().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

minigame_CheckSend()

bool minigame_CheckSend	(	entity	this,
		entity	client
	)

Definition at line 118 of file sv_minigames.qc.

References entity(), NULL, and owner.

Referenced by minigame_addplayer(), and msle_spawn().

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

Here is the call graph for this function:

Here is the caller graph for this function:

minigame_find_player()

entity minigame_find_player

(

entity

client

)

Definition at line 283 of file sv_minigames.qc.

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

Referenced by ClientCommand_minigame(), and MinigameImpulse().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

minigame_SendEntity()

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

Definition at line 64 of file sv_minigames.qc.

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

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

{
    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;

}

Here is the call graph for this function:

Here is the caller graph for this function:

MinigameImpulse()

bool MinigameImpulse	(	entity	this,
		int	imp
	)

Definition at line 294 of file sv_minigames.qc.

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

Referenced by ImpulseCommands(), and ObserverOrSpectatorThink().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

part_minigame()

void part_minigame

(

entity

player

)

Definition at line 216 of file sv_minigames.qc.

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

Referenced by ClientCommand_minigame(), and ClientDisconnect().

{
    entity minig = CS(player).active_minigame;

    if ( minig && minig.classname == "minigame" )
        minigame_rmplayer(minig,player);
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_minigame()

entity start_minigame	(	entity	player,
		string	minigame
	)

Create a new minigame session.

Returns

minigame session entity

Definition at line 164 of file sv_minigames.qc.

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

Referenced by ClientCommand_minigame().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

active_minigame

entity active_minigame

For players: Minigame being played.

Definition at line 41 of file sv_minigames.qh.

autocvar_sv_minigames

bool autocvar_sv_minigames

Definition at line 3 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 4 of file sv_minigames.qh.

Referenced by minigame_addplayer().

minigame_players

entity minigame_players

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

Definition at line 45 of file sv_minigames.qh.

Referenced by minigame_SendEntity().

minigame_sessions

entity minigame_sessions

Definition at line 47 of file sv_minigames.qh.

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