#include "mapvoting.qh"
+#include <server/defs.qh>
+#include <server/miscfunctions.qh>
#include "g_world.qh"
#include "command/cmd.qh"
#include "command/getreplies.qh"
#include <common/net_linked.qh>
#include "../common/mapinfo.qh"
#include "../common/playerstats.qh"
+#include <common/state.qh>
#include "../common/util.qh"
float mapvote_nextthink;
float mapvote_keeptwotime;
float mapvote_timeout;
-const float MAPVOTE_SCREENSHOT_DIRS_COUNT = 4;
+const int MAPVOTE_SCREENSHOT_DIRS_COUNT = 4;
string mapvote_screenshot_dirs[MAPVOTE_SCREENSHOT_DIRS_COUNT];
-float mapvote_screenshot_dirs_count;
+int mapvote_screenshot_dirs_count;
-float mapvote_count;
-float mapvote_count_real;
+int mapvote_count;
+int mapvote_count_real;
string mapvote_maps[MAPVOTE_COUNT];
-float mapvote_maps_screenshot_dir[MAPVOTE_COUNT];
+int mapvote_maps_screenshot_dir[MAPVOTE_COUNT];
string mapvote_maps_pakfile[MAPVOTE_COUNT];
-float mapvote_maps_suggested[MAPVOTE_COUNT];
+bool mapvote_maps_suggested[MAPVOTE_COUNT];
string mapvote_suggestions[MAPVOTE_COUNT];
-float mapvote_suggestion_ptr;
-float mapvote_voters;
-float mapvote_selections[MAPVOTE_COUNT];
-float mapvote_maps_flags[MAPVOTE_COUNT];
-float mapvote_run;
-float mapvote_detail;
-float mapvote_abstain;
-.float mapvote;
+int mapvote_suggestion_ptr;
+int mapvote_voters;
+int mapvote_selections[MAPVOTE_COUNT];
+int mapvote_maps_flags[MAPVOTE_COUNT];
+bool mapvote_run;
+bool mapvote_detail;
+bool mapvote_abstain;
+.int mapvote;
entity mapvote_ent;
return flag | GTV_AVAILABLE;
}
-float GameTypeVote_GetMask()
+int GameTypeVote_GetMask()
{
- float n, j, gametype_mask;
+ int n, j, gametype_mask;
n = tokenizebyseparator(autocvar_sv_vote_gametype_options, " ");
n = min(MAPVOTE_COUNT, n);
gametype_mask = 0;
void MapVote_ClearAllVotes()
{
- FOREACH_CLIENT(true, LAMBDA(it.mapvote = 0));
+ FOREACH_CLIENT(true, { it.mapvote = 0; });
}
void MapVote_UnzoneStrings()
{
- float j;
- for(j = 0; j < mapvote_count; ++j)
+ for(int j = 0; j < mapvote_count; ++j)
{
- if ( mapvote_maps[j] )
- {
- strunzone(mapvote_maps[j]);
- mapvote_maps[j] = string_null;
- }
- if ( mapvote_maps_pakfile[j] )
- {
- strunzone(mapvote_maps_pakfile[j]);
- mapvote_maps_pakfile[j] = string_null;
- }
+ strfree(mapvote_maps[j]);
+ strfree(mapvote_maps_pakfile[j]);
}
}
string MapVote_Suggest(entity this, string m)
{
- float i;
+ int i;
if(m == "")
return "That's not how to use this command.";
if(!autocvar_g_maplist_votable_suggestions)
return strcat("Suggestion of ", m, " accepted.");
}
-void MapVote_AddVotable(string nextMap, float isSuggestion)
+void MapVote_AddVotable(string nextMap, bool isSuggestion)
{
- float j, i, o;
+ int j, i, o;
string pakfile, mapfile;
if(nextMap == "")
void MapVote_Init()
{
- float i;
- float nmax, smax;
+ int i;
+ int nmax, smax;
MapVote_ClearAllVotes();
MapVote_UnzoneStrings();
mapvote_count = 0;
mapvote_detail = !autocvar_g_maplist_votable_nodetail;
- mapvote_abstain = autocvar_g_maplist_votable_abstain;
+ mapvote_abstain = boolean(autocvar_g_maplist_votable_abstain);
if(mapvote_abstain)
nmax = min(MAPVOTE_COUNT - 1, autocvar_g_maplist_votable);
mapvote_count_real = mapvote_count;
if(mapvote_abstain)
- MapVote_AddVotable("don't care", 0);
+ MapVote_AddVotable("don't care", false);
//dprint("mapvote count is ", ftos(mapvote_count), "\n");
bool MapVote_SendEntity(entity this, entity to, int sf)
{
- float i;
+ int i;
if(sf & 1)
sf &= ~2; // if we send 1, we don't need to also send 2
mapvote_ent.SendFlags |= 4;
}
-float MapVote_Finished(float mappos)
+bool MapVote_Finished(int mappos)
{
if(alreadychangedlevel)
return false;
string result;
- float i;
- float didntvote;
+ int i;
+ int didntvote;
if(autocvar_sv_eventlog)
{
GameLogEcho(strcat(":vote:suggestion_accepted:", mapvote_maps[mappos]));
}
- FOREACH_CLIENT(IS_REAL_CLIENT(it), LAMBDA(FixClientCvars(it)));
+ FOREACH_CLIENT(IS_REAL_CLIENT(it), { FixClientCvars(it); });
if(gametypevote)
{
});
}
-float MapVote_CheckRules_2()
+bool MapVote_CheckRules_2()
{
- float i;
- float firstPlace, secondPlace, currentPlace;
- float firstPlaceVotes, secondPlaceVotes, currentVotes;
- float mapvote_voters_real;
+ int i;
+ int firstPlace, secondPlace, currentPlace;
+ int firstPlaceVotes, secondPlaceVotes, currentVotes;
+ int mapvote_voters_real;
string result;
if(mapvote_count_real == 1)
}
}
firstPlaceVotes = RandomSelection_best_priority;
- if ( autocvar_sv_vote_gametype_default_current && currentVotes == firstPlaceVotes )
+ if ( autocvar_sv_vote_gametype_default_current && firstPlaceVotes == 0 )
firstPlace = currentPlace;
else
firstPlace = RandomSelection_chosen_float;
if(mapvote_keeptwotime)
if(time > mapvote_keeptwotime || (mapvote_voters_real - firstPlaceVotes - secondPlaceVotes) < secondPlaceVotes)
{
- float didntvote;
MapVote_TouchMask();
mapvote_keeptwotime = 0;
result = strcat(":vote:keeptwo:", mapvote_maps[firstPlace]);
result = strcat(result, ":", ftos(firstPlaceVotes));
result = strcat(result, ":", mapvote_maps[secondPlace]);
result = strcat(result, ":", ftos(secondPlaceVotes), "::");
- didntvote = mapvote_voters;
+ int didntvote = mapvote_voters;
for(i = 0; i < mapvote_count; ++i)
{
didntvote -= mapvote_selections[i];
void MapVote_Tick()
{
- float totalvotes;
MapVote_CheckRules_1(); // count
if(MapVote_CheckRules_2()) // decide
return;
- totalvotes = 0;
- FOREACH_CLIENT(IS_REAL_CLIENT(it), LAMBDA(
+ int totalvotes = 0;
+ FOREACH_CLIENT(IS_REAL_CLIENT(it), {
// hide scoreboard again
- if(it.health != 2342)
+ if(GetResource(it, RES_HEALTH) != 2342)
{
- it.health = 2342;
- it.impulse = 0;
+ SetResourceExplicit(it, RES_HEALTH, 2342);
+ CS(it).impulse = 0;
msg_entity = it;
WriteByte(MSG_ONE, SVC_FINALE);
if ( !(mapvote_maps_flags[it.mapvote-1] & GTV_AVAILABLE) )
it.mapvote = 0;
// use impulses as new vote
- if(it.impulse >= 1 && it.impulse <= mapvote_count)
- if( mapvote_maps_flags[it.impulse - 1] & GTV_AVAILABLE )
+ if(CS(it).impulse >= 1 && CS(it).impulse <= mapvote_count)
+ if( mapvote_maps_flags[CS(it).impulse - 1] & GTV_AVAILABLE )
{
- it.mapvote = it.impulse;
+ it.mapvote = CS(it).impulse;
MapVote_TouchVotes(it);
}
- it.impulse = 0;
+ CS(it).impulse = 0;
if(it.mapvote)
++totalvotes;
- ));
+ });
MapVote_CheckRules_1(); // just count
}
MapVote_Tick();
}
-float GameTypeVote_SetGametype(Gametype type)
+bool GameTypeVote_SetGametype(Gametype type)
{
if (MapInfo_CurrentGametype() == type)
return true;
return true;
}
-float gametypevote_finished;
-float GameTypeVote_Finished(float pos)
+bool gametypevote_finished;
+bool GameTypeVote_Finished(int pos)
{
if(!gametypevote || gametypevote_finished)
return false;
return true;
}
-float GameTypeVote_AddVotable(string nextMode)
+bool GameTypeVote_AddVotable(string nextMode)
{
- float j;
if ( nextMode == "" || GameTypeVote_Type_FromString(nextMode) == NULL )
return false;
- for(j = 0; j < mapvote_count; ++j)
+
+ for(int j = 0; j < mapvote_count; ++j)
if(mapvote_maps[j] == nextMode)
return false;
}
-float GameTypeVote_Start()
+bool GameTypeVote_Start()
{
- float j;
MapVote_ClearAllVotes();
MapVote_UnzoneStrings();
mapvote_count = 0;
mapvote_timeout = time + autocvar_sv_vote_gametype_timeout;
- mapvote_abstain = 0;
+ mapvote_abstain = false;
mapvote_detail = !autocvar_g_maplist_votable_nodetail;
- float n = tokenizebyseparator(autocvar_sv_vote_gametype_options, " ");
+ int n = tokenizebyseparator(autocvar_sv_vote_gametype_options, " ");
n = min(MAPVOTE_COUNT, n);
- float really_available, which_available;
+ int really_available, which_available;
really_available = 0;
which_available = -1;
- for(j = 0; j < n; ++j)
+ for(int j = 0; j < n; ++j)
{
if ( GameTypeVote_AddVotable(argv(j)) )
if ( mapvote_maps_flags[j] & GTV_AVAILABLE )
projects / xonotic / xonotic-data.pk3dir.git / blobdiff