sv_minigames.qc File Reference

#include "sv_minigames.qh"
#include <common/minigames/minigames.qh>
#include <server/gamelog.qh>

Include dependency graph for sv_minigames.qc:

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

Go to the source code of this file.

Macros
#define	FIELD(Flags, Type, Name)
#define	MINIGAME_CMD(cmd_id)
#define	MSLE(Name, Fields)

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.
int	minigame_addplayer (entity minigame_session, entity player)
bool	minigame_CheckSend (entity this, entity client)
entity	minigame_find_player (entity client)
void	minigame_resend (entity minigame)
void	minigame_rmplayer (entity minigame_session, entity player)
bool	minigame_SendEntity (entity this, entity to, int sf)
bool	MinigameImpulse (entity this, int imp)
void	part_minigame (entity player)
void	player_clear_minigame (entity player)
entity	start_minigame (entity player, string minigame)
	Create a new minigame session.

Macro Definition Documentation

FIELD

#define FIELD	(		Flags,
			Type,
			Name )

Value:

if ( sf & (Flags) ) Write##Type(MSG_ENTITY, this.Name);

Definition at line 56 of file sv_minigames.qc.

MINIGAME_CMD

#define MINIGAME_CMD

(

cmd_id

)

Value:

MINIGAME_COMMON_CMD[MINIGAME_COMMON_CMD_ID_##cmd_id]

Definition at line 308 of file sv_minigames.qc.

Referenced by ClientCommand_minigame().

MSLE

#define MSLE	(		Name,
			Fields )

Value:

    else if ( this.classname == #Name ) { \
        if ( sf & MINIG_SF_CREATE ) WriteString(MSG_ENTITY,this.owner.netname); \
        Fields }

Definition at line 57 of file sv_minigames.qc.

#define MSLE(Name,Fields) \
    else if ( this.classname == #Name ) { \
        if ( sf & MINIG_SF_CREATE ) WriteString(MSG_ENTITY,this.owner.netname); \
        Fields }

Function Documentation

ClientCommand_minigame()

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

Definition at line 310 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 224 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 255 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 263 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 200 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_addplayer()

int minigame_addplayer	(	entity	minigame_session,
		entity	player )

Definition at line 127 of file sv_minigames.qc.

{
    if ( CS(player).active_minigame )
    {
        if ( CS(player).active_minigame == minigame_session )
            return 0;
        minigame_rmplayer(CS(player).active_minigame,player);
    }
    entity player_pointer = new(minigame_player);
    int mgteam = minigame_session.minigame_event(minigame_session,"join",player,player_pointer);
 
    if ( mgteam )
    {
        player_pointer.owner = minigame_session;
        player_pointer.minigame_players = player;
        player_pointer.team = mgteam;
        player_pointer.list_next = minigame_session.minigame_players;
        minigame_session.minigame_players = player_pointer;
        CS(player).active_minigame = minigame_session;
        player.minigame_players = player_pointer;
        setcefc(player_pointer, minigame_CheckSend);
        Net_LinkEntity(player_pointer, false, 0, minigame_SendEntity);
 
        if ( !IS_OBSERVER(player) && autocvar_sv_minigames_observer )
            PutObserverInServer(player, true, true);
        if ( autocvar_sv_minigames_observer == 2 )
            Player_SetForcedTeamIndex(player, TEAM_FORCE_SPECTATOR);
 
        minigame_resend(minigame_session);
    }
    else { delete(player_pointer); }
    GameLogEcho(strcat(":minigame:join",(mgteam?"":"fail"),":",minigame_session.netname,":",
        ftos(etof(player)),":",player.netname));
 
    return mgteam;
}

References active_minigame, autocvar_sv_minigames_observer, CS(), entity(), etof, ftos(), GameLogEcho(), IS_OBSERVER, minigame_CheckSend(), minigame_resend(), minigame_rmplayer(), minigame_SendEntity(), Net_LinkEntity(), Player_SetForcedTeamIndex(), PutObserverInServer(), setcefc, strcat(), and TEAM_FORCE_SPECTATOR.

Referenced by join_minigame(), and start_minigame().

minigame_CheckSend()

bool minigame_CheckSend	(	entity	this,
		entity	client )

Definition at line 118 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 285 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_resend()

void minigame_resend

(

entity

minigame

)

Definition at line 108 of file sv_minigames.qc.

{
    minigame.SendFlags = MINIG_SF_ALL;
    entity e = NULL;
    while (( e = findentity(e,owner,minigame) ))
    {
        e.SendFlags = MINIG_SF_ALL;
    }
}

References entity(), findentity(), MINIG_SF_ALL, NULL, and owner.

Referenced by minigame_addplayer().

minigame_rmplayer()

void minigame_rmplayer	(	entity	minigame_session,
		entity	player )

Definition at line 17 of file sv_minigames.qc.

{
    entity e;
    entity p = minigame_session.minigame_players;
 
    if ( p.minigame_players == player )
    {
        if ( p.list_next == NULL )
        {
            end_minigame(minigame_session);
            return;
        }
        minigame_session.minigame_event(minigame_session,"part",player);
        GameLogEcho(strcat(":minigame:part:",minigame_session.netname,":",
            ftos(etof(player)),":",player.netname));
        minigame_session.minigame_players = p.list_next;
        delete( p );
        player_clear_minigame(player);
    }
    else
    {
        for ( e = p.list_next; e != NULL; e = e.list_next )
        {
            if ( e.minigame_players == player )
            {
                minigame_session.minigame_event(minigame_session,"part",player);
                GameLogEcho(strcat(":minigame:part:",minigame_session.netname,":",
                    ftos(etof(player)),":",player.netname));
                p.list_next = e.list_next;
                delete(e);
                player_clear_minigame(player);
                return;
            }
            p = e;
        }
    }
}

References end_minigame(), entity(), etof, ftos(), GameLogEcho(), NULL, player_clear_minigame(), and strcat().

Referenced by minigame_addplayer(), and part_minigame().

minigame_SendEntity()

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

Definition at line 64 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 296 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 216 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().

player_clear_minigame()

void player_clear_minigame

(

entity

player

)

Definition at line 6 of file sv_minigames.qc.

{
    CS(player).active_minigame = NULL;
    player.minigame_players = NULL;
    if ( IS_PLAYER(player) )
        set_movetype(player, MOVETYPE_WALK);
    else
        set_movetype(player, MOVETYPE_FLY_WORLDONLY);
    Player_SetForcedTeamIndex(player, TEAM_FORCE_DEFAULT);
}

References CS(), entity(), IS_PLAYER, MOVETYPE_FLY_WORLDONLY, MOVETYPE_WALK, NULL, Player_SetForcedTeamIndex(), set_movetype(), and TEAM_FORCE_DEFAULT.

Referenced by end_minigame(), and minigame_rmplayer().

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.

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