mirror of
https://github.com/KartKrewDev/RingRacers.git
synced 2025-10-30 08:01:28 +00:00
d8ea8c0fe1
Currently just plays the squishy "nope" sound for "KICK PLAYER?", all others are functional Shows whether vote is active or the cooldown is too recent (via numerical timer) as reasons for why you can't select it
354 lines
9.9 KiB
C
354 lines
9.9 KiB
C
// DR. ROBOTNIK'S RING RACERS
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) by Sally "TehRealSalt" Cochenour
|
|
// Copyright (C) by Kart Krew
|
|
//
|
|
// This program is free software distributed under the
|
|
// terms of the GNU General Public License, version 2.
|
|
// See the 'LICENSE' file for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file k_zvote.h
|
|
/// \brief Player callable mid-game vote
|
|
|
|
#ifndef __K_ZVOTE__
|
|
#define __K_ZVOTE__
|
|
|
|
#include "doomdef.h"
|
|
#include "doomstat.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define ZVOTE_GUI_CONFIRM (TICRATE)
|
|
#define ZVOTE_GUI_SUCCESS (3 * TICRATE)
|
|
#define ZVOTE_GUI_SLIDE (TICRATE / 2)
|
|
|
|
typedef enum
|
|
{
|
|
MVT_KICK, // Kick another player in the server
|
|
MVT_RTV, // Exit level early
|
|
MVT_RUNITBACK, // Restart level fresh
|
|
MVT__MAX, // Total number of vote types
|
|
} midVoteType_e;
|
|
|
|
extern const char *g_midVoteTypeNames[MVT__MAX];
|
|
|
|
struct midVoteGUI_t
|
|
{
|
|
tic_t slide; // Slide in when Z is first pressed.
|
|
tic_t confirm; // How long this player has held Z.
|
|
boolean unpress; // Z button needs unpressed to continue accepting input.
|
|
};
|
|
|
|
struct midVote_t
|
|
{
|
|
boolean active; // If true, a vote is currently running.
|
|
|
|
player_t *caller; // The player that called for this vote.
|
|
player_t *victim; // If non-NULL, then this vote targets a player (kicks), don't let them vote on it.
|
|
boolean votes[MAXPLAYERS]; // Votes recieved from each player.
|
|
|
|
midVoteType_e type; // Type of vote that was called, see midVoteType_e.
|
|
INT32 variable; // Extra variable, unique purpose for each vote type.
|
|
|
|
tic_t time; // Time until the vote times out and fails.
|
|
tic_t delay; // Delay before another vote is allowed to be called.
|
|
|
|
tic_t end; // Ended animation, wait a second before activating callback.
|
|
UINT8 endVotes; // How many votes it got when the vote went through.
|
|
UINT8 endRequired; // How many votes were required when the vote went through.
|
|
|
|
midVoteGUI_t gui[MAXSPLITSCREENPLAYERS]; // GUI / inputs struct
|
|
};
|
|
|
|
extern midVote_t g_midVote;
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_MidVoteTypeUsesVictim(midVoteType_e voteType)
|
|
|
|
Specifies whenever or not a vote type is intended
|
|
to specify a "victim", or a player that would be
|
|
negatively affected by the vote.
|
|
|
|
Input Arguments:-
|
|
voteType - The vote type to check.
|
|
|
|
Return:-
|
|
true if it uses a victim, otherwise false.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_MidVoteTypeUsesVictim(midVoteType_e voteType);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_SendCallMidVote(midVoteType_e voteType, INT32 voteVariable)
|
|
|
|
Prepares and sends net packet for calling a midvote.
|
|
|
|
Input Arguments:-
|
|
voteType - The type of vote a local player is trying to call.
|
|
variable - Extra arguments for the vote type.
|
|
|
|
Return:-
|
|
N/A
|
|
--------------------------------------------------*/
|
|
|
|
void K_SendCallMidVote(midVoteType_e voteType, INT32 voteVariable);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_RegisterMidVoteCVars(void);
|
|
|
|
Registers the console variables related to
|
|
the Z-voting systems.
|
|
--------------------------------------------------*/
|
|
|
|
void K_RegisterMidVoteCVars(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_ResetMidVote(void);
|
|
|
|
Resets Z-voting variables to their default state.
|
|
--------------------------------------------------*/
|
|
|
|
void K_ResetMidVote(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_AnyMidVotesAllowed(void);
|
|
|
|
Determines if the server has enabled any types
|
|
of Z-votes. If this is false, then any menu options
|
|
for Z-voting should be disabled.
|
|
|
|
Input Arguments:-
|
|
N/A
|
|
|
|
Return:-
|
|
true if any vote types are enabled, otherwise false.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_AnyMidVotesAllowed(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
midVoteType_e K_GetNextCallableMidVote(midVoteType_e seed, boolean backwards)
|
|
|
|
Gets the next enabled Z-vote type in the list.
|
|
|
|
Input Arguments:-
|
|
seed - position in the list to start with
|
|
backwards - if true, traverses list in reverse order
|
|
|
|
Return:-
|
|
next Z-vote id if any vote types are enabled, otherwise MVT__MAX.
|
|
--------------------------------------------------*/
|
|
|
|
midVoteType_e K_GetNextAllowedMidVote(midVoteType_e seed, boolean backwards);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_PlayerIDAllowedInMidVote(const UINT8 id);
|
|
|
|
Determines if this player ID is allowed to
|
|
vote or not.
|
|
|
|
Input Arguments:-
|
|
id - Player index to check.
|
|
|
|
Return:-
|
|
true if the player index can vote, otherwise false.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_PlayerIDAllowedInMidVote(const UINT8 id);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
UINT8 K_RequiredMidVotes(void);
|
|
|
|
Calculates the number of votes needed for thr
|
|
vote to go through (aka, the "quorum"), as
|
|
per the server's settings. Usually at least
|
|
2 players are required for the vote to go through.
|
|
|
|
Input Arguments:-
|
|
N/A
|
|
|
|
Return:-
|
|
Number of player votes needed before we should
|
|
call K_MidVoteSuccess.
|
|
--------------------------------------------------*/
|
|
|
|
UINT8 K_RequiredMidVotes(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_PlayerIDMidVoted(const UINT8 id);
|
|
|
|
Determines if this player ID has voted for
|
|
the current issue or not. Is mostly safety
|
|
checks for g_midVote.votes[id], to force
|
|
the player who called the vote to vote for it,
|
|
the victim being affected to vote against,
|
|
and invalid players not having a vote.
|
|
|
|
Input Arguments:-
|
|
id - Player index to check.
|
|
|
|
Return:-
|
|
true if the player index voted yes, otherwise false.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_PlayerIDMidVoted(const UINT8 id);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
UINT8 K_CountMidVotes(void);
|
|
|
|
Counts the total number of votes in favor of
|
|
the current issue.
|
|
|
|
Input Arguments:-
|
|
N/A
|
|
|
|
Return:-
|
|
Number of votes that agree.
|
|
--------------------------------------------------*/
|
|
|
|
UINT8 K_CountMidVotes(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_MinimalCheckNewMidVote(midVoteType_e type)
|
|
|
|
Returns if the variables given are a valid state for
|
|
pause menu Z-vote flow.
|
|
|
|
Input Arguments:-
|
|
type - The type of vote they're trying to call.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_MinimalCheckNewMidVote(midVoteType_e type);
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_AllowNewMidVote(player_t *caller, midVoteType_e type, INT32 variable, player_t *victim);
|
|
|
|
Returns if the variables given are a valid state for
|
|
K_InitNewMidVote. Creates console alerts if it's not.
|
|
|
|
Input Arguments:-
|
|
caller - The player that is trying to call for a vote.
|
|
type - The type of vote they're trying to call.
|
|
variable - Extra arguments for the vote type.
|
|
victim - If this is a vote that negatively affects a
|
|
player, the player being affected would go here.
|
|
|
|
Return:-
|
|
true if we can start a new vote, otherwise false.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_AllowNewMidVote(player_t *caller, midVoteType_e type, INT32 variable, player_t *victim);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_InitNewMidVote(player_t *caller, midVoteType_e type, INT32 variable, player_t *victim);
|
|
|
|
Tries to start a new Z-vote, or mid-game vote. This will
|
|
handle everything needed to be initialized. Also calls
|
|
K_AllowNewMidVote to prevent invalid states from happening.
|
|
|
|
Input Arguments:-
|
|
caller - The player that is trying to call for a vote.
|
|
type - The type of vote they're trying to call.
|
|
variable - Extra arguments for the vote type.
|
|
victim - If this is a vote that negatively affects a
|
|
player, the player being affected would go here.
|
|
|
|
Return:-
|
|
N/A
|
|
--------------------------------------------------*/
|
|
|
|
void K_InitNewMidVote(player_t *caller, midVoteType_e type, INT32 variable, player_t *victim);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_MidVoteFinalize(fixed_t delayMul);
|
|
|
|
Ran when a vote is totally done, and we need to
|
|
reset the struct and set the delay timer.
|
|
--------------------------------------------------*/
|
|
|
|
void K_MidVoteFinalize(fixed_t delayMul);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_MidVoteSuccess(void);
|
|
|
|
Ran whenever a vote meets the quorum, activates
|
|
the effect that the current vote is intended to
|
|
have.
|
|
--------------------------------------------------*/
|
|
|
|
void K_MidVoteSuccess(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_MidVoteFailure(void);
|
|
|
|
Ran when a vote times out without meeting the quorum.
|
|
Doesn't do anything but set a very long delay before
|
|
accepting another vote.
|
|
--------------------------------------------------*/
|
|
|
|
void K_MidVoteFailure(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_TickMidVote(void);
|
|
|
|
Run every game tick when in a server to process
|
|
the vote in progress, if it exists.
|
|
--------------------------------------------------*/
|
|
|
|
void K_TickMidVote(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_UpdateMidVotePatches(void);
|
|
|
|
Caches the patches needed for drawing the
|
|
HUD elements for Z-voting.
|
|
--------------------------------------------------*/
|
|
|
|
void K_UpdateMidVotePatches(void);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
const char *K_GetMidVoteLabel(midVoteType_e i)
|
|
|
|
Input Arguments:-
|
|
i - id in the list to retrieve label for
|
|
|
|
Return:-
|
|
label associated with that id, or a sensible default (not NULL)
|
|
--------------------------------------------------*/
|
|
|
|
const char *K_GetMidVoteLabel(midVoteType_e i);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
void K_DrawMidVote(void);
|
|
|
|
Handles drawing the HUD elements for Z-voting.
|
|
--------------------------------------------------*/
|
|
|
|
void K_DrawMidVote(void);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif // __K_ZVOTE__
|