diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -799,6 +799,7 @@ bots.cpp #ST browser.cpp #ST callvote.cpp #ST + callvotetype.cpp #ZA campaign.cpp #ST c_bind.cpp c_cmds.cpp diff --git a/src/callvote.cpp b/src/callvote.cpp --- a/src/callvote.cpp +++ b/src/callvote.cpp @@ -65,13 +65,20 @@ #include "sv_main.h" #include "v_video.h" #include "maprotation.h" +#include "deathmatch.h" +#include "duel.h" +#include "lastmanstanding.h" +#include "team.h" +#include "sv_ban.h" +#include "callvotetype.h" +#include "p_acs.h" #include //***************************************************************************** // VARIABLES static VOTESTATE_e g_VoteState; -static FString g_VoteCommand; +static FString g_VoteDisplay; static FString g_VoteReason; static ULONG g_ulVoteCaller; static ULONG g_ulVoteCountdownTicks = 0; @@ -83,6 +90,8 @@ static ULONG g_ulPlayersWhoVotedNo[(MAXPLAYERS / 2) + 1]; static NETADDRESS_s g_KickVoteVictimAddress; static std::list g_PreviousVotes; +static VoteStateData g_VoteStateData; +static FString g_CurrentVoteSummary; //***************************************************************************** // PROTOTYPES @@ -90,10 +99,8 @@ static void callvote_EndVote( void ); static ULONG callvote_CountPlayersWhoVotedYes( void ); static ULONG callvote_CountPlayersWhoVotedNo( void ); -static bool callvote_CheckForFlooding( FString &Command, FString &Parameters, ULONG ulPlayer ); -static bool callvote_CheckValidity( FString &Command, FString &Parameters ); -static ULONG callvote_GetVoteType( const char *pszCommand ); -static bool callvote_IsKickVote( const ULONG ulVoteType ); +static bool callvote_CheckForFlooding( ULONG& Command, FString& Parameters, ULONG ulPlayer ); +static void callvote_ExecuteVote( const VoteStateData& input ); //***************************************************************************** // FUNCTIONS @@ -150,27 +157,16 @@ g_PreviousVotes.back( ).bPassed = g_bVotePassed; // If the vote passed, execute the command string. - if (( g_bVotePassed ) && ( !g_bVoteCancelled ) && - ( NETWORK_GetState( ) != NETSTATE_CLIENT ) && - ( CLIENTDEMO_IsPlaying( ) == false )) + if (( g_bVotePassed ) + && ( g_bVoteCancelled == false ) + && ( NETWORK_InClientMode() == false )) { - // [BB, RC] If the vote is a kick vote, we have to rewrite g_VoteCommand to both use the stored IP, and temporarily ban it. - // [Dusk] Write the kick reason into the ban reason, [BB] but only if it's not empty. - // [BB] "forcespec" votes need a similar handling. - if ( ( strncmp( g_VoteCommand, "kick", 4 ) == 0 ) || ( strncmp( g_VoteCommand, "forcespec", 9 ) == 0 ) ) - { - if ( strncmp( g_VoteCommand, "kick", 4 ) == 0 ) - g_VoteCommand.Format( "addban %s 10min \"Vote kick", NETWORK_AddressToString( g_KickVoteVictimAddress ) ); - else - g_VoteCommand.Format( "kickfromgame_idx %d \"Vote forcespec", SERVER_FindClientByAddress ( g_KickVoteVictimAddress ) ); - g_VoteCommand.AppendFormat( ", %d to %d", static_cast(callvote_CountPlayersWhoVotedYes( )), static_cast(callvote_CountPlayersWhoVotedNo( )) ); - if ( g_VoteReason.IsNotEmpty() ) - g_VoteCommand.AppendFormat ( " (%s)", g_VoteReason.GetChars( ) ); - g_VoteCommand += ".\""; - } + VoteValidateResult output; + g_VoteStateData.yes = callvote_CountPlayersWhoVotedYes( ); + g_VoteStateData.no = callvote_CountPlayersWhoVotedNo( ); + callvote_ExecuteVote( g_VoteStateData ); + } - AddCommandString( (char *)g_VoteCommand.GetChars( )); - } // Reset the module. CALLVOTE_ClearVote( ); } @@ -181,8 +177,11 @@ //***************************************************************************** // -void CALLVOTE_BeginVote( FString Command, FString Parameters, FString Reason, ULONG ulPlayer ) +void CALLVOTE_BeginVote( ULONG Command, FString Parameters, FString Reason, ULONG ulPlayer ) { + VoteValidateResult validateResult; + VoteClass* votetype = VOTEDEF_FindTypeByIndex( Command ); + // Don't allow a vote in the middle of another vote. if ( g_VoteState != VOTESTATE_NOVOTE ) { @@ -191,47 +190,68 @@ return; } + g_VoteStateData.type = votetype; + g_VoteStateData.arg = Parameters; + g_VoteStateData.caller = SERVER_GetCurrentClient( ); + g_VoteStateData.yes = 0; + g_VoteStateData.no = 0; + g_VoteStateData.reason = Reason; + // Check and make sure all the parameters are valid. - if ( callvote_CheckValidity( Command, Parameters ) == false ) + if (( VOTEDEF_Validate( g_VoteStateData, validateResult ) == false ) + && ( NETWORK_GetState() == NETSTATE_SERVER )) + { + SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient(), + "Cannot call that vote because %s\n", validateResult.error.GetChars() ); + return; + } + + if ( votetype == NULL ) return; // Prevent excessive re-voting. if (( NETWORK_GetState( ) == NETSTATE_SERVER ) && callvote_CheckForFlooding( Command, Parameters, ulPlayer ) == false ) return; + if ( votetype->argumentType() == VOTEARG_Player ) + { + g_VoteStateData.targetAddress = SERVER_GetClient( validateResult.argument )->Address; + g_VoteStateData.targetAddressKnown = true; + } + + g_CurrentVoteSummary = VOTEDEF_MakeVoteSummary( g_VoteStateData ); + // Play the announcer sound for this. ANNOUNCER_PlayEntry( cl_announcer, "VoteNow" ); - // Create the vote console command. - g_VoteCommand = Command; - g_VoteCommand += " "; - g_VoteCommand += Parameters; + // [TP] How to display the vote? + g_VoteDisplay = votetype->name(); + + if ( votetype->hasArgument() ) + g_VoteDisplay += " (" + Parameters + ")"; + g_ulVoteCaller = ulPlayer; g_VoteReason = Reason.Left(25); // Create the record of the vote for flood prevention. { VOTE_s VoteRecord; - VoteRecord.fsParameter = Parameters; - time_t tNow; - time( &tNow ); - VoteRecord.tTimeCalled = tNow; + time( &VoteRecord.tTimeCalled ); + VoteRecord.VoteType = g_VoteStateData.type; VoteRecord.Address = SERVER_GetClient( g_ulVoteCaller )->Address; - VoteRecord.ulVoteType = callvote_GetVoteType( Command ); - - if ( callvote_IsKickVote ( VoteRecord.ulVoteType ) ) - VoteRecord.KickAddress = g_KickVoteVictimAddress; - + VoteRecord.Summary = g_CurrentVoteSummary; g_PreviousVotes.push_back( VoteRecord ); } // Display the message in the console. { - FString ReasonBlurb = ( g_VoteReason.Len( )) ? ( ", reason: \"" + g_VoteReason + "\"" ) : ""; + FString ReasonBlurb = ( g_VoteReason.Len( )) ? ( ": \"" + g_VoteReason + "\"" ) : ""; + FString IPString; if ( NETWORK_GetState( ) == NETSTATE_SERVER ) - Printf( "%s\\c- (%s) has called a vote (\"%s\"%s).\n", players[ulPlayer].userinfo.netname, NETWORK_AddressToString( SERVER_GetClient( ulPlayer )->Address ), g_VoteCommand.GetChars(), ReasonBlurb.GetChars() ); - else - Printf( "%s\\c- has called a vote (\"%s\"%s).\n", players[ulPlayer].userinfo.netname, g_VoteCommand.GetChars(), ReasonBlurb.GetChars() ); + IPString.Format( " (%s)", NETWORK_AddressToString( SERVER_GetClient( ulPlayer )->Address )); + + Printf( "%s%s\\c- has called a %s vote%s.\n", players[ulPlayer].userinfo.netname, + IPString.GetChars(), g_VoteDisplay.GetChars(), ReasonBlurb.GetChars() ); } g_VoteState = VOTESTATE_INVOTE; @@ -251,10 +271,11 @@ ULONG ulIdx; g_VoteState = VOTESTATE_NOVOTE; - g_VoteCommand = ""; + g_VoteDisplay = ""; g_ulVoteCaller = MAXPLAYERS; g_ulVoteCountdownTicks = 0; g_ulShowVoteScreenTicks = 0; + g_VoteStateData = VoteStateData(); for ( ulIdx = 0; ulIdx < (( MAXPLAYERS / 2 ) + 1 ); ulIdx++ ) { @@ -373,7 +394,7 @@ if ( ulPlayer == g_ulVoteCaller && ( NETWORK_GetState( ) == NETSTATE_SERVER )) { // [BB] If a player canceled his own vote, don't prevent others from making this type of vote again. - g_PreviousVotes.back( ).ulVoteType = NUM_VOTECMDS; + g_PreviousVotes.back( ).VoteType = NULL; SERVER_Printf( PRINT_HIGH, "Vote caller cancelled the vote.\n" ); g_bVoteCancelled = true; @@ -437,7 +458,7 @@ { return ( true ); } - + SERVERCOMMANDS_PlayerVote( ulPlayer, false ); ulNumYes = callvote_CountPlayersWhoVotedYes( ); @@ -499,14 +520,108 @@ //***************************************************************************** // +// [TP] Executes the called vote +// +static void callvote_ExecuteVote( const VoteStateData& input ) +{ + VoteValidateResult data; + + // [TP] Validate again before executing it. + if ( VOTEDEF_Validate( input, data ) == false ) + { + SERVER_Printf( PRINT_HIGH, TEXTCOLOR_ORANGE "Cannot execute vote: %s\n", data.error.GetChars() ); + return; + } + + if ( input.type->isNative() ) + { + // [TP] Write the kick reason into the ban reason, [BB] but only if it's not empty. + FString votekickmessage; + votekickmessage.Format( "%s: %d to %d: %s", + input.type->nativeType() == VOTETYPE_Kick ? "Vote kick" : "Voted to be forced to spectate", + input.yes, input.no, + ( input.reason.IsNotEmpty() ? input.reason.GetChars() : "No reason given" )); + + switch ( input.type->nativeType() ) + { + case VOTETYPE_Kick: + { + // [BB, RC] If the vote is a kick vote, we have to use stored IP and temporarily ban it. + std::string response; + SERVERBAN_BanIP ( input.targetAddress, 10 * MINUTE, votekickmessage, response ); + Printf( "[VOTEKICK] %s\n", response.c_str() ); + break; + } + + case VOTETYPE_ForceSpec: + SERVER_KickPlayerFromGame( data.argument, votekickmessage ); + break; + + case VOTETYPE_ChangeMap: + strncpy( level.nextmap, data.stringArgument, 8 ); + level.flags |= LEVEL_CHANGEMAPCHEAT; + G_ExitLevel( 0, false ); + break; + + case VOTETYPE_Map: + { + // [TP] There's enough stuff in the map ccmd that this needs to be done.. + // This should be safe since the votedef code ensures that the argument + // is a valid map name and no valid map name should break this. + char command[64]; + sprintf( command, "map \"%s\"", data.stringArgument.GetChars() ); + AddCommandString( command ); + break; + } + + case VOTETYPE_FragLimit: + fraglimit = data.argument; + break; + + case VOTETYPE_DuelLimit: + duellimit = data.argument; + break; + + case VOTETYPE_WinLimit: + winlimit = data.argument; + break; + + case VOTETYPE_PointLimit: + pointlimit = data.argument; + break; + + case VOTETYPE_TimeLimit: + timelimit = data.floatArgument; + break; + + case VOTETYPE_NumNatives: + break; // impossible + } + } + else + { + DWORD argvalue = data.argument; + + if (( input.type->argumentType() == VOTEARG_String ) + || ( input.type->argumentType() == VOTEARG_Level )) + { + argvalue = ACS_PushAndReturnDynamicString( data.stringArgument, NULL, 0 ); + } + + Printf( "[VOTE] -> Script %d (%s)\n", input.type->scriptNumber(), input.arg.GetChars() ); + int callerid = input.caller; + AActor* mo = PLAYER_IsValidPlayerWithMo( callerid ) ? players[callerid].mo : NULL; + P_StartScript( mo, NULL, input.type->scriptNumber(), NULL, false, argvalue, 0, 0, 1, false ); + } +} + +//***************************************************************************** +// void CALLVOTE_EndVote( bool bPassed ) { // This is a client-only function. - if (( NETWORK_GetState( ) != NETSTATE_CLIENT ) && - ( CLIENTDEMO_IsPlaying( ) == false )) - { + if ( NETWORK_InClientMode() == false ) return; - } g_bVotePassed = bPassed; callvote_EndVote( ); @@ -516,7 +631,7 @@ // const char *CALLVOTE_GetCommand( void ) { - return ( g_VoteCommand.GetChars( )); + return ( g_VoteDisplay.GetChars( )); } //***************************************************************************** @@ -651,10 +766,9 @@ //***************************************************************************** // -static bool callvote_CheckForFlooding( FString &Command, FString &Parameters, ULONG ulPlayer ) +static bool callvote_CheckForFlooding( ULONG &Command, FString &Parameters, ULONG ulPlayer ) { NETADDRESS_s Address = SERVER_GetClient( ulPlayer )->Address; - ULONG ulVoteType = callvote_GetVoteType( Command ); time_t tNow; time( &tNow ); @@ -670,11 +784,18 @@ // Run through the vote cache (backwards, from recent to old) and search for grounds on which to reject the vote. for( std::list::reverse_iterator i = g_PreviousVotes.rbegin(); i != g_PreviousVotes.rend(); ++i ) { + VoteClass* type = i->VoteType; + + if ( type == NULL ) + continue; + // One *type* of vote per voter per ## minutes (excluding kick votes if they passed). - if ( !( callvote_IsKickVote ( i->ulVoteType ) && i->bPassed ) && NETWORK_CompareAddress( i->Address, Address, true ) && ( ulVoteType == i->ulVoteType ) && (( tNow - i->tTimeCalled ) < VOTER_VOTETYPE_INTERVAL * MINUTE )) + if ( !(( type->flags() & VOTEF_NoLimitIfPassed ) && i->bPassed ) && NETWORK_CompareAddress( i->Address, Address, true ) && + ( g_VoteStateData.type == i->VoteType ) && (( tNow - i->tTimeCalled ) < VOTER_VOTETYPE_INTERVAL * MINUTE )) { int iMinutesLeft = static_cast( 1 + ( i->tTimeCalled + VOTER_VOTETYPE_INTERVAL * MINUTE - tNow ) / MINUTE ); - SERVER_PrintfPlayer( PRINT_HIGH, ulPlayer, "You must wait %d minute%s to call another %s vote.\n", iMinutesLeft, ( iMinutesLeft == 1 ? "" : "s" ), Command.GetChars() ); + SERVER_PrintfPlayer( PRINT_HIGH, ulPlayer, "You must wait %d minute%s to call another %s vote.\n", + iMinutesLeft, ( iMinutesLeft == 1 ? "" : "s" ), type->name().GetChars() ); return false; } @@ -682,28 +803,21 @@ if ( NETWORK_CompareAddress( i->Address, Address, true ) && (( tNow - i->tTimeCalled ) < VOTER_NEWVOTE_INTERVAL * MINUTE )) { int iMinutesLeft = static_cast( 1 + ( i->tTimeCalled + VOTER_NEWVOTE_INTERVAL * MINUTE - tNow ) / MINUTE ); - SERVER_PrintfPlayer( PRINT_HIGH, ulPlayer, "You must wait %d minute%s to call another vote.\n", iMinutesLeft, ( iMinutesLeft == 1 ? "" : "s" )); + SERVER_PrintfPlayer( PRINT_HIGH, ulPlayer, "You must wait %d minute%s to call another vote.\n", + iMinutesLeft, ( iMinutesLeft == 1 ? "" : "s" )); return false; } // Specific votes ("map map30") that fail can't be re-proposed for ## minutes. - if (( ulVoteType == i->ulVoteType ) && ( !i->bPassed ) && (( tNow - i->tTimeCalled ) < VOTE_LITERALREVOTE_INTERVAL * MINUTE )) + // [TP] Using generalized summaries. This takes care of the IP checking for instance. + if (( g_CurrentVoteSummary == i->Summary ) && ( !i->bPassed ) && (( tNow - i->tTimeCalled ) < VOTE_LITERALREVOTE_INTERVAL * MINUTE )) { - int iMinutesLeft = static_cast( 1 + ( i->tTimeCalled + VOTE_LITERALREVOTE_INTERVAL * MINUTE - tNow ) / MINUTE ); + int iMinutesLeft ( 1 + ( i->tTimeCalled + VOTE_LITERALREVOTE_INTERVAL * MINUTE - tNow ) / MINUTE ); - // Kickvotes (can't give the IP to clients!). - if ( callvote_IsKickVote ( i->ulVoteType ) && ( !i->bPassed ) && NETWORK_CompareAddress( i->KickAddress, g_KickVoteVictimAddress, true )) - { - SERVER_PrintfPlayer( PRINT_HIGH, ulPlayer, "That specific player was recently on voted to be kicked or forced to spectate, but the vote failed. You must wait %d minute%s to call it again.\n", iMinutesLeft, ( iMinutesLeft == 1 ? "" : "s" )); - return false; - } - - // Other votes. - if ( ( callvote_IsKickVote ( i->ulVoteType ) == false ) && ( stricmp( i->fsParameter.GetChars(), Parameters.GetChars() ) == 0 )) - { - SERVER_PrintfPlayer( PRINT_HIGH, ulPlayer, "That specific vote (\"%s %s\") was recently called, and failed. You must wait %d minute%s to call it again.\n", Command.GetChars(), Parameters.GetChars(), iMinutesLeft, ( iMinutesLeft == 1 ? "" : "s" )); - return false; - } + SERVER_PrintfPlayer( PRINT_HIGH, ulPlayer, "That specific vote was recently " + "called, and failed. You must wait %d minute%s to call it again.\n", + iMinutesLeft, ( iMinutesLeft == 1 ? "" : "s" )); + return false; } } @@ -711,167 +825,6 @@ } //***************************************************************************** -// -static bool callvote_CheckValidity( FString &Command, FString &Parameters ) -{ - // Get the type of vote this is. - ULONG ulVoteCmd = callvote_GetVoteType( Command.GetChars( )); - if ( ulVoteCmd == NUM_VOTECMDS ) - return ( false ); - - // Check for any illegal characters. - if ( callvote_IsKickVote ( ulVoteCmd ) == false ) - { - int i = 0; - while ( Parameters.GetChars()[i] != '\0' ) - { - if ( Parameters.GetChars()[i] == ';' || Parameters.GetChars()[i] == ' ' ) - { - if ( NETWORK_GetState( ) == NETSTATE_SERVER ) - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "That vote command contained illegal characters.\n" ); - return ( false ); - } - i++; - } - } - - // Then, make sure the parameter for each vote is valid. - int parameterInt = atoi( Parameters.GetChars() ); - switch ( ulVoteCmd ) - { - case VOTECMD_KICK: - case VOTECMD_KICKFROMGAME: - { - if ( NETWORK_GetState( ) == NETSTATE_SERVER ) - { - // Store the player's IP so he can't get away. - ULONG ulIdx = SERVER_GetPlayerIndexFromName( Parameters.GetChars( ), true, false ); - if ( ulIdx < MAXPLAYERS ) - { - if ( static_cast(ulIdx) == SERVER_GetCurrentClient( )) - { - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "You cannot call a vote to kick or to force to spectate yourself!\n" ); - return ( false ); - } - // [BB] Don't allow anyone to kick somebody who is on the admin list. [K6] ...or is logged into RCON. - if ( SERVER_GetAdminList()->isIPInList( SERVER_GetClient( ulIdx )->Address ) - || SERVER_GetClient( ulIdx )->bRCONAccess ) - { - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "This player is a server admin and thus can't be kicked or forced to spectate!\n" ); - return ( false ); - } - g_KickVoteVictimAddress = SERVER_GetClient( ulIdx )->Address; - return ( true ); - } - else - { - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "That player doesn't exist.\n" ); - return ( false ); - } - } - } - break; - case VOTECMD_MAP: - case VOTECMD_CHANGEMAP: - - // Don't allow the command if the map doesn't exist. - if ( !P_CheckIfMapExists( Parameters.GetChars( ))) - { - if ( NETWORK_GetState( ) == NETSTATE_SERVER ) - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "That map does not exist.\n" ); - return ( false ); - } - - // Don't allow us to leave the map rotation. - if ( NETWORK_GetState( ) == NETSTATE_SERVER ) - { - // [BB] Regardless of sv_maprotation, if the server has maps in the rotation, - // assume players are restricted to these maps. - if ( ( MAPROTATION_GetNumEntries() > 0 ) && ( MAPROTATION_IsMapInRotation( Parameters.GetChars( ) ) == false ) ) - { - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "That map is not in the map rotation.\n" ); - return ( false ); - } - } - break; - case VOTECMD_FRAGLIMIT: - case VOTECMD_WINLIMIT: - case VOTECMD_DUELLIMIT: - - // Parameteter be between 0 and 255. - if (( parameterInt < 0 ) || ( parameterInt >= 256 )) - { - if ( NETWORK_GetState( ) == NETSTATE_SERVER ) - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "%s parameters must be between 0 and 255.\n", Command.GetChars() ); - return ( false ); - } - else if ( parameterInt == 0 ) - { - if (( Parameters.GetChars()[0] != '0' ) || ( Parameters.Len() != 1 )) - return ( false ); - } - Parameters.Format( "%d", parameterInt ); - break; - case VOTECMD_TIMELIMIT: - case VOTECMD_POINTLIMIT: - - // Parameteter must be between 0 and 65535. - if (( parameterInt < 0 ) || ( parameterInt >= 65536 )) - { - if ( NETWORK_GetState( ) == NETSTATE_SERVER ) - SERVER_PrintfPlayer( PRINT_HIGH, SERVER_GetCurrentClient( ), "%s parameters must be between 0 and 65535.\n", Command.GetChars() ); - return ( false ); - } - else if ( parameterInt == 0 ) - { - if (( Parameters.GetChars()[0] != '0' ) || ( Parameters.Len() != 1 )) - return ( false ); - } - Parameters.Format( "%d", parameterInt ); - break; - default: - - return ( false ); - } - - // Passed all checks! - return ( true ); -} - -//***************************************************************************** -// -static ULONG callvote_GetVoteType( const char *pszCommand ) -{ - if ( stricmp( "kick", pszCommand ) == 0 ) - return VOTECMD_KICK; - else if ( stricmp( "forcespec", pszCommand ) == 0 ) - return VOTECMD_KICKFROMGAME; - else if ( stricmp( "map", pszCommand ) == 0 ) - return VOTECMD_MAP; - else if ( stricmp( "changemap", pszCommand ) == 0 ) - return VOTECMD_CHANGEMAP; - else if ( stricmp( "fraglimit", pszCommand ) == 0 ) - return VOTECMD_FRAGLIMIT; - else if ( stricmp( "timelimit", pszCommand ) == 0 ) - return VOTECMD_TIMELIMIT; - else if ( stricmp( "winlimit", pszCommand ) == 0 ) - return VOTECMD_WINLIMIT; - else if ( stricmp( "duellimit", pszCommand ) == 0 ) - return VOTECMD_DUELLIMIT; - else if ( stricmp( "pointlimit", pszCommand ) == 0 ) - return VOTECMD_POINTLIMIT; - - return NUM_VOTECMDS; -} - -//***************************************************************************** -// -static bool callvote_IsKickVote( const ULONG ulVoteType ) -{ - return ( ( ulVoteType == VOTECMD_KICK ) || ( ulVoteType == VOTECMD_KICKFROMGAME ) ); -} - -//***************************************************************************** // CONSOLE COMMANDS/VARIABLES CUSTOM_CVAR( Int, sv_minvoters, 1, CVAR_ARCHIVE ) @@ -881,7 +834,6 @@ } CVAR( Int, sv_nocallvote, 0, CVAR_ARCHIVE ); // 0 - everyone can call votes. 1 - nobody can. 2 - only players can. CVAR( Bool, sv_nokickvote, false, CVAR_ARCHIVE ); -CVAR( Bool, sv_noforcespecvote, false, CVAR_ARCHIVE ); CVAR( Bool, sv_nomapvote, false, CVAR_ARCHIVE ); CVAR( Bool, sv_nochangemapvote, false, CVAR_ARCHIVE ); CVAR( Bool, sv_nofraglimitvote, false, CVAR_ARCHIVE ); @@ -895,6 +847,8 @@ CCMD( callvote ) { ULONG ulVoteCmd; + FString arg, reason; + VoteClass* votetype; // Don't allow a vote unless the player is a client. if ( NETWORK_GetState( ) != NETSTATE_CLIENT ) @@ -906,7 +860,7 @@ if ( CLIENT_GetConnectionState( ) != CTS_ACTIVE ) return; - if ( argv.argc( ) < 3 ) + if ( argv.argc( ) < 2 ) { Printf( "callvote [reason]: Calls a vote\n" ); return; @@ -919,22 +873,33 @@ return; } - ulVoteCmd = callvote_GetVoteType( argv[1] ); - if ( ulVoteCmd == NUM_VOTECMDS ) + if (( votetype = VOTEDEF_FindTypeByName( argv[1] )) == NULL ) { - Printf( "Invalid callvote command.\n" ); + Printf( "No such vote type '%s'.\nTry use one of: %s\n", argv[1], + VOTEDEF_GetVoteTypeList().GetChars() ); return; } - if ( argv.argc( ) >= 4 ) - CLIENTCOMMANDS_CallVote( ulVoteCmd, argv[2], argv[3] ); + // [TP] We may need a second argument + if ( votetype->hasArgument() ) + { + if ( argv.argc() < 3 ) + { + Printf( "You need to supply an argument to call a %s vote:\nUsage: %s", + votetype->name().GetChars(), votetype->usage().GetChars()); + return; + } + + arg = argv[2]; + reason = ( argv.argc() >= 4 ) ? argv[3] : ""; + } else - CLIENTCOMMANDS_CallVote( ulVoteCmd, argv[2], "" ); -/* - g_lBytesSent += g_LocalBuffer.cursize; - if ( g_lBytesSent > g_lMaxBytesSent ) - g_lMaxBytesSent = g_lBytesSent; -*/ + { + arg = ""; + reason = ( argv.argc() >= 3 ) ? argv[2] : ""; + } + + CLIENTCOMMANDS_CallVote( votetype->index(), arg, reason ); NETWORK_LaunchPacket( CLIENT_GetLocalBuffer( ), CLIENT_GetServerAddress( )); NETWORK_ClearBuffer( CLIENT_GetLocalBuffer( )); } @@ -1010,3 +975,25 @@ } } } + +//***************************************************************************** +// +// [TP] What has g_PreviousVotes eaten? +// +CCMD ( recentvotes ) +{ + for( std::list::reverse_iterator i = g_PreviousVotes.rbegin(); i != g_PreviousVotes.rend(); ++i ) + { + Printf( "- " ); + + if ( i->VoteType == NULL ) + Printf( "" ); + else + Printf( "%s", i->VoteType->name().GetChars() ); + + char timestring[256]; + strftime( timestring, sizeof timestring, "%F %T", localtime( &i->tTimeCalled )); + + Printf( ", called by %s on %s\n", NETWORK_AddressToString( i->Address ), timestring ); + } +} diff --git a/src/callvote.h b/src/callvote.h --- a/src/callvote.h +++ b/src/callvote.h @@ -66,21 +66,7 @@ #define VOTE_LITERALREVOTE_INTERVAL 10 #define VOTE_LONGEST_INTERVAL 10 // Sets when old votes are removed from the flood cache. Set to the longest interval of the above. -//***************************************************************************** -enum -{ - VOTECMD_KICK, - VOTECMD_KICKFROMGAME, - VOTECMD_MAP, - VOTECMD_CHANGEMAP, - VOTECMD_FRAGLIMIT, - VOTECMD_TIMELIMIT, - VOTECMD_WINLIMIT, - VOTECMD_DUELLIMIT, - VOTECMD_POINTLIMIT, - - NUM_VOTECMDS -}; +class VoteClass; //***************************************************************************** typedef enum @@ -102,18 +88,15 @@ // Time that this vote was called. time_t tTimeCalled; - // The type of vote (see NUM_VOTECMDS). - ULONG ulVoteType; - - // Parameter of the vote ("map01", "50", etc). - FString fsParameter; - - // For kick votes: the address being kicked. - NETADDRESS_s KickAddress; - // Was it passed? bool bPassed; + // [TP] The type of this vote + VoteClass* VoteType; + + // [TP] Unique summary for this vote (contains type and argument and whatever else) + FString Summary; + } VOTE_s; //***************************************************************************** @@ -122,7 +105,7 @@ void CALLVOTE_Construct( void ); void CALLVOTE_Tick( void ); //void CALLVOTE_Render( void ); -void CALLVOTE_BeginVote( FString Command, FString Parameters, FString Reason, ULONG ulPlayer ); +void CALLVOTE_BeginVote( ULONG Command, FString Parameters, FString Reason, ULONG ulPlayer ); void CALLVOTE_ClearVote( void ); bool CALLVOTE_VoteYes( ULONG ulPlayer ); bool CALLVOTE_VoteNo( ULONG ulPlayer ); @@ -144,7 +127,6 @@ EXTERN_CVAR( Int, sv_minvoters ); EXTERN_CVAR( Int, sv_nocallvote ) EXTERN_CVAR( Bool, sv_nokickvote ); -EXTERN_CVAR( Bool, sv_noforcespecvote ); EXTERN_CVAR( Bool, sv_nomapvote ); EXTERN_CVAR( Bool, sv_nochangemapvote ); EXTERN_CVAR( Bool, sv_nofraglimitvote ); diff --git a/src/callvotetype.cpp b/src/callvotetype.cpp new file mode 100644 --- /dev/null +++ b/src/callvotetype.cpp @@ -0,0 +1,623 @@ +/* + * Zandronum source code + * Copyright (C) 2012-2014 Teemu Piippo + * Copyright (C) 2012-2014 Zandronum Development Team + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of the Skulltag Development Team nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * 4. Redistributions in any form must be accompanied by information on how to + * obtain complete source code for the software and any accompanying + * software that uses the software. The source code must either be included + * in the distribution or be available for no more than the cost of + * distribution plus a nominal fee, and must be freely redistributable + * under reasonable conditions. For an executable file, complete source + * code means the source code for all modules it contains. It does not + * include source code for modules or files that typically accompany the + * major components of the operating system on which the executable file + * runs. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Filename: votedef.cpp + * + * Description: VOTEDEF parser, vote type manager + * + * ----------------------------------------------------------------------------- + */ + +#include "doomdef.h" +#include "info.h" +#include "tarray.h" +#include "callvotetype.h" +#include "network.h" +#include "sv_main.h" +#include "g_level.h" +#include "v_text.h" +#include "c_dispatch.h" +#include "maprotation.h" +#include "c_cvars.h" +#include "i_system.h" +#include "doomerrors.h" +#include "p_acs.h" + +static TArray g_Defs; +static NETADDRESS_s g_StoredIPAddress; + +const char* g_ParameterTokens[] = +{ + "INT", + "FLOAT", + "PLAYER", + "MAP", + "STRING", + NULL +}; + +const char* g_PropertyTokens[] = +{ + "ARGUMENT", + "SCRIPTNUMBER", + "DESCRIPTION", + "FORBIDCVAR", + "ARGUMENTLABEL", + "MENURANGE", + "MENUINCREMENT", + NULL +}; + +const char* g_FlagTokens[] = +{ + "NOPASSEDLIMIT", + "NOTONSELF", + "NOTONADMIN", + "PLAYERASINDEX", + "NOTONSPECTATORS", + "MENUSLIDER", + "MAPINROTATION", + NULL +}; + +const char* g_NativeNames[] = +{ + "KICK", + "FORCESPEC", + "CHANGEMAP", + "MAP", + "FRAGLIMIT", + "TIMELIMIT", + "POINTLIMIT", + "DUELLIMIT", + "WINLIMIT", + NULL +}; + +enum VotedefProperty +{ + VTPROP_Argument, + VTPROP_ScriptNumber, + VTPROP_Description, + VTPROP_ForbidCVar, + VTPROP_ArgumentLabel, + VTPROP_MenuRange, + VTPROP_MenuIncrement, +}; + +// +// [TP] Vote definition constructor +// +VoteClass::VoteClass( const FString& name, NativeVoteType native ) : + _name( name ), + _scriptNumber( 0 ), + _flags( 0 ), + _argumentType( VOTEARG_NumArgTypes ), + _minimum( INT_MAX ), + _maximum( INT_MAX ), + _native( native ), + _index( g_Defs.Size() ), + _menuMinimum( 0.0f ), + _menuMaximum( 0.0f ), + _menuIncrement( 1.0f ) {} + +// +// [TP] Vote definition destructor +// +VoteClass::~VoteClass() {} + +// +// [TP] Initializes custom vote types. +// +void VOTEDEF_Construct() +{ + if ( Wads.CheckNumForName( "VOTEDEF" ) == -1 ) + return; + + // [TP] Startup message. :) + Printf( "VOTEDEF_Construct: Loading vote type definitions.\n" ); + atterm( VOTEDEF_Destruct ); + + int lump, lastlump; + lastlump = 0; + + while (( lump = Wads.FindLump( "VOTEDEF", &lastlump )) != -1 ) + VOTEDEF_ParseLump( lump ); +} + +// +// [TP] De-initializes the votedef stuff. +// +void VOTEDEF_Destruct() +{ + for ( unsigned i = 0; i < g_Defs.Size(); ++i ) + delete g_Defs[i]; + + g_Defs.Clear(); +} + +static double VOTEDEF_GetNumeric( FScanner& sc ) +{ + if ( sc.CheckToken( TK_FloatConst ) == false ) + sc.MustGetToken( TK_IntConst ); + + return sc.Float; +} + +// +// [TP] Parse a single VOTEDEF lump. +// +void VOTEDEF_ParseLump( int lump ) +{ + FScanner sc( lump ); + + while ( sc.GetToken() ) + { + bool isnative = false; + NativeVoteType native = VOTETYPE_NumNatives; + + // [TP] 'votetype' is the only command we have right now. + if ( sc.Compare( "VOTETYPE" ) == false ) + sc.ScriptError( "Expected `votetype`, got %s", sc.String ); + + // [TP] See if this vote type is native. + if ( sc.CheckToken( TK_Native )) + isnative = true; + + sc.MustGetAnyToken(); + FString votename = sc.String; + FString forbidCVarName; + + if ( isnative ) + native = NativeVoteType( sc.MustMatchString( g_NativeNames )); + + // [TP] Check that it's not already defined + if ( VOTEDEF_FindTypeByName( votename )) + sc.ScriptError( "Vote type `%s` is already defined", votename.GetChars() ); + + VoteClass* type = new VoteClass( votename, native ); + + bool gotMenuRange = false; + sc.MustGetToken( '{' ); + + while ( sc.CheckToken( '}' ) == false ) + { + // [TP] The file shouldn't end in the middle of a block + if ( sc.GetToken() == false ) + sc.ScriptError( "Unexpected end of file, did you miss a '}'?" ); + + // [TP] Try flags + int flagindex; + if (( flagindex = sc.MatchString( g_FlagTokens )) != -1 ) + { + sc.MustGetToken( ';' ); + type->_flags |= ( 1 << flagindex ); + continue; + } + + // [TP] Try properties + int prop = sc.MustMatchString( g_PropertyTokens ); + sc.MustGetToken( '=' ); + + switch ( VotedefProperty( prop )) + { + case VTPROP_Argument: + sc.MustGetAnyToken(); + type->_argumentType = VoteArgumentType( sc.MustMatchString( g_ParameterTokens )); + + // [TP] Int and float types must have a value range. + if (( type->argumentType() == VOTEARG_Int ) + || ( type->argumentType() == VOTEARG_Float )) + { + sc.MustGetToken( '(' ); + type->_minimum = VOTEDEF_GetNumeric( sc ); + sc.MustGetToken( ',' ); + type->_maximum = VOTEDEF_GetNumeric( sc ); + sc.MustGetToken( ')' ); + } + break; + + case VTPROP_ForbidCVar: + sc.MustGetAnyToken(); + forbidCVarName = sc.String; + break; + + case VTPROP_ScriptNumber: + sc.MustGetToken( TK_IntConst ); + type->_scriptNumber = sc.Number; + + if ( type->scriptNumber() != clamp( type->scriptNumber(), 1, 999 ) ) + sc.ScriptError( "Script number must be between values 1 and 999." ); + break; + + case VTPROP_Description: + sc.MustGetAnyToken(); + type->_description = sc.String; + break; + + case VTPROP_ArgumentLabel: + sc.MustGetToken( TK_StringConst ); + type->_argumentLabel = sc.String; + break; + + case VTPROP_MenuRange: + type->_menuMinimum = VOTEDEF_GetNumeric( sc ); + sc.MustGetToken( ',' ); + type->_menuMaximum = VOTEDEF_GetNumeric( sc ); + gotMenuRange = true; + break; + + case VTPROP_MenuIncrement: + type->_menuIncrement = VOTEDEF_GetNumeric( sc ); + break; + } + + sc.MustGetToken( ';' ); + } + + if ( type->isNative() == false + && type->_scriptNumber == 0 ) + { + sc.ScriptError( "Non-native vote type '%s' needs a script number.", + type->_name.GetChars() ); + } + + // [TP] Generate the forbid CVar name if it's not given. + if ( forbidCVarName.IsEmpty() ) + forbidCVarName = "sv_no" + type->name() + "vote"; + + // [TP] If the CVar does not exist, create it now. + if (( type->_forbidCVar = FindCVar( forbidCVarName, NULL )) == NULL ) + { + FBoolCVar* var = new FBoolCVar( forbidCVarName, false, CVAR_AUTO | CVAR_ARCHIVE ); + var->SetArchiveBit(); + type->_forbidCVar = var; + } + + // [TP] Put a colon after the argument label if it's not empty. + // If it is empty, we want it to be an empty string. + if ( type->_argumentLabel.IsNotEmpty() ) + type->_argumentLabel += ":"; + + // [TP] Fill in default menu range if not explicitly given + if ( gotMenuRange == false ) + { + type->_menuMinimum = type->_minimum; + type->_menuMaximum = type->_maximum; + } + + // [TP] If we use integral values, ensure the numbers given aren't floating point + if ( type->argumentType() == VOTEARG_Int ) + { + const double epsilon = 0.0000000001; + float values[] = { type->minimum(), type->maximum(), type->menuMinimum(), + type->menuMaximum(), type->menuIncrement() }; + const char* valueNames[] = { "Minimum", "Maximum", "Menu minimum", + "Menu maximum", "Menu increment" }; + + for( int i = 0; i < int( sizeof values / sizeof *values ); ++i ) + { + if ( fabsf( values[i] - floor( values[i] )) > epsilon ) + { + sc.ScriptError( "%s of vote type '%s' is not an integer", + valueNames[i], type->name().GetChars() ); + } + } + } + + g_Defs.Push( type ); + } +} + +// +// [TP] An error function for VOTEDEF_Validate +// +static void STACK_ARGS VOTEDEF_ValidateError( const char* fmtstr, ... ) GCCPRINTF( 1, 2 ); +static void STACK_ARGS VOTEDEF_ValidateError( const char* fmtstr, ... ) +{ + va_list va; + char errortext[1024]; + va_start( va, fmtstr ); + vsprintf( errortext, fmtstr, va ); + va_end( va ); + throw FString( errortext ); +} + +// +// [TP] Apply given input data, performs validity checks and compiles some data +// needed for vote execution. +// +bool VOTEDEF_Validate( VoteStateData const& input, VoteValidateResult& result ) +{ + try + { + VoteClass* votetype = input.type; + + if ( votetype == NULL ) + VOTEDEF_ValidateError( "a bad vote class was given" ); + + // [TP] Reset the result + result.error = ""; + result.stringArgument = ""; + result.argument = 0; + result.floatArgument = 0.0; + + // [TP] Check that we got the proper parameter + if ( votetype->hasArgument() ) + { + if ( input.arg.IsEmpty() ) + VOTEDEF_ValidateError( "the vote argument was not given" ); + + // [TP] The variable contens in various types + DWORD valueAsIntegral = atol( input.arg ); + double valueAsDouble = atof( input.arg ); + int idx = 0; + + switch ( votetype->argumentType() ) + { + case VOTEARG_Int: + if (( input.arg.IsInt() == false ) + || ( valueAsIntegral < DWORD( votetype->minimum() )) + || ( valueAsIntegral > DWORD( votetype->maximum() ))) + { + VOTEDEF_ValidateError( "%s is not an integral number between %d and %d", + input.arg.GetChars(), DWORD( votetype->minimum() ), DWORD( votetype->maximum() )); + } + + result.argument = valueAsIntegral; + break; + + case VOTEARG_Float: + if (( input.arg.IsFloat() == false ) + || ( valueAsDouble < votetype->minimum() ) + || ( valueAsDouble > votetype->maximum() )) + { + VOTEDEF_ValidateError( "%s is not a number between %f and %f", + input.arg.GetChars(), votetype->minimum(), votetype->maximum() ); + } + + // [TP] The argument needs to be converted to fixed point + result.argument = valueAsDouble * FRACUNIT; + result.floatArgument = valueAsDouble; + break; + + case VOTEARG_Player: + // [TP] Only need to test the player index of the target address isn't already known + if (( votetype->nativeType() != VOTETYPE_Kick ) || ( input.targetAddressKnown == false )) + { + // [TP] Find the client by name, unless PLAYERINDEX is given + if ( votetype->flags() & VOTEF_PlayerAsIndex ) + { + if ( input.arg.IsInt() == false ) + VOTEDEF_ValidateError( "'%s' is not a valid player index", input.arg.GetChars() ); + + idx = valueAsIntegral; + } + else + { + idx = SERVER_GetPlayerIndexFromName( input.arg, true, false ); + } + + // [TP] Must be a valid player + if ( SERVER_IsValidClient( idx ) == false ) + VOTEDEF_ValidateError( "there is no player #%d", idx ); + + // [TP] Check if this is to be done on spectators + if (( votetype->flags() & VOTEF_NotOnSpectators ) && ( players[idx].bSpectating )) + VOTEDEF_ValidateError( "%s is a spectator", players[idx].userinfo.netname ); + + // [BB] Don't allow anyone to kick somebody who is on the admin list. + if (( votetype->flags() & VOTEF_NotOnAdmin ) && ( VOTEDEF_IsPlayerAdmin( idx ))) + VOTEDEF_ValidateError( "you may not do this on %s", players[idx].userinfo.netname ); + + // [TP] Not self if NOTSELF is set + if (( votetype->flags() & VOTEF_NotOnSelf ) && ( idx == input.caller )) + VOTEDEF_ValidateError( "you are %s!", players[idx].userinfo.netname ); + } + + result.argument = idx; + break; + + case VOTEARG_Level: + if ( P_CheckIfMapExists( input.arg ) == false ) + VOTEDEF_ValidateError( "there is no such map '%s'", input.arg.GetChars() ); + + if (( votetype->flags() & VOTEF_MapInRotation ) + && ( NETWORK_GetState() == NETSTATE_SERVER ) + && ( sv_maprotation ) + && ( MAPROTATION_IsMapInRotation( input.arg ) == false )) + { + VOTEDEF_ValidateError( "the map '%s' is not in rotation", input.arg.GetChars() ); + } + + result.stringArgument = input.arg; + break; + + case VOTEARG_String: + if ( input.arg.Len() >= MAX_NETWORK_STRING ) + VOTEDEF_ValidateError( "the argument is too long" ); + + result.stringArgument = input.arg; + break; + + case VOTEARG_NumArgTypes: + break; + } + } + + // [TP] Check that we won't run a client-side script as a result of this vote. + if ( votetype->isNative() == false ) + { + FBehavior* module = NULL; + const ScriptPtr* scriptdata = FBehavior::StaticFindScript( votetype->scriptNumber(), module ); + + if (( scriptdata != NULL ) && ( scriptdata->Flags & SCRIPTF_ClientSide )) + VOTEDEF_ValidateError( "the vote would call the client-side script %d", votetype->scriptNumber() ); + } + } + catch ( FString& err ) + { + result.error = err; + return false; + } + + return true; +} + +// +// [TP] Make a record of this vote for later comparing +// +FString VOTEDEF_MakeVoteSummary( const VoteStateData& input ) +{ + FString record = input.type->name() + " "; + + switch ( input.type->argumentType() ) + { + case VOTEARG_Int: + case VOTEARG_Float: + case VOTEARG_Level: + record += input.arg; + break; + + case VOTEARG_Player: + // [TP] Store the IP address of this player was this a kick vote or not, + // as this way we can have something unique to the player. + // This way a player index vote will not fail just because someone + // left and another person took his index. + record += NETWORK_AddressToStringIgnorePort( input.targetAddress ); + break; + + default: + break; + } + + return record; +} + +// +// [TP] Get usage info of calling this vote +// +FString VoteClass::usage() const +{ + FString cmd = "callvote " + name(); + + if ( hasArgument() ) + { + FString arg = g_ParameterTokens[argumentType()]; + arg.ToLower(); + cmd.AppendFormat( " <%s>", arg.GetChars() ); + } + + cmd += " [reason]"; + return cmd; +} + +// +// [TP] Find a vote type by index number +// +VoteClass* VOTEDEF_FindTypeByIndex( int index ) +{ + if (( index < 0 ) || ( index >= int( g_Defs.Size() ))) + return NULL; + + return g_Defs[index]; +} + +// +// [TP] Find a vote type by name +// +VoteClass* VOTEDEF_FindTypeByName( FString name ) +{ + for ( int i = 0; i < int( g_Defs.Size() ); i++ ) + { + if ( g_Defs[i]->name().CompareNoCase( name ) == 0 ) + return g_Defs[i]; + } + + return NULL; +} + +int VOTEDEF_NumVoteTypes() +{ + return g_Defs.Size(); +} + +// +// [TP] Is the given player in the adminlist? +// +bool VOTEDEF_IsPlayerAdmin( int idx ) +{ + NETADDRESS_s address = SERVER_GetClient( idx )->Address; + return SERVER_GetAdminList()->isIPInList( address ); +} + +// +// [TP] Gets a comma-delimeted list of all vote type names +// +FString VOTEDEF_GetVoteTypeList() +{ + FString result; + + for ( int i = 0; i < VOTEDEF_NumVoteTypes(); i++ ) + { + if ( i != 0 ) + result += ", "; + + VoteClass* votetype = VOTEDEF_FindTypeByIndex( i ); + result += votetype->name(); + } + + return result; +} + +// +// [TP] List all vote types and information on how to use them. +// +CCMD( listvotetypes ) +{ + for ( int i = 0; i < VOTEDEF_NumVoteTypes(); i++ ) + { + VoteClass* votetype = VOTEDEF_FindTypeByIndex( i ); + FString message, description; + message.Format( "\\c[Orange]%s\\c-", votetype->usage().GetChars() ); + + // [TP] Add the description, if we have it. + if (( description = votetype->description() ).IsNotEmpty() ) + message.AppendFormat( ": %s", description.GetChars() ); + + Printf( "%s\n", message.GetChars() ); + } +} diff --git a/src/callvotetype.h b/src/callvotetype.h new file mode 100644 --- /dev/null +++ b/src/callvotetype.h @@ -0,0 +1,282 @@ +/* + * Zandronum source code + * Copyright (C) 2012-2014 Teemu Piippo + * Copyright (C) 2012-2014 Zandronum Development Team + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of the Skulltag Development Team nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * 4. Redistributions in any form must be accompanied by information on how to + * obtain complete source code for the software and any accompanying + * software that uses the software. The source code must either be included + * in the distribution or be available for no more than the cost of + * distribution plus a nominal fee, and must be freely redistributable + * under reasonable conditions. For an executable file, complete source + * code means the source code for all modules it contains. It does not + * include source code for modules or files that typically accompany the + * major components of the operating system on which the executable file + * runs. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Filename: callvotetype.h + * + * Description: VOTEDEF declarations + * + * ----------------------------------------------------------------------------- + */ + +#ifndef VOTEDEF_H +#define VOTEDEF_H + +#include "zstring.h" +#include "basictypes.h" +#include "networkshared.h" +#include "doomdef.h" + +class FBaseCVar; +class VoteClass; + +enum NativeVoteType +{ + VOTETYPE_Kick, + VOTETYPE_ForceSpec, + VOTETYPE_ChangeMap, + VOTETYPE_Map, + VOTETYPE_FragLimit, + VOTETYPE_TimeLimit, + VOTETYPE_PointLimit, + VOTETYPE_DuelLimit, + VOTETYPE_WinLimit, + + VOTETYPE_NumNatives, // i.e. not native +}; + +// +// Vote parameter types +// +enum VoteArgumentType +{ + VOTEARG_Int, + VOTEARG_Float, + VOTEARG_Player, + VOTEARG_Level, + VOTEARG_String, + + VOTEARG_NumArgTypes, // i.e. no argument +}; + +// +// Flags for vote classes +// +enum +{ + // Vote can be called without delay as long as it passes + VOTEF_NoLimitIfPassed = ( 1 << 0 ), + + // Player argument must not be the caller + VOTEF_NotOnSelf = ( 1 << 1 ), + + // Player argument must not be an admin + VOTEF_NotOnAdmin = ( 1 << 2 ), + + // Player argument is given as an index instead of a name + VOTEF_PlayerAsIndex = ( 1 << 3 ), + + // Player given must be in game + VOTEF_NotOnSpectators = ( 1 << 4 ), + + // Use a slider in the call vote menu (int and float only) + VOTEF_MenuSlider = ( 1 << 5 ), + + // If a map argument, map must be in rotation + VOTEF_MapInRotation = ( 1 << 6 ), + + VOTEF_NumFlags = 7 +}; + +// +// A bunch of data for the state of a vote +// +struct VoteStateData +{ + VoteClass* type; // Type of vote (note: only is guaranteed non-NULL if validate passes) + FString arg; // Vote argument + FString reason; // Reason string + int yes; // Count of yes votes + int no; // Count of no votes + int caller; // Index of vote caller + NETADDRESS_s targetAddress; // For a vote with a player argument, what's the target address? + bool targetAddressKnown; // Is the targetAddress valid? + + VoteStateData() : + type( NULL ), + yes( 0 ), + no( 0 ), + targetAddressKnown( false ) {} +}; + +// +// Structure for result from VOTEDEF_Validate +// +struct VoteValidateResult +{ + FString command; // Resulting command string (for natives) + FString error; // Failed? Why? + DWORD argument; // Processed argument + FString stringArgument; // For a string or map argument, what's the string? + double floatArgument; // For a float argument, what's the floating-point value? +}; + +// +// A type of vote +// +class VoteClass +{ + FString _name; // Name of the type + int _scriptNumber; // Script number to execute + DWORD _flags; // Flags of this vote + VoteArgumentType _argumentType; // Argument type + FString _argumentLabel; // Label of the argument in menus + FString _description; // Description string + FBaseCVar* _forbidCVar; // CVar that forbids the use of this vote + float _minimum; // Minimum input value + float _maximum; // Maximum input value + NativeVoteType _native; // Native vote type, these have special behavior. + int _index; // The index of this type + float _menuMinimum; // Minimum value for menus + float _menuMaximum; // Maximum value for menus + float _menuIncrement; // Increment value for menus + + friend void VOTEDEF_ParseLump( int ); + +public: + VoteClass( const FString& name, NativeVoteType native ); + ~VoteClass(); + + inline VoteArgumentType argumentType() const; + const FString& argumentLabel() const; + inline const FString& description() const; + inline DWORD flags() const; + inline FBaseCVar* forbidCVar() const; + inline bool hasArgument() const; + inline int index() const; + inline bool isNative() const; + FString usage() const; + inline float maximum() const; + inline float menuIncrement() const; + inline float menuMaximum() const; + inline float menuMinimum() const; + inline float minimum() const; + inline const FString& name() const; + inline NativeVoteType nativeType() const; + inline int scriptNumber() const; +}; + +void VOTEDEF_Construct(); +void VOTEDEF_Destruct(); +FString VOTEDEF_GetVoteTypeList(); +VoteClass* VOTEDEF_FindTypeByIndex( int index ); +VoteClass* VOTEDEF_FindTypeByName( FString name ); +FString VOTEDEF_MakeVoteSummary( VoteStateData const& input ); +int VOTEDEF_NumVoteTypes(); +void VOTEDEF_ParseLump( int lump ); +bool VOTEDEF_IsPlayerAdmin( int idx ); +bool VOTEDEF_Validate( const VoteStateData& input, VoteValidateResult& result ); + +inline int VoteClass::index() const +{ + return _index; +} + +inline int VoteClass::scriptNumber() const +{ + return _scriptNumber; +} + +inline NativeVoteType VoteClass::nativeType() const +{ + return _native; +} + +inline const FString& VoteClass::name() const +{ + return _name; +} + +inline VoteArgumentType VoteClass::argumentType() const +{ + return _argumentType; +} + +inline DWORD VoteClass::flags() const +{ + return _flags; +} + +inline FBaseCVar* VoteClass::forbidCVar() const +{ + return _forbidCVar; +} + +inline float VoteClass::minimum() const +{ + return _minimum; +} + +inline float VoteClass::maximum() const +{ + return _maximum; +} + +inline const FString& VoteClass::description() const +{ + return _description; +} + +inline bool VoteClass::isNative() const +{ + return _native != VOTETYPE_NumNatives; +} + +inline bool VoteClass::hasArgument() const +{ + return _argumentType != VOTEARG_NumArgTypes; +} + +inline const FString& VoteClass::argumentLabel() const +{ + return _argumentLabel; +} + +inline float VoteClass::menuMinimum() const +{ + return _menuMinimum; +} + +inline float VoteClass::menuMaximum() const +{ + return _menuMaximum; +} + +inline float VoteClass::menuIncrement() const +{ + return _menuIncrement; +} + +#endif // VOTEDEF_H diff --git a/src/cl_main.cpp b/src/cl_main.cpp --- a/src/cl_main.cpp +++ b/src/cl_main.cpp @@ -9997,7 +9997,7 @@ // static void client_CallVote( BYTESTREAM_s *pByteStream ) { - FString command; + ULONG ulCommand; FString parameters; FString reason; ULONG ulVoteCaller; @@ -10006,7 +10006,7 @@ ulVoteCaller = NETWORK_ReadByte( pByteStream ); // Read in the command. - command = NETWORK_ReadString( pByteStream ); + ulCommand = NETWORK_ReadLong( pByteStream ); // Read in the parameters. parameters = NETWORK_ReadString( pByteStream ); @@ -10015,7 +10015,7 @@ reason = NETWORK_ReadString( pByteStream ); // Begin the vote! - CALLVOTE_BeginVote( command, parameters, reason, ulVoteCaller ); + CALLVOTE_BeginVote( ulCommand, parameters, reason, ulVoteCaller ); } //***************************************************************************** diff --git a/src/d_main.cpp b/src/d_main.cpp --- a/src/d_main.cpp +++ b/src/d_main.cpp @@ -147,6 +147,7 @@ #include "g_shared/pwo.h" #include "win32/g15/g15.h" +#include "callvotetype.h" EXTERN_CVAR(Bool, hud_althud) void DrawHUD(); @@ -2737,6 +2738,9 @@ // [BB] At the moment Skulltag still doesn't use the new ZDoom TeamLibrary class. TEAMINFO_Init (); + // [Dusk] Initialize vote definitions + VOTEDEF_Construct(); + FActorInfo::StaticInit (); // [GRB] Initialize player class list diff --git a/src/g_level.cpp b/src/g_level.cpp --- a/src/g_level.cpp +++ b/src/g_level.cpp @@ -261,7 +261,6 @@ // // //========================================================================== - CCMD (map) { if (argv.argc() > 1) diff --git a/src/m_menu.h b/src/m_menu.h --- a/src/m_menu.h +++ b/src/m_menu.h @@ -142,6 +142,7 @@ browserslot, txslider, mnnumber, + votetype, // [Dusk] } itemtype; diff --git a/src/m_options.cpp b/src/m_options.cpp --- a/src/m_options.cpp +++ b/src/m_options.cpp @@ -115,6 +115,7 @@ // [ZZ] PWO header file #include "g_shared/pwo.h" +#include "callvotetype.h" // EXTERNAL FUNCTION PROTOTYPES -------------------------------------------- @@ -201,6 +202,12 @@ static LONG g_lSavedColor; static bool g_bSwitchColorBack; +// [BB] +static TArray SkirmishLevels; + +// [BB] +void InitSkirmishLevelList(); + value_t YesNo[2] = { { 0.0, "No" }, { 1.0, "Yes" } @@ -1827,8 +1834,10 @@ if ( !bAllowBots && ( players[lPlayer].bIsBot )) return ( false ); +/* if ( lPlayer == consoleplayer ) return ( false ); +*/ return ( true ); } @@ -1946,221 +1955,26 @@ //==================================================================================== // -// Call Vote-->Kick Player Menu -// -//==================================================================================== - -CVAR( String, menu_votereason, "", 0 ); - -void kickplayermenu_Kick( void ); - -//***************************************************************************** -// -static menuitem_t kickplayermenu_Items[] = -{ - { discretes,"Player", {&menu_playerslider_idx}, {1.0}, {0.0}, {0.0}, {NULL} }, - { redtext, " ", {NULL}, {0.0}, {0.0}, {0.0}, {NULL} }, - { string, "Reason for kicking:",{&menu_votereason}, {0.0}, {0.0}, {0.0}, {NULL} }, - { more, "Kick!", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)kickplayermenu_Kick} }, -}; - -// [BB, RC] Line number of the "Player:" entry from kickplayermenu_Items. If the line number is changed, the value has to be adjusted. -#define KICKPLAYER_SLIDER_LOCATION 0 - -//***************************************************************************** -// -menu_t KickPlayerMenu = { - "KICK A PLAYER", - 0, - countof(kickplayermenu_Items), - 0, - kickplayermenu_Items, - 0, - 0, -}; - -//***************************************************************************** -// -void kickplayermenu_Kick( void ) -{ - // Clean the name of color codes. - FString Name = AvailablePlayers[menu_playerslider_idx].name.GetChars( ); - V_RemoveColorCodes( Name ); - V_EscapeBacklashes( Name ); - - FString Reason = menu_votereason.GetGenericRep( CVAR_String ).String; - V_EscapeBacklashes( Reason ); - - // Execute the command. - char szString[256]; - sprintf( szString, "callvote kick \"%s\" \"%s\"", Name.Left( 96 ).GetChars(), Reason.Left( 25 ).GetChars()); - AddCommandString( szString ); - M_ClearMenus( ); -} - -//***************************************************************************** -// -void kickplayermenu_Show( void ) -{ - if ( SERVER_CountPlayers( false ) < 2 ) - { - M_ClearMenus( ); - M_StartMessage( "There is nobody else here to kick!\n\npress any key.", NULL ); - return; - } - - // Set up the player selection slider. - playerslider_BuildList( false ); - kickplayermenu_Items[KICKPLAYER_SLIDER_LOCATION].b.numvalues = static_cast(AvailablePlayers.Size()); - kickplayermenu_Items[KICKPLAYER_SLIDER_LOCATION].e.valuestrings = &AvailablePlayers[0]; - - M_SwitchMenu( &KickPlayerMenu ); -} - -//==================================================================================== -// -// Call Vote-->Map Menu -// -//==================================================================================== - -CVAR( String, menu_mapvotemap, "", 0 ); -CVAR( Bool, menu_mapvoteintermission, false, 0 ); - -//***************************************************************************** -// -void mapvotemenu_Vote( void ) -{ - // Sanitize the inputs. - FString Map = menu_mapvotemap.GetGenericRep( CVAR_String ).String; - FString Reason = menu_votereason.GetGenericRep( CVAR_String ).String; - V_EscapeBacklashes( Map ); - V_EscapeBacklashes( Reason ); - - if ( !Map.Len( ) ) - { - Printf( "You didn't specify a map!\n" ); - return; - } - - // Execute the command. - char szString[256]; - sprintf( szString, "callvote %s %s \"%s\"", ( menu_mapvoteintermission.GetGenericRep( CVAR_Bool ).Bool ? "changemap" : "map" ), Map.Left( 128 ).GetChars(), Reason.Left( 25 ).GetChars() ); - AddCommandString( szString ); - M_ClearMenus( ); -} - -//***************************************************************************** -// -static menuitem_t mapvotemenu_Items[] = -{ - { string, "Map", {&menu_mapvotemap}, {0.0}, {0.0}, {0.0}, {NULL} }, - { discrete, "Intermission", {&menu_mapvoteintermission}, {2.0}, {0.0}, {0.0}, {YesNo} }, - { redtext, " ", {NULL}, {0.0}, {0.0}, {0.0}, {NULL} }, - { string, "Reason for change:",{&menu_votereason}, {0.0}, {0.0}, {0.0}, {NULL} }, - { more, "Vote!", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)mapvotemenu_Vote} }, -}; - -//***************************************************************************** -// -menu_t MapVoteMenu = { - "CHANGE MAP", - 0, - countof(mapvotemenu_Items), - 0, - mapvotemenu_Items, - 0, - 0, -}; - -//***************************************************************************** -// -void mapvotemenu_Show( void ) -{ - M_SwitchMenu( &MapVoteMenu ); -} - -//==================================================================================== -// -// Call Vote-->Limit Menu -// -//==================================================================================== - -//***************************************************************************** -// -value_t limitvote_Types[5] = { - { 0.0, "fraglimit" }, - { 1.0, "timelimit" }, - { 2.0, "winlimit" }, - { 3.0, "duellimit" }, - { 4.0, "pointlimit" } -}; - -//***************************************************************************** -// -CVAR( Int, menu_limitvote_type, 0, 0 ); -CVAR( String, menu_limitvote_value, "", 0 ); - -//***************************************************************************** -// -void limitvotemenu_Vote( void ) -{ - // Sanitize the inputs. - int iVoteType = menu_limitvote_type.GetGenericRep( CVAR_Int ).Int; - int iLimit = atoi( menu_limitvote_value.GetGenericRep( CVAR_String ).String ); - FString Reason = menu_votereason.GetGenericRep( CVAR_String ).String; - V_EscapeBacklashes( Reason ); - - if ( iVoteType >= 5 || iVoteType < 0 ) - return; - - // Execute the command. - char szString[512]; - sprintf( szString, "callvote %s %d \"%s\"", limitvote_Types[iVoteType].name, iLimit, Reason.Left( 25 ).GetChars() ); - AddCommandString( szString ); - M_ClearMenus( ); -} - -//***************************************************************************** -// -static menuitem_t limitvotemenu_Items[] = -{ - { discrete, "Type of limit", {&menu_limitvote_type}, {5.0}, {0.0}, {0.0}, {limitvote_Types} }, - { string, "New value", {&menu_limitvote_value}, {0.0}, {0.0}, {0.0}, {NULL} }, - { redtext, " ", {NULL}, {0.0}, {0.0}, {0.0}, {NULL} }, - { string, "Reason for change:",{&menu_votereason}, {0.0}, {0.0}, {0.0}, {NULL} }, - { more, "Vote!", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)limitvotemenu_Vote} }, -}; - -//***************************************************************************** -// -menu_t limitvoteMenu = { - "CHANGE LIMIT", - 0, - countof(limitvotemenu_Items), - 0, - limitvotemenu_Items, - 0, - 0, -}; - -//***************************************************************************** -// -void limitvotemenu_Show( void ) -{ - M_SwitchMenu( &limitvoteMenu ); -} - -//==================================================================================== -// // Call Vote Menu // //==================================================================================== +// [TP] +CVAR( Int, menu_votetype, 0, 0 ) +CVAR( Int, menu_voteargument, 0, 0 ) +CVAR( Float, menu_votefloatargument, 0, 0 ) +CVAR( String, menu_votestringargument, "", 0 ) +CVAR( String, menu_votereason, "", 0 ) +static void M_VoteTypeChanged( bool first ); +static void votemenu_go(); + static menuitem_t CallVoteItems[] = { - { more, "Kick a player", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)kickplayermenu_Show} }, - { more, "Change the map", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)mapvotemenu_Show} }, - { more, "Change a limit", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)limitvotemenu_Show} }, + { votetype, "Vote action", {&menu_votetype}, {0.0}, {100.0}, {1.0}, {NULL} }, + { string, "", {&menu_voteargument}, {0.0}, {0.0}, {0.0}, {NULL} }, + { string, "Reason for vote", {&menu_votereason}, {0.0}, {0.0}, {0.0}, {NULL} }, + { redtext, " ", {NULL}, {0.0}, {0.0}, {0.0}, {NULL} }, + { more, "Call the vote", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *) votemenu_go} }, }; menu_t CallVoteMenu = { @@ -2173,6 +1987,182 @@ 0, }; +//***************************************************************************** +// +void M_CallVote( void ) +{ + // Don't allow a vote unless the player is a client. + if (( NETWORK_GetState( ) != NETSTATE_CLIENT ) + || ( CLIENT_GetConnectionState() != CTS_ACTIVE )) + { + M_ClearMenus(); + M_StartMessage( "You must be in a multiplayer game to call a vote.\n\npress any key.", NULL ); + return; + } + + // [TP] Init the skirmish level list as we're using it for map votes + InitSkirmishLevelList(); + M_VoteTypeChanged( true ); + M_SwitchMenu( &CallVoteMenu ); +} + +//***************************************************************************** +// +// [TP] Hmm. Now that votes are generalized the argument passed is of variable +// type. Thus, we have to change the argument field dynamically based on the type +// of the argument of the vote we scrolled to. +// +// This also resets the argument, first because the argument of one type may be +// out of bounds or otherwise be of completely different meaning for another. +// +static void M_VoteTypeChanged( bool first ) +{ + VoteClass* def = VOTEDEF_FindTypeByIndex( menu_votetype ); + + if ( def == NULL ) + return; + + VoteArgumentType argtype = def->argumentType(); + menuitem_t* item = &CallVoteItems[1]; + item->label = def->argumentLabel().GetChars(); + + switch ( argtype ) + { + case VOTEARG_Player: + // Set up the player selection slider. + playerslider_BuildList( false ); + item->type = discretes; + item->a.intcvar = &menu_voteargument; + item->b.numvalues = float( AvailablePlayers.Size() ); + item->e.valuestrings = &AvailablePlayers[0]; + + if ( item->label[0] == '\0' ) + item->label = "Player"; + + if ( first == false ) + menu_voteargument = AvailablePlayers[0].value; + break; + + case VOTEARG_Int: + case VOTEARG_Float: + item->type = ( def->flags() & VOTEF_MenuSlider ) ? slider : number; + item->a.cvar = &menu_votefloatargument; + item->b.min = def->menuMinimum(); + item->c.max = def->menuMaximum(); + item->d.step = def->menuIncrement(); + item->e.values = NULL; + + if ( item->label[0] == '\0' ) + item->label = "Value"; + + if ( first == false ) + menu_votefloatargument = def->minimum(); + break; + + case VOTEARG_Level: + item->type = discretes; + item->a.intcvar = &menu_voteargument; + item->b.numvalues = float( SkirmishLevels.Size() ); + item->e.valuestrings = ( SkirmishLevels.Size() > 0 ) ? &SkirmishLevels[0] : NULL; + + if ( item->label[0] == '\0' ) + item->label = "Level:"; + + if ( first == false ) + menu_voteargument = 0; + break; + + case VOTEARG_String: + item->type = string; + item->a.stringcvar = &menu_votestringargument; + item->b.min = 0.0f; + item->c.max = 0.0f; + item->d.step = 0.0f; + item->e.values = NULL; + break; + + case VOTEARG_NumArgTypes: + item->type = redtext; + item->label = ""; + break; + } +} + +static void votemenu_go() +{ + VoteClass* def = VOTEDEF_FindTypeByIndex( menu_votetype ); + + if ( def == NULL ) + return; + + VoteStateData in; + VoteValidateResult out; + in.type = VOTEDEF_FindTypeByIndex( menu_votetype ); + in.caller = consoleplayer; + + // [TP] Determine the argument to callvote. + if ( def->hasArgument() ) + { + if ( def->argumentType() == VOTEARG_Level ) + { + // [TP] If this is a map, we need to pass the string argument + in.arg = wadlevelinfos[menu_voteargument].mapname; + } + else if (( def->argumentType() == VOTEARG_Player ) + && (( def->flags() & VOTEF_PlayerAsIndex ) == 0 )) + { + // [TP] A player's name is wanted - pass that. + in.arg = players[menu_voteargument].userinfo.netname; + V_ColorizeString( in.arg ); + V_RemoveColorCodes( in.arg ); + } + else if ( def->argumentType() == VOTEARG_Float ) + { + in.arg.Format( "%f", float( menu_votefloatargument )); + + // Remove trailing zeroes + if ( in.arg.IndexOf( "." ) != -1 ) + { + while ( in.arg[in.arg.Len() - 1] == '0' ) + in.arg = FString( in.arg.GetChars(), in.arg.Len() - 1 ); + + if ( in.arg[in.arg.Len() - 1] == '.' ) + in.arg = FString( in.arg.GetChars(), in.arg.Len() - 1 ); + } + } + else if ( def->argumentType() == VOTEARG_String ) + { + in.arg = menu_votestringargument; + } + else if ( def->argumentType() == VOTEARG_Int ) + { + in.arg.Format( "%d", int( menu_votefloatargument )); + } + else + { + in.arg.Format( "%d", int( menu_voteargument )); + } + } + + M_ClearMenus(); + + // [TP] Validate the vote command now + if ( VOTEDEF_Validate( in, out )) + { + CLIENTCOMMANDS_CallVote( menu_votetype, in.arg, menu_votereason ); + NETWORK_LaunchPacket( CLIENT_GetLocalBuffer( ), CLIENT_GetServerAddress( )); + NETWORK_ClearBuffer( CLIENT_GetLocalBuffer( )); + } + else + { + // [TP] Failed - tell the user why. + static char errortext[256]; + snprintf( errortext, sizeof errortext, "Couldn't call that because %s\n\npress any key.", + out.error.GetChars() ); + M_StartMessage( errortext, NULL ); + } +} + /*======================================= * * Multiplayer Menu @@ -2186,6 +2176,7 @@ void M_StartBrowserMenu( void ); void M_Spectate( void ); void M_CallVote( void ); +void M_VoteTypeChanged( bool first ); void M_ChangeTeam( void ); void M_Skirmish( void ); @@ -2199,7 +2190,7 @@ { more, "Spectate", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)M_Spectate} }, { more, "Switch teams", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)M_ChangeTeam} }, { redtext, " ", {NULL}, {0.0}, {0.0}, {0.0}, {NULL} }, - { more, "Call a vote", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)M_CallVote} }, + { more, "Call a vote", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)M_CallVote} }, { more, "Ignore a player", {NULL}, {0.0}, {0.0}, {0.0}, {(value_t *)ignoreplayermenu_Show} }, { redtext, " ", {NULL}, {0.0}, {0.0}, {0.0}, {NULL} }, { discrete, "Allow skins", {&cl_skins}, {3.0}, {0.0}, {0.0}, {AllowSkinVals} }, @@ -2239,22 +2230,6 @@ //***************************************************************************** // -void M_CallVote( void ) -{ - // Don't allow a vote unless the player is a client. - if ( NETWORK_GetState( ) != NETSTATE_CLIENT ) - { - M_ClearMenus( ); - M_StartMessage( "You must be in a multiplayer game to vote.\n\npress any key.", NULL ); - - return; - } - - M_SwitchMenu( &CallVoteMenu ); -} - -//***************************************************************************** -// bool M_SkulltagVersionDrawer( void ) { ULONG ulTextHeight; @@ -3278,9 +3253,6 @@ #define SKIRMISHITEMS_LEVEL_INDEX 0 // [BB] -static TArray SkirmishLevels; - -// [BB] void InitSkirmishLevelList() { SkirmishLevels.Clear(); @@ -5070,6 +5042,24 @@ screen->DrawText( SmallFont, CR_GREY, x, y, szString, DTA_CleanNoMove_1, true, TAG_DONE ); } break; + + // [TP] + case votetype: + { + VoteClass* def = VOTEDEF_FindTypeByIndex( *item->a.intcvar ); + FString text; + + if ( def == NULL ) + text = "UNKNOWN"; + else if ( def->description().IsNotEmpty() ) + text = def->description(); + else + text = def->name(); + + screen->DrawText( SmallFont, CR_GREY, x, y, text.GetChars(), DTA_CleanNoMove_1, true, TAG_DONE ); + } + break; + default: break; } @@ -5931,6 +5921,17 @@ S_Sound (CHAN_VOICE | CHAN_UI, "menu/change", 1, ATTN_NONE); break; + // [TP] + case votetype: + { + FIntCVar& cv = *item->a.intcvar; + int num = VOTEDEF_NumVoteTypes(); + cv = ( cv + num - 1 ) % num; + } + M_VoteTypeChanged( false ); + S_Sound( CHAN_VOICE | CHAN_UI, "menu/change", 1, ATTN_NONE ); + break; + default: break; } @@ -6363,6 +6364,16 @@ S_Sound (CHAN_VOICE | CHAN_UI, "menu/change", 1, ATTN_NONE); break; + // [TP] + case votetype: + { + FIntCVar& cv = *item->a.intcvar; + cv = ( cv + 1 ) % VOTEDEF_NumVoteTypes(); + } + M_VoteTypeChanged( false ); + S_Sound( CHAN_VOICE | CHAN_UI, "menu/change", 1, ATTN_NONE ); + break; + default: break; } diff --git a/src/network.cpp b/src/network.cpp --- a/src/network.cpp +++ b/src/network.cpp @@ -310,6 +310,8 @@ lumpsToAuthenticateMode.push_back( ALL_LUMPS ); lumpsToAuthenticate.push_back( "MAPINFO" ); lumpsToAuthenticateMode.push_back( ALL_LUMPS ); + lumpsToAuthenticate.push_back( "VOTEDEF" ); + lumpsToAuthenticateMode.push_back( ALL_LUMPS ); FString checksum, longChecksum; bool noProtectedLumpsAutoloaded = true; diff --git a/src/sv_ban.cpp b/src/sv_ban.cpp --- a/src/sv_ban.cpp +++ b/src/sv_ban.cpp @@ -600,6 +600,15 @@ //***************************************************************************** // +void SERVERBAN_BanIP ( NETADDRESS_s address, time_t duration, FString const& comment, std::string& message ) +{ + time_t expiration; + time ( &expiration ); + expiration += duration; + g_ServerBans.addEntry( NETWORK_AddressToStringIgnorePort ( address ), NULL, comment.GetChars(), message, expiration ); + serverban_KickBannedPlayers(); +} + CCMD( addban ) { if ( argv.argc( ) < 3 ) diff --git a/src/sv_ban.h b/src/sv_ban.h --- a/src/sv_ban.h +++ b/src/sv_ban.h @@ -67,6 +67,7 @@ IPList *SERVERBAN_GetBanList( void ); IPList *SERVERBAN_GetBanExemptionList( void ); void SERVERBAN_BanPlayer( ULONG ulPlayer, const char *pszBanLength, const char *pszBanReason ); +void SERVERBAN_BanIP ( NETADDRESS_s address, time_t duration, FString const& comment, std::string& message ); //-------------------------------------------------------------------------------------------------------------------------------------------------- //-- EXTERNAL CONSOLE VARIABLES -------------------------------------------------------------------------------------------------------------------- diff --git a/src/sv_commands.cpp b/src/sv_commands.cpp --- a/src/sv_commands.cpp +++ b/src/sv_commands.cpp @@ -3525,17 +3525,17 @@ //***************************************************************************** //***************************************************************************** // -void SERVERCOMMANDS_CallVote( ULONG ulPlayer, FString Command, FString Parameters, FString Reason, ULONG ulPlayerExtra, ULONG ulFlags ) +void SERVERCOMMANDS_CallVote( ULONG ulPlayer, ULONG Command, FString Parameters, FString Reason, ULONG ulPlayerExtra, ULONG ulFlags ) { if ( PLAYER_IsValidPlayer( ulPlayer ) == false ) return; - NetCommand command ( SVC_CALLVOTE ); - command.addByte ( ulPlayer ); - command.addString ( Command.GetChars() ); - command.addString ( Parameters.GetChars() ); - command.addString ( Reason.GetChars() ); - command.sendCommandToClients ( ulPlayerExtra, ulFlags ); + NetCommand command( SVC_CALLVOTE ); + command.addByte( ulPlayer ); + command.addLong( Command ); + command.addString( Parameters ); + command.addString( Reason ); + command.sendCommandToClients( ulPlayerExtra, ulFlags ); } //***************************************************************************** diff --git a/src/sv_commands.h b/src/sv_commands.h --- a/src/sv_commands.h +++ b/src/sv_commands.h @@ -273,7 +273,7 @@ void SERVERCOMMANDS_StopSectorSequence( sector_t *pSector, ULONG ulPlayerExtra = MAXPLAYERS, ULONG ulFlags = 0 ); // Voting commands. These handle the voting. -void SERVERCOMMANDS_CallVote( ULONG ulPlayer, FString Command, FString Parameters, FString Reason, ULONG ulPlayerExtra = MAXPLAYERS, ULONG ulFlags = 0 ); +void SERVERCOMMANDS_CallVote( ULONG ulPlayer, ULONG Command, FString Parameters, FString Reason, ULONG ulPlayerExtra = MAXPLAYERS, ULONG ulFlags = 0 ); void SERVERCOMMANDS_PlayerVote( ULONG ulPlayer, bool bVoteYes, ULONG ulPlayerExtra = MAXPLAYERS, ULONG ulFlags = 0 ); void SERVERCOMMANDS_VoteEnded( bool bVotePassed, ULONG ulPlayerExtra = MAXPLAYERS, ULONG ulFlags = 0 ); diff --git a/src/sv_main.cpp b/src/sv_main.cpp --- a/src/sv_main.cpp +++ b/src/sv_main.cpp @@ -117,6 +117,7 @@ #include "po_man.h" #include "network/cl_auth.h" #include "network/sv_auth.h" +#include "callvotetype.h" //***************************************************************************** // MISC CRAP THAT SHOULDN'T BE HERE BUT HAS TO BE BECAUSE OF SLOPPY CODING @@ -6048,68 +6049,22 @@ } // Check if the specific type of vote is allowed. - bool bVoteAllowed = false; - switch ( ulVoteCmd ) - { - case VOTECMD_KICK: - - bVoteAllowed = !sv_nokickvote; - sprintf( szCommand, "kick" ); - break; - - case VOTECMD_KICKFROMGAME: - - bVoteAllowed = !sv_noforcespecvote; - sprintf( szCommand, "forcespec" ); - break; - - case VOTECMD_MAP: - - bVoteAllowed = !sv_nomapvote; - sprintf( szCommand, "map" ); - break; - case VOTECMD_CHANGEMAP: - - bVoteAllowed = !sv_nochangemapvote; - sprintf( szCommand, "changemap" ); - break; - case VOTECMD_FRAGLIMIT: - - bVoteAllowed = !sv_nofraglimitvote; - sprintf( szCommand, "fraglimit" ); - break; - case VOTECMD_TIMELIMIT: - - bVoteAllowed = !sv_notimelimitvote; - sprintf( szCommand, "timelimit" ); - break; - case VOTECMD_WINLIMIT: - - bVoteAllowed = !sv_nowinlimitvote; - sprintf( szCommand, "winlimit" ); - break; - case VOTECMD_DUELLIMIT: - - bVoteAllowed = !sv_noduellimitvote; - sprintf( szCommand, "duellimit" ); - break; - case VOTECMD_POINTLIMIT: - - bVoteAllowed = !sv_nopointlimitvote; - sprintf( szCommand, "pointlimit" ); - break; - default: - - return ( false ); - } - - // Begin the vote, if that type is allowed. - if ( bVoteAllowed ) - CALLVOTE_BeginVote( szCommand, Parameters, Reason, g_lCurrentClient ); - else - SERVER_PrintfPlayer( PRINT_HIGH, g_lCurrentClient, "%s votes are disabled on this server.\n", szCommand ); - - return ( false ); + // [Dusk] Generalized for custom vote types. + VoteClass* votetype = VOTEDEF_FindTypeByIndex( ulVoteCmd ); + + if( votetype == NULL ) + return false; // Unknown vote type + + if( votetype->forbidCVar()->GetGenericRep( CVAR_Bool ).Bool ) + { + SERVER_PrintfPlayer( PRINT_HIGH, g_lCurrentClient, "%s votes are disabled on this server.\n", + votetype->name().GetChars( )); + return false; + } + + // Begin the vote + CALLVOTE_BeginVote( ulVoteCmd, Parameters, Reason, g_lCurrentClient ); + return false; } //***************************************************************************** diff --git a/wadsrc/static/votedef.txt b/wadsrc/static/votedef.txt new file mode 100644 --- /dev/null +++ b/wadsrc/static/votedef.txt @@ -0,0 +1,108 @@ +// +// Kick a player from the server and ban for 10 minutes +// +VoteType native kick +{ + Argument = player; + ForbidCVar = "sv_nokickvote"; + Description = "Kick a player"; + NotOnSelf; + NotOnAdmin; + NoPassedLimit; +} + +// +// Remove a player from game to spectators +// +VoteType native forcespec +{ + Argument = player; + ForbidCVar = "sv_noforcespecvote"; + Description = "Force to spectate"; + NotOnSelf; + NotOnAdmin; + NotOnSpectators; + NoPassedLimit; +} + +// +// Set the frag limit +// +VoteType native fraglimit +{ + Description = "Set frag limit"; + Argument = int( 0, 65535 ); + ArgumentLabel = "New limit"; + MenuRange = 0, 100; + ForbidCVar = "sv_nofraglimitvote"; +} + +// +// Set the LMS win limit +// +VoteType native winlimit +{ + Description = "Set LMS win limit"; + Argument = int( 0, 255 ); + ArgumentLabel = "New limit"; + MenuRange = 0, 100; + ForbidCVar = "sv_nowinlimitvote"; +} + +// +// Set the time limit +// +VoteType native timelimit +{ + Argument = float( 0, 255 ); + Description = "Set time limit"; + ArgumentLabel = "New limit"; + MenuRange = 0, 100; + ForbidCVar = "sv_notimelimitvote"; +} + +// +// Set the point limit +// +VoteType native pointlimit +{ + Description = "Set point limit"; + Argument = int( 0, 65535 ); + ArgumentLabel = "New limit"; + MenuRange = 0, 100; + ForbidCVar = "sv_nopointlimitvote"; +} + +// +// Set the duel win limit +// +VoteType native duellimit +{ + Description = "Set duel win limit"; + Argument = int( 0, 255 ); + ArgumentLabel = "New limit"; + MenuRange = 0, 100; + ForbidCVar = "sv_noduellimitvote"; +} + +// +// Change to a given level gracefully with intermission +// +VoteType native changemap +{ + Description = "Change level"; + ForbidCVar = "sv_nochangemapvote"; + Argument = map; + MapInRotation; +} + +// +// Restart the game on a given level +// +VoteType native map +{ + Description = "Restart game"; + ForbidCVar = "sv_nomapvote"; + Argument = map; + MapInRotation; +}