set g_grappling_hook 0 "let players spawn with the grappling hook which allows them to pull themselves up"
set g_spawn_alloweffects 1 "allow clients to enable spawn point and event effects such as particles and sounds, see cl_spawn_ cvars for more info"
-set g_spawn_furthest 1.0 "this amount of the spawns shall be far away from any players"
+set g_spawn_furthest 0.5 "this amount of the spawns shall be far away from any players"
set g_spawn_useallspawns 0 "use all spawns, e.g. also team spawns in non-teamplay, and all spawns, even enemy spawns, in teamplay"
// respawn delay
set g_respawn_delay_small 2 "small game number of seconds you have to wait before you can respawn again"
return color;
}
-float HUD_GetRowCount(float item_count, vector size, float item_aspect)
+float HUD_GetRowCount(int item_count, vector size, float item_aspect)
{
float aspect = size_y / size_x;
return bound(1, floor((sqrt(4 * item_aspect * aspect * item_count + aspect * aspect) + aspect + 0.5) / 2), item_count);
}
-vector HUD_GetTableSize(float item_count, vector psize, float item_aspect)
+vector HUD_GetTableSize(int item_count, vector psize, float item_aspect)
{
float columns, rows;
float ratio, best_ratio = 0;
return stringwidth(s, false, theSize);
}
-void drawstringright(vector position, string text, vector theScale, vector rgb, float theAlpha, float flag)
+void drawstringright(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
{
position.x -= 2 / 3 * strlen(text) * theScale.x;
drawstring(position, text, theScale, rgb, theAlpha, flag);
}
-void drawstringcenter(vector position, string text, vector theScale, vector rgb, float theAlpha, float flag)
+void drawstringcenter(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
{
position.x = 0.5 * (vid_conwidth - 0.6025 * strlen(text) * theScale.x);
drawstring(position, text, theScale, rgb, theAlpha, flag);
}
// return the string of the onscreen race timer
-string MakeRaceString(float cp, float mytime, float histime, float lapdelta, string hisname)
+string MakeRaceString(int cp, float mytime, float theirtime, float lapdelta, string theirname)
{
string col;
string timestr;
string lapstr;
lapstr = "";
- if(histime == 0) // goal hit
+ if(theirtime == 0) // goal hit
{
if(mytime > 0)
{
col = "^1";
}
}
- else if(histime > 0) // anticipation
+ else if(theirtime > 0) // anticipation
{
- if(mytime >= histime)
- timestr = strcat("+", ftos_decimals(mytime - histime, TIME_DECIMALS));
+ if(mytime >= theirtime)
+ timestr = strcat("+", ftos_decimals(mytime - theirtime, TIME_DECIMALS));
else
- timestr = TIME_ENCODED_TOSTRING(TIME_ENCODE(histime));
+ timestr = TIME_ENCODED_TOSTRING(TIME_ENCODE(theirtime));
col = "^3";
}
else
else
cpname = _("Finish line");
- if(histime < 0)
+ if(theirtime < 0)
return strcat(col, cpname);
- else if(hisname == "")
+ else if(theirname == "")
return strcat(col, sprintf("%s (%s)", cpname, timestr));
else
- return strcat(col, sprintf("%s (%s %s)", cpname, timestr, strcat(hisname, col, lapstr)));
+ return strcat(col, sprintf("%s (%s %s)", cpname, timestr, strcat(theirname, col, lapstr)));
}
// Check if the given name already exist in race rankings? In that case, where? (otherwise return 0)
-float race_CheckName(string net_name) {
- float i;
+int race_CheckName(string net_name)
+{
+ int i;
for (i=RANKINGS_CNT-1;i>=0;--i)
if(grecordholder[i] == net_name)
return i+1;
return 0;
}
-float GetPlayerColorForce(int i)
+int GetPlayerColorForce(int i)
{
if(!teamplay)
return 0;
return stof(getplayerkeyvalue(i, "colors")) & 15;
}
-float GetPlayerColor(int i)
+int GetPlayerColor(int i)
{
if(!playerslots[i].gotscores) // unconnected
return NUM_SPECTATOR;
} while(0)
//basically the same code of draw_ButtonPicture and draw_VertButtonPicture for the menu
-void HUD_Panel_DrawProgressBar(vector theOrigin, vector theSize, string pic, float length_ratio, float vertical, float baralign, vector theColor, float theAlpha, float drawflag)
+void HUD_Panel_DrawProgressBar(vector theOrigin, vector theSize, string pic, float length_ratio, bool vertical, float baralign, vector theColor, float theAlpha, int drawflag)
{
if(!length_ratio || !theAlpha)
return;
}
}
-void HUD_Panel_DrawHighlight(vector pos, vector mySize, vector color, float theAlpha, float drawflag)
+void HUD_Panel_DrawHighlight(vector pos, vector mySize, vector color, float theAlpha, int drawflag)
{
if(!theAlpha)
return;
}
string weaponorder_cmp_str;
-float weaponorder_cmp(float i, float j, entity pass)
+int weaponorder_cmp(int i, int j, entity pass)
{
- float ai, aj;
+ int ai, aj;
ai = strstrofs(weaponorder_cmp_str, sprintf(" %d ", weaponorder[i].weapon), 0);
aj = strstrofs(weaponorder_cmp_str, sprintf(" %d ", weaponorder[j].weapon), 0);
return aj - ai; // the string is in REVERSE order (higher prio at the right is what we want, but higher prio first is the string)
{
// declarations
WepSet weapons_stat = WepSet_GetFromStat();
- float i, f, a;
+ int i;
+ float f, a;
float screen_ar;
vector center = '0 0 0';
- float weapon_count, weapon_id;
- float row, column, rows = 0, columns = 0;
+ int weapon_count, weapon_id;
+ int row, column, rows = 0, columns = 0;
bool vertical_order = true;
float aspect = autocvar_hud_panel_weapons_aspect;
if(padded_panel_size.x / padded_panel_size.y < aspect)
{
// maximum number of rows that allows to display items with the desired aspect ratio
- float max_rows = floor(padded_panel_size.y / (weapon_size.x / aspect));
+ int max_rows = floor(padded_panel_size.y / (weapon_size.x / aspect));
columns = min(columns, ceil(weapon_count / max_rows));
rows = ceil(weapon_count / columns);
weapon_size.y = min(padded_panel_size.y / rows, weapon_size.x / aspect);
}
else
{
- float max_columns = floor(padded_panel_size.x / (weapon_size.y * aspect));
+ int max_columns = floor(padded_panel_size.x / (weapon_size.y * aspect));
rows = min(rows, ceil(weapon_count / max_columns));
columns = ceil(weapon_count / rows);
weapon_size.x = min(padded_panel_size.x / columns, aspect * weapon_size.y);
}
-void DrawAmmoNades(vector myPos, vector mySize, float draw_expanding, float expand_time)
+void DrawAmmoNades(vector myPos, vector mySize, bool draw_expanding, float expand_time)
{
float theAlpha = 1, a, b;
vector nade_color, picpos, numpos;
}
}
-void DrawAmmoItem(vector myPos, vector mySize, .float ammoType, float isCurrent, float isInfinite)
+void DrawAmmoItem(vector myPos, vector mySize, .int ammoType, bool isCurrent, bool isInfinite)
{
if(ammoType == ammo_none)
return;
// Initialize variables
- float ammo;
+ int ammo;
if(autocvar__hud_configure)
{
isCurrent = (ammoType == ammo_rockets); // Rockets always current
textPos = myPos + eX * mySize.y;
}
- float isShadowed = (ammo <= 0 && !isCurrent && !isInfinite);
+ bool isShadowed = (ammo <= 0 && !isCurrent && !isInfinite);
vector iconColor = isShadowed ? '0 0 0' : '1 1 1';
vector textColor;
drawpic_aspect_skin(iconPos, GetAmmoPicture(ammoType), '1 1 0' * mySize.y, iconColor, alpha, DRAWFLAG_NORMAL);
}
-float nade_prevstatus;
-float nade_prevframe;
+int nade_prevstatus;
+int nade_prevframe;
float nade_statuschange_time;
void HUD_Ammo(void)
{
mySize -= '2 2 0' * panel_bg_padding;
}
- float rows = 0, columns, row, column;
+ int rows = 0, columns, row, column;
float nade_cnt = getstatf(STAT_NADE_BONUS), nade_score = getstatf(STAT_NADE_BONUS_SCORE);
- float draw_nades = (nade_cnt > 0 || nade_score > 0), nade_statuschange_elapsedtime;
- float total_ammo_count;
+ bool draw_nades = (nade_cnt > 0 || nade_score > 0);
+ float nade_statuschange_elapsedtime;
+ int total_ammo_count;
vector ammo_size;
if (autocvar_hud_panel_ammo_onlycurrent)
ammo_size.y = newSize;
}
- float i;
- float infinite_ammo = (getstati(STAT_ITEMS, 0, 24) & IT_UNLIMITED_WEAPON_AMMO);
+ int i;
+ bool infinite_ammo = (getstati(STAT_ITEMS, 0, 24) & IT_UNLIMITED_WEAPON_AMMO);
row = column = 0;
if(autocvar_hud_panel_ammo_onlycurrent)
{
}
else
{
- .float ammotype;
+ .int ammotype;
row = column = 0;
for(i = 0; i < AMMO_COUNT; ++i)
{
draw_endBoldFont();
}
-void DrawNumIcon_expanding(vector myPos, vector mySize, float x, string icon, float vertical, float icon_right_align, vector color, float theAlpha, float fadelerp)
+void DrawNumIcon_expanding(vector myPos, vector mySize, float x, string icon, bool vertical, bool icon_right_align, vector color, float theAlpha, float fadelerp)
{
vector newPos = '0 0 0', newSize = '0 0 0';
vector picpos, numpos;
drawpic_aspect_skin_expanding(picpos, icon, '1 1 0' * newSize.y, '1 1 1', panel_fg_alpha * theAlpha, DRAWFLAG_NORMAL, fadelerp);
}
-void DrawNumIcon(vector myPos, vector mySize, float x, string icon, float vertical, float icon_right_align, vector color, float theAlpha)
+void DrawNumIcon(vector myPos, vector mySize, float x, string icon, bool vertical, bool icon_right_align, vector color, float theAlpha)
{
DrawNumIcon_expanding(myPos, mySize, x, icon, vertical, icon_right_align, color, theAlpha, 0);
}
}
float panel_ar = mySize.x/mySize.y;
- float is_vertical = (panel_ar < 1);
+ bool is_vertical = (panel_ar < 1);
vector shield_offset = '0 0 0', strength_offset = '0 0 0', superweapons_offset = '0 0 0';
- float superweapons_is = -1;
+ int superweapons_is = -1;
if(superweapons_time)
{
}
}
- float shield_baralign, strength_baralign, superweapons_baralign;
- float shield_iconalign, strength_iconalign, superweapons_iconalign;
+ bool shield_baralign, strength_baralign, superweapons_baralign;
+ bool shield_iconalign, strength_iconalign, superweapons_iconalign;
if (autocvar_hud_panel_powerups_flip)
{
// prev_* vars contain the health/armor at the previous FRAME
// set to -1 when player is dead or was not playing
-float prev_health, prev_armor;
+int prev_health, prev_armor;
float health_damagetime, armor_damagetime;
-float health_beforedamage, armor_beforedamage;
+int health_beforedamage, armor_beforedamage;
// old_p_* vars keep track of previous values when smoothing value changes of the progressbar
-float old_p_health, old_p_armor;
+int old_p_health, old_p_armor;
float old_p_healthtime, old_p_armortime;
// prev_p_* vars contain the health/armor progressbar value at the previous FRAME
// set to -1 to forcedly stop effects when we switch spectated player (e.g. from playerX: 70h to playerY: 50h)
-float prev_p_health, prev_p_armor;
+int prev_p_health, prev_p_armor;
void HUD_HealthArmor(void)
{
- float armor, health, fuel;
+ int armor, health, fuel;
if(!autocvar__hud_configure)
{
if(!autocvar_hud_panel_healtharmor) return;
mySize -= '2 2 0' * panel_bg_padding;
}
- float baralign = autocvar_hud_panel_healtharmor_baralign;
- float iconalign = autocvar_hud_panel_healtharmor_iconalign;
+ int baralign = autocvar_hud_panel_healtharmor_baralign;
+ int iconalign = autocvar_hud_panel_healtharmor_iconalign;
- float maxhealth = autocvar_hud_panel_healtharmor_maxhealth;
- float maxarmor = autocvar_hud_panel_healtharmor_maxarmor;
+ int maxhealth = autocvar_hud_panel_healtharmor_maxhealth;
+ int maxarmor = autocvar_hud_panel_healtharmor_maxarmor;
if(autocvar_hud_panel_healtharmor == 2) // combined health and armor display
{
vector v;
else
{
float panel_ar = mySize.x/mySize.y;
- float is_vertical = (panel_ar < 1);
+ bool is_vertical = (panel_ar < 1);
vector health_offset = '0 0 0', armor_offset = '0 0 0';
if (panel_ar >= 4 || (panel_ar >= 1/4 && panel_ar < 1))
{
armor_offset.y = mySize.y;
}
- float health_baralign, armor_baralign, fuel_baralign;
- float health_iconalign, armor_iconalign;
+ bool health_baralign, armor_baralign, fuel_baralign;
+ bool health_iconalign, armor_iconalign;
if (autocvar_hud_panel_healtharmor_flip)
{
armor_baralign = (autocvar_hud_panel_healtharmor_baralign == 2 || autocvar_hud_panel_healtharmor_baralign == 1);
float fade_time = max(0, autocvar_hud_panel_notify_fadetime);
float icon_aspect = max(1, autocvar_hud_panel_notify_icon_aspect);
- float entry_count = bound(1, floor(NOTIFY_MAX_ENTRIES * size.y / size.x), NOTIFY_MAX_ENTRIES);
+ int entry_count = bound(1, floor(NOTIFY_MAX_ENTRIES * size.y / size.x), NOTIFY_MAX_ENTRIES);
float entry_height = size.y / entry_count;
float panel_width_half = size.x * 0.5;
vector attacker_pos, victim_pos, icon_pos;
string attacker, victim, icon;
- float i, j, count, step, limit, alpha;
+ int i, j, count, step, limit;
+ float alpha;
if (autocvar_hud_panel_notify_flip)
{
mySize -= '2 2 0' * panel_bg_padding;
}
- float color2;
+ int color2;
entity tm;
float scale2d, normalsize, bigsize;
{
float score;
entity tm = world, pl;
- float SCOREPANEL_MAX_ENTRIES = 6;
+ int SCOREPANEL_MAX_ENTRIES = 6;
float SCOREPANEL_ASPECTRATIO = 2;
- float entries = bound(1, floor(SCOREPANEL_MAX_ENTRIES * mySize.y/mySize.x * SCOREPANEL_ASPECTRATIO), SCOREPANEL_MAX_ENTRIES);
+ int entries = bound(1, floor(SCOREPANEL_MAX_ENTRIES * mySize.y/mySize.x * SCOREPANEL_ASPECTRATIO), SCOREPANEL_MAX_ENTRIES);
vector fontsize = '1 1 0' * (mySize.y/entries);
vector rgb, score_color;
float name_size = mySize.x*0.75;
float spacing_size = mySize.x*0.04;
const float highlight_alpha = 0.2;
- float i = 0, me_printed = 0, first_pl = 0;
+ int i = 0, first_pl = 0;
+ bool me_printed = false;
string s;
if (autocvar__hud_configure)
{
{
if (i == first_pl)
rgb = '0 1 0'; //first: green
- me_printed = 1;
+ me_printed = true;
drawfill(pos, eX * mySize.x + eY * fontsize.y, rgb, highlight_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
}
if (team_count)
// Vote window (#9)
//
-float vote_yescount;
-float vote_nocount;
-float vote_needed;
-float vote_highlighted; // currently selected vote
+int vote_yescount;
+int vote_nocount;
+int vote_needed;
+int vote_highlighted; // currently selected vote
-float vote_active; // is there an active vote?
-float vote_prev; // previous state of vote_active to check for a change
+int vote_active; // is there an active vote?
+int vote_prev; // previous state of vote_active to check for a change
float vote_alpha;
float vote_change; // "time" when vote_active changed
// Mod icons panel (#10)
//
-float mod_active; // is there any active mod icon?
+bool mod_active; // is there any active mod icon?
-void DrawCAItem(vector myPos, vector mySize, float aspect_ratio, int layout, float i)
+void DrawCAItem(vector myPos, vector mySize, float aspect_ratio, int layout, int i)
{
- float stat = -1;
+ int stat = -1;
string pic = "";
vector color = '0 0 0';
switch(i)
layout = autocvar_hud_panel_modicons_ca_layout;
else //if(gametype == MAPINFO_TYPE_FREEZETAG)
layout = autocvar_hud_panel_modicons_freezetag_layout;
- float rows, columns, aspect_ratio;
+ int rows, columns;
+ float aspect_ratio;
aspect_ratio = (layout) ? 2 : 1;
rows = HUD_GetRowCount(team_count, mySize, aspect_ratio);
columns = ceil(team_count/rows);
// CTF HUD modicon section
int redflag_prevframe, blueflag_prevframe, yellowflag_prevframe, pinkflag_prevframe, neutralflag_prevframe; // status during previous frame
int redflag_prevstatus, blueflag_prevstatus, yellowflag_prevstatus, pinkflag_prevstatus, neutralflag_prevstatus; // last remembered status
-int redflag_statuschange_time, blueflag_statuschange_time, yellowflag_statuschange_time, pinkflag_statuschange_time, neutralflag_statuschange_time; // time when the status changed
+float redflag_statuschange_time, blueflag_statuschange_time, yellowflag_statuschange_time, pinkflag_statuschange_time, neutralflag_statuschange_time; // time when the status changed
void HUD_Mod_CTF_Reset(void)
{
// Read current state
- float state = getstati(STAT_KH_KEYS);
- float i, key_state;
- float all_keys, team1_keys, team2_keys, team3_keys, team4_keys, dropped_keys, carrying_keys;
+ int state = getstati(STAT_KH_KEYS);
+ int i, key_state;
+ int all_keys, team1_keys, team2_keys, team3_keys, team4_keys, dropped_keys, carrying_keys;
all_keys = team1_keys = team2_keys = team3_keys = team4_keys = dropped_keys = carrying_keys = 0;
for(i = 0; i < 4; ++i)
}
// Keepaway HUD mod icon
-float kaball_prevstatus; // last remembered status
+int kaball_prevstatus; // last remembered status
float kaball_statuschange_time; // time when the status changed
// we don't need to reset for keepaway since it immediately
float BLINK_FREQ = 5;
float kaball_alpha = BLINK_BASE + BLINK_FACTOR * cos(time * BLINK_FREQ);
- float stat_items = getstati(STAT_ITEMS, 0, 24);
- float kaball = (stat_items/IT_KEY1) & 1;
+ int stat_items = getstati(STAT_ITEMS, 0, 24);
+ int kaball = (stat_items/IT_KEY1) & 1;
if(kaball != kaball_prevstatus)
{
// Nexball HUD mod icon
void HUD_Mod_NexBall(vector pos, vector mySize)
{
- float stat_items, nb_pb_starttime, dt, p;
+ float nb_pb_starttime, dt, p;
+ int stat_items;
stat_items = getstati(STAT_ITEMS, 0, 24);
nb_pb_starttime = getstatf(STAT_NB_METERSTART);
float srecordtime_change_time; // time when srecordtime last changed
float race_status_time;
-float race_status_prev;
+int race_status_prev;
string race_status_name_prev;
void HUD_Mod_Race(vector pos, vector mySize)
{
}
}
-void DrawDomItem(vector myPos, vector mySize, float aspect_ratio, int layout, float i)
+void DrawDomItem(vector myPos, vector mySize, float aspect_ratio, int layout, int i)
{
float stat = -1;
string pic = "";
mod_active = 1; // required in each mod function that always shows something
int layout = autocvar_hud_panel_modicons_dom_layout;
- float rows, columns, aspect_ratio;
+ int rows, columns;
+ float aspect_ratio;
aspect_ratio = (layout) ? 3 : 1;
rows = HUD_GetRowCount(team_count, mySize, aspect_ratio);
columns = ceil(team_count/rows);
}
}
-float mod_prev; // previous state of mod_active to check for a change
+int mod_prev; // previous state of mod_active to check for a change
float mod_alpha;
float mod_change; // "time" when mod_active changed
//
float prevfps;
float prevfps_time;
-float framecounter;
+int framecounter;
float frametimeavg;
float frametimeavg1; // 1 frame ago
else
acceleration_offset.y = panel_size.y;
}
- float speed_baralign, acceleration_baralign;
+ int speed_baralign, acceleration_baralign;
if (autocvar_hud_panel_physics_baralign == 1)
acceleration_baralign = speed_baralign = 1;
else if(autocvar_hud_panel_physics_baralign == 4)
// CenterPrint (#16)
//
-const float CENTERPRINT_MAX_MSGS = 10;
-const float CENTERPRINT_MAX_ENTRIES = 50;
+const int CENTERPRINT_MAX_MSGS = 10;
+const int CENTERPRINT_MAX_ENTRIES = 50;
const float CENTERPRINT_SPACING = 0.7;
-float cpm_index;
+int cpm_index;
string centerprint_messages[CENTERPRINT_MAX_MSGS];
-float centerprint_msgID[CENTERPRINT_MAX_MSGS];
+int centerprint_msgID[CENTERPRINT_MAX_MSGS];
float centerprint_time[CENTERPRINT_MAX_MSGS];
float centerprint_expire_time[CENTERPRINT_MAX_MSGS];
-float centerprint_countdown_num[CENTERPRINT_MAX_MSGS];
-float centerprint_showing;
+int centerprint_countdown_num[CENTERPRINT_MAX_MSGS];
+bool centerprint_showing;
-void centerprint_generic(float new_id, string strMessage, float duration, float countdown_num)
+void centerprint_generic(int new_id, string strMessage, float duration, int countdown_num)
{
//printf("centerprint_generic(%d, '%s^7', %d, %d);\n", new_id, strMessage, duration, countdown_num);
- float i, j;
+ int i, j;
if(strMessage == "" && new_id == 0)
return;
void reset_centerprint_messages(void)
{
- float i;
+ int i;
for (i=0; i<CENTERPRINT_MAX_MSGS; ++i)
{
centerprint_expire_time[i] = 0;
panel_size -= '2 2 0' * panel_bg_padding;
}
- float entries, height;
+ int entries;
+ float height;
vector fontsize;
// entries = bound(1, floor(CENTERPRINT_MAX_ENTRIES * 4 * panel_size_y/panel_size_x), CENTERPRINT_MAX_ENTRIES);
// height = panel_size_y/entries;
fontsize = '1 1 0' * height;
entries = bound(1, floor(panel_size.y/height), CENTERPRINT_MAX_ENTRIES);
- float i, j, k, n, g;
+ int i, j, k, n, g;
float a, sz, align, current_msg_posY = 0, msg_size;
vector pos;
string ts;
- float all_messages_expired = true;
+ bool all_messages_expired = true;
pos = panel_pos;
if (autocvar_hud_panel_centerprint_flip)
//
void HUD_Buffs(void)
{
- float buffs = getstati(STAT_BUFFS, 0, 24);
+ int buffs = getstati(STAT_BUFFS, 0, 24);
if(!autocvar__hud_configure)
{
if(!autocvar_hud_panel_buffs) return;
buffs = Buff_Type_first.items; // force first buff
}
- float b = 0; // counter to tell other functions that we have buffs
+ int b = 0; // counter to tell other functions that we have buffs
entity e;
string s = "";
for(e = Buff_Type_first; e; e = e.enemy) if(buffs & e.items)
}
//float panel_ar = mySize_x/mySize_y;
- //float is_vertical = (panel_ar < 1);
+ //bool is_vertical = (panel_ar < 1);
//float buff_iconalign = autocvar_hud_panel_buffs_iconalign;
vector buff_offset = '0 0 0';
// draw the dock
if(autocvar_hud_dock != "" && autocvar_hud_dock != "0")
{
- float f;
+ int f;
vector color;
float hud_dock_color_team = autocvar_hud_dock_color_team;
if((teamplay) && hud_dock_color_team) {
for(i = 0; i < HUD_PANEL_NUM; ++i)
panel_order[i] = -1;
string s = "";
- float p_num, warning = false;
- float argc = tokenize_console(autocvar__hud_panelorder);
+ int p_num;
+ bool warning = false;
+ int argc = tokenize_console(autocvar__hud_panelorder);
if (argc > HUD_PANEL_NUM)
warning = true;
//first detect wrong/missing panel numbers
for(i = 0; i < HUD_PANEL_NUM; ++i) {
- p_num = stof(argv(i));
+ p_num = stoi(argv(i));
if (p_num >= 0 && p_num < HUD_PANEL_NUM) { //correct panel number?
if (panel_order[p_num] == -1) //found for the first time?
s = strcat(s, ftos(p_num), " ");
precache_model ("models/turrets/head-gib2.md3");
precache_model ("models/turrets/head-gib3.md3");
precache_model ("models/turrets/head-gib4.md3");
- precache_model ("models/turrets/terrainbase.md3");
precache_model ("models/turrets/base.md3");
precache_model ("models/turrets/rocket.md3");
}
self.nextthink = time + 0.2;
}
-void shambler_lightning_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void shambler_lightning_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if (self.health <= 0)
return;
makevectors(self.v_angle);
}
-float monster_melee(entity targ, float damg, float anim, float er, float anim_finished, float deathtype, float dostop)
+float monster_melee(entity targ, float damg, float anim, float er, float anim_finished, int deathtype, float dostop)
{
if (self.health <= 0)
return false; // attacking while dead?!
self.moveto = self.origin;
}
-void monsters_corpse_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void monsters_corpse_damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
self.health -= damage;
MON_ACTION(self.monsterid, MR_DEATH);
}
-void monsters_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void monsters_damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.frozen && deathtype != DEATH_KILL && deathtype != DEATH_NADE_ICE_FREEZE)
return;
float monster_initialize(float mon_id);
float monster_leap (float anm, void() touchfunc, vector vel, float anim_finished);
void monster_makevectors(entity e);
-float monster_melee(entity targ, float damg, float anim, float er, float anim_finished, float deathtype, float dostop);
+float monster_melee(entity targ, float damg, float anim, float er, float anim_finished, int deathtype, float dostop);
void monster_move(float runspeed, float walkspeed, float stopspeed, float manim_run, float manim_walk, float manim_idle);
void monster_setupcolors(entity mon);
float Monster_SkillModifier();
}
#ifdef SVQC
-float healer_send(entity to, float sf);
+float healer_send(entity to, int sf);
#endif
#ifdef CSQC
if(notif.nent_challow_var && (warmup_stage || (notif.nent_challow_var == 2)))
{
- switch(cvar_string(sprintf("notification_%s", notif.nent_name)))
+ switch(cvar(sprintf("notification_%s", notif.nent_name)))
{
case 1: found_choice = notif.nent_optiona; break;
case 2: found_choice = notif.nent_optionb; break;
remove(self);
}
-float Net_Write_Notification(entity client, float sf)
+float Net_Write_Notification(entity client, int sf)
{
if(Notification_ShouldSend(self.nent_broadcast, client, self.nent_client))
{
#define int float
#define stoi(s) stof(s)
- #define itos(s) ftos(s)
+ #define stob(s) stof(s)
+ #define itos(i) ftos(i)
+#else
+ #define stoi(s) ((int) stof(s))
+ #define stob(s) ((bool) stof(s))
+ #define itos(i) ftos(i)
#endif
#ifndef QCC_SUPPORT_BOOL
}
#ifndef MENUQC
-vector healtharmor_maxdamage(float h, float a, float armorblock, float deathtype)
+vector healtharmor_maxdamage(float h, float a, float armorblock, int deathtype)
{
// NOTE: we'll always choose the SMALLER value...
float healthdamage, armordamage, armorideal;
return v;
}
-vector healtharmor_applydamage(float a, float armorblock, float deathtype, float damage)
+vector healtharmor_applydamage(float a, float armorblock, int deathtype, float damage)
{
vector v;
if (deathtype == DEATH_DROWN) // Why should armor help here...
void RandomSelection_Add(entity e, float f, string s, float weight, float priority);
#ifndef MENUQC
-vector healtharmor_maxdamage(float h, float a, float armorblock, float deathtype); // returns vector: maxdamage, armorideal, 1 if fully armored
-vector healtharmor_applydamage(float a, float armorblock, float deathtype, float damage); // returns vector: take, save, 0
+vector healtharmor_maxdamage(float h, float a, float armorblock, int deathtype); // returns vector: maxdamage, armorideal, 1 if fully armored
+vector healtharmor_applydamage(float a, float armorblock, int deathtype, float damage); // returns vector: take, save, 0
#endif
string getcurrentmod();
#ifdef SVQC
void spawnfunc_weapon_arc(void) { weapon_defaultspawnfunc(WEP_ARC); }
-float W_Arc_Beam_Send(entity to, float sf)
+float W_Arc_Beam_Send(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_ARC_BEAM);
||
self.owner.frozen
||
+ self.owner.vehicle
+ ||
(WEP_CVAR(arc, overheat_max) > 0 && self.beam_heat >= WEP_CVAR(arc, overheat_max))
)
{
entity oldself = self;
self = self.owner;
if(!WEP_ACTION(WEP_ARC, WR_CHECKAMMO1) && !WEP_ACTION(WEP_ARC, WR_CHECKAMMO2))
+ if(!(self.items & IT_UNLIMITED_WEAPON_AMMO))
{
// note: this doesn't force the switch
W_SwitchToOtherWeapon(self);
}
}
-float W_Arc(float req)
+bool W_Arc(int req)
{
switch(req)
{
}
}
-float W_Arc(float req)
+bool W_Arc(int req)
{
switch(req)
{
self = oldself;
}
}
-float W_Blaster(float request)
+bool W_Blaster(int request)
{
switch(request)
{
}
#endif
#ifdef CSQC
-float W_Blaster(float request)
+bool W_Blaster(int request)
{
switch(request)
{
}
}
-float W_Crylink(float req)
+bool W_Crylink(int req)
{
float ammo_amount;
switch(req)
}
#endif
#ifdef CSQC
-float W_Crylink(float req)
+bool W_Crylink(int req)
{
switch(req)
{
if(self.realowner.weapon == WEP_DEVASTATOR)
{
if(self.realowner.WEP_AMMO(DEVASTATOR) < WEP_CVAR(devastator, ammo))
+ if(!(self.realowner.items & IT_UNLIMITED_WEAPON_AMMO))
{
self.realowner.cnt = WEP_DEVASTATOR;
ATTACK_FINISHED(self.realowner) = time;
if(self.realowner.weapon == WEP_DEVASTATOR)
{
if(self.realowner.WEP_AMMO(DEVASTATOR) < WEP_CVAR(devastator, ammo))
+ if(!(self.realowner.items & IT_UNLIMITED_WEAPON_AMMO))
{
self.realowner.cnt = WEP_DEVASTATOR;
ATTACK_FINISHED(self.realowner) = time;
W_Devastator_Explode();
}
-void W_Devastator_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Devastator_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
other = missile; MUTATOR_CALLHOOK(EditProjectile);
}
-float W_Devastator(float req)
+bool W_Devastator(int req)
{
entity rock;
float rockfound;
}
#endif
#ifdef CSQC
-float W_Devastator(float req)
+bool W_Devastator(int req)
{
switch(req)
{
}
}
-void W_Electro_Orb_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Electro_Orb_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
}
.float bot_secondary_electromooth;
-float W_Electro(float req)
+bool W_Electro(int req)
{
float ammo_amount;
switch(req)
}
#endif
#ifdef CSQC
-float W_Electro(float req)
+bool W_Electro(int req)
{
switch(req)
{
self.nextthink = time + 0.1;
}
-void W_Fireball_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Fireball_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
other = proj; MUTATOR_CALLHOOK(EditProjectile);
}
-float W_Fireball(float req)
+bool W_Fireball(int req)
{
switch(req)
{
}
#endif
#ifdef CSQC
-float W_Fireball(float req)
+bool W_Fireball(int req)
{
switch(req)
{
remove(self);
}
-void W_Hagar_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Hagar_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
loaded = self.hagar_load >= WEP_CVAR_SEC(hagar, load_max);
// this is different than WR_CHECKAMMO when it comes to reloading
- if(autocvar_g_balance_hagar_reload_ammo)
+ if(self.items & IT_UNLIMITED_WEAPON_AMMO)
+ enough_ammo = true;
+ else if(autocvar_g_balance_hagar_reload_ammo)
enough_ammo = self.(weapon_load[WEP_HAGAR]) >= WEP_CVAR_SEC(hagar, ammo);
else
enough_ammo = self.WEP_AMMO(HAGAR) >= WEP_CVAR_SEC(hagar, ammo);
// we aren't checking ammo during an attack, so we must do it here
if(!(WEP_ACTION(self.weapon, WR_CHECKAMMO1) + WEP_ACTION(self.weapon, WR_CHECKAMMO2)))
+ if(!(self.items & IT_UNLIMITED_WEAPON_AMMO))
{
// note: this doesn't force the switch
W_SwitchToOtherWeapon(self);
}
}
-float W_Hagar(float req)
+bool W_Hagar(int req)
{
float ammo_amount;
switch(req)
}
#endif
#ifdef CSQC
-float W_Hagar(float req)
+bool W_Hagar(int req)
{
switch(req)
{
}
}
-float W_HLAC(float req)
+bool W_HLAC(int req)
{
float ammo_amount;
switch(req)
}
#endif
#ifdef CSQC
-float W_HLAC(float req)
+bool W_HLAC(int req)
{
switch(req)
{
weapon_thinkf(WFRAME_FIRE1, WEP_CVAR(hmg, refire), W_HeavyMachineGun_Attack_Auto);
}
-float W_HeavyMachineGun(float req)
+bool W_HeavyMachineGun(int req)
{
float ammo_amount;
switch(req)
}
#endif
#ifdef CSQC
-float W_HeavyMachineGun(float req)
+bool W_HeavyMachineGun(int req)
{
switch(req)
{
self.movetype = MOVETYPE_NONE;
}
-void W_Hook_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Hook_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
other = gren; MUTATOR_CALLHOOK(EditProjectile);
}
-float W_Hook(float req)
+bool W_Hook(int req)
{
float hooked_time_max, hooked_fuel;
}
#endif
#ifdef CSQC
-float W_Hook(float req)
+bool W_Hook(int req)
{
switch(req)
{
self.muzzle_flash.owner = self.muzzle_flash.realowner = self;
}
-void W_MachineGun_Attack(float deathtype)
+void W_MachineGun_Attack(int deathtype)
{
W_SetupShot(self, true, 0, "weapons/uzi_fire.wav", CH_WEAPON_A, ((self.misc_bulletcounter == 1) ? WEP_CVAR(machinegun, first_damage) : WEP_CVAR(machinegun, sustained_damage)));
if(!autocvar_g_norecoil)
}
-float W_MachineGun(float req)
+bool W_MachineGun(int req)
{
float ammo_amount;
switch(req)
}
#endif
#ifdef CSQC
-float W_MachineGun(float req)
+bool W_MachineGun(int req)
{
switch(req)
{
W_MineLayer_Explode();
}
-float W_MineLayer_Count(entity e)
+int W_MineLayer_Count(entity e)
{
- float minecount = 0;
+ int minecount = 0;
entity mine;
for(mine = world; (mine = find(mine, classname, "mine")); ) if(mine.realowner == e)
minecount += 1;
}
}
-void W_MineLayer_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_MineLayer_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
return minfound;
}
-float W_MineLayer(float req)
+bool W_MineLayer(int req)
{
entity mine;
float ammo_amount;
}
#endif
#ifdef CSQC
-float W_MineLayer(float req)
+bool W_MineLayer(int req)
{
switch(req)
{
}
-void W_Mortar_Grenade_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Mortar_Grenade_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
}
.float bot_secondary_grenademooth;
-float W_Mortar(float req)
+bool W_Mortar(int req)
{
entity nade;
float nadefound;
}
#endif
#ifdef CSQC
-float W_Mortar(float req)
+bool W_Mortar(int req)
{
switch(req)
{
other = gren; MUTATOR_CALLHOOK(EditProjectile);
}
-float w_nexball_weapon(float req); // WEAPONTODO
-float W_Porto(float req)
+bool w_nexball_weapon(int req); // WEAPONTODO
+bool W_Porto(int req)
{
//vector v_angle_save;
}
#endif
#ifdef CSQC
-float W_Porto(float req)
+bool W_Porto(int req)
{
switch(req)
{
void spawnfunc_weapon_campingrifle(void) { spawnfunc_weapon_rifle(); }
void spawnfunc_weapon_sniperrifle(void) { spawnfunc_weapon_rifle(); }
-void W_Rifle_FireBullet(float pSpread, float pDamage, float pForce, float pSolidPenetration, float pAmmo, float deathtype, float pTracer, float pShots, string pSound)
+void W_Rifle_FireBullet(float pSpread, float pDamage, float pForce, float pSolidPenetration, float pAmmo, int deathtype, float pTracer, float pShots, string pSound)
{
float i;
}
.float bot_secondary_riflemooth;
-float W_Rifle(float req)
+bool W_Rifle(int req)
{
float ammo_amount;
}
#endif
#ifdef CSQC
-float W_Rifle(float req)
+bool W_Rifle(int req)
{
switch(req)
{
W_RocketPropelledChainsaw_Explode();
}
-void W_RocketPropelledChainsaw_Damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_RocketPropelledChainsaw_Damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if (self.health <= 0)
return;
other = missile; MUTATOR_CALLHOOK(EditProjectile);
}
-float W_RocketPropelledChainsaw(float req)
+bool W_RocketPropelledChainsaw(int req)
{
float ammo_amount = false;
switch(req)
#endif
#ifdef CSQC
-float W_RocketPropelledChainsaw(float req)
+bool W_RocketPropelledChainsaw(int req)
{
switch(req)
{
-void W_Seeker_Missile_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Seeker_Missile_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
remove(self);
}
-void W_Seeker_Tag_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void W_Seeker_Tag_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
// Begin: Genereal weapon functions
// ============================
-float W_Seeker(float req)
+bool W_Seeker(int req)
{
float ammo_amount;
}
#endif
#ifdef CSQC
-float W_Seeker(float req)
+bool W_Seeker(int req)
{
switch(req)
{
}
}
-float W_Shockwave(float req)
+bool W_Shockwave(int req)
{
switch(req)
{
shockwave.sw_time = time;
}
-float W_Shockwave(float req)
+bool W_Shockwave(int req)
{
switch(req)
{
#ifdef SVQC
void spawnfunc_weapon_tuba(void) { weapon_defaultspawnfunc(WEP_TUBA); }
-float W_Tuba_HasPlayed(entity pl, string melody, float instrument, float ignorepitch, float mintempo, float maxtempo)
+bool W_Tuba_HasPlayed(entity pl, string melody, int instrument, bool ignorepitch, float mintempo, float maxtempo)
{
float i, j, mmin, mmax, nolength;
float n = tokenize_console(melody);
remove(self);
}
-float W_Tuba_GetNote(entity pl, float hittype)
+int W_Tuba_GetNote(entity pl, int hittype)
{
float movestate = 5;
if (pl.movement.x < 0) movestate -= 3;
if (pl.movement.y < 0) movestate -= 1;
else if (pl.movement.y > 0) movestate += 1;
- float note = 0;
+ int note = 0;
switch(movestate)
{
// layout: originally I wanted
return note;
}
-float W_Tuba_NoteSendEntity(entity to, float sf)
+bool W_Tuba_NoteSendEntity(entity to, int sf)
{
- float f;
+ int f;
msg_entity = to;
if(!sound_allowed(MSG_ONE, self.realowner))
}
}
-float W_Tuba(float req)
+bool W_Tuba(int req)
{
switch(req)
{
}
#endif
#ifdef CSQC
-float W_Tuba(float req)
+bool W_Tuba(int req)
{
// nothing to do here; particles of tuba are handled differently
// WEAPONTODO
#ifdef SVQC
VORTEX_SETTINGS(WEP_ADD_CVAR, WEP_ADD_PROP)
+
+.float vortex_lasthit;
#endif
#else
#ifdef SVQC
}
yoda = 0;
+ damage_goodhits = 0;
FireRailgunBullet(w_shotorg, w_shotorg + w_shotdir * MAX_SHOT_DISTANCE, mydmg, myforce, mymindist, mymaxdist, myhalflife, myforcehalflife, WEP_VORTEX);
if(yoda && flying)
Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_ACHIEVEMENT_YODA);
+ if(damage_goodhits && self.vortex_lasthit)
+ {
+ Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_ACHIEVEMENT_IMPRESSIVE);
+ damage_goodhits = 0; // only every second time
+ }
+
+ self.vortex_lasthit = damage_goodhits;
//beam and muzzle flash done on client
SendCSQCVortexBeamParticle(charge);
void spawnfunc_weapon_vortex(void); // defined in t_items.qc
.float vortex_chargepool_pauseregen_finished;
-float W_Vortex(float req)
+bool W_Vortex(int req)
{
float dt;
float ammo_amount;
VORTEX_SETTINGS(WEP_SKIP_CVAR, WEP_SET_PROP);
return true;
}
+ case WR_SETUP:
+ {
+ self.vortex_lasthit = 0;
+ return true;
+ }
case WR_CHECKAMMO1:
{
ammo_amount = self.WEP_AMMO(VORTEX) >= WEP_CVAR_PRI(vortex, ammo);
VORTEX_SETTINGS(WEP_CONFIG_WRITE_CVARS, WEP_CONFIG_WRITE_PROPS);
return true;
}
+ case WR_RESETPLAYER:
+ {
+ self.vortex_lasthit = 0;
+ return true;
+ }
case WR_RELOAD:
{
W_Reload(min(WEP_CVAR_PRI(vortex, ammo), WEP_CVAR_SEC(vortex, ammo)), "weapons/reload.wav");
#endif
#ifdef CSQC
float autocvar_g_balance_vortex_secondary = 0; // WEAPONTODO
-float W_Vortex(float req)
+bool W_Vortex(int req)
{
switch(req)
{
# error Kein Weltraum links auf dem Gerät
#endif
-WepSet WepSet_FromWeapon(float a) {
+WepSet WepSet_FromWeapon(int a) {
a -= WEP_FIRST;
#if WEP_MAXCOUNT > 24
if(a >= 24) {
void register_weapon(
int id,
WepSet bit,
- float(float) func,
- .float ammotype,
- float i,
- float weapontype,
+ bool(int) func,
+ .int ammotype,
+ int i,
+ int weapontype,
float pickupbasevalue,
vector clr,
string modelname,
func(WR_INIT);
#endif
}
-float w_null(float dummy)
+bool w_null(int dummy)
{
return 0;
}
}
string W_NumberWeaponOrder_MapFunc(string s)
{
- float i;
+ int i;
if(s == "0" || stof(s))
return s;
s = W_UndeprecateName(s);
void W_RandomWeapons(entity e, float n)
{
- float i, j;
+ int i, j;
WepSet remaining;
WepSet result;
remaining = e.weapons;
e.weapons = result;
}
-string GetAmmoPicture(.float ammotype)
+string GetAmmoPicture(.int ammotype)
{
switch(ammotype)
{
}
#ifdef CSQC
-.float GetAmmoFieldFromNum(int i)
+.int GetAmmoFieldFromNum(int i)
{
switch(i)
{
}
}
-int GetAmmoStat(.float ammotype)
+int GetAmmoStat(.int ammotype)
{
switch(ammotype)
{
// weapon sets
typedef vector WepSet;
-WepSet WepSet_FromWeapon(float a);
+WepSet WepSet_FromWeapon(int a);
#ifdef SVQC
void WepSet_AddStat();
void WriteWepSet(float dest, WepSet w);
WepSet WEPSET_SUPERWEAPONS;
// functions:
-entity get_weaponinfo(float id);
+entity get_weaponinfo(int id);
string W_FixWeaponOrder(string order, float complete);
string W_UndeprecateName(string s);
string W_NameWeaponOrder(string order);
string W_FixWeaponOrder_ForceComplete(string order);
void W_RandomWeapons(entity e, float n);
-string GetAmmoPicture(.float ammotype);
+string GetAmmoPicture(.int ammotype);
#ifdef CSQC
-.float GetAmmoFieldFromNum(int i);
-int GetAmmoStat(.float ammotype);
+.int GetAmmoFieldFromNum(int i);
+int GetAmmoStat(.int ammotype);
#endif
// ammo types
-.float ammo_shells;
-.float ammo_nails;
-.float ammo_rockets;
-.float ammo_cells;
-.float ammo_plasma;
-.float ammo_fuel;
-.float ammo_none;
+.int ammo_shells;
+.int ammo_nails;
+.int ammo_rockets;
+.int ammo_cells;
+.int ammo_plasma;
+.int ammo_fuel;
+.int ammo_none;
// other useful macros
#define WEP_ACTION(wpn,wrequest) (get_weaponinfo(wpn)).weapon_func(wrequest)
// Weapon Registration
// =====================
-float w_null(float dummy);
+bool w_null(int dummy);
void register_weapon(
- float id,
+ int id,
WepSet bit,
- float(float) func,
- .float ammotype,
- float i,
- float weapontype,
+ bool(int) func,
+ .int ammotype,
+ int i,
+ int weapontype,
float pickupbasevalue,
vector clr,
string modelname,
.int weapon; // M: WEP_id // WEP_...
.WepSet weapons; // A: WEPSET_id // WEPSET_...
.float(float) weapon_func; // M: function // w_...
-..float ammo_field; // M: ammotype // main ammo field
+..int ammo_field; // M: ammotype // main ammo field
.int impulse; // M: impulse // weapon impulse
.int spawnflags; // M: flags // WEPSPAWNFLAG_... combined
.float bot_pickupbasevalue; // M: rating // bot weapon priority
#define REGISTER_WEAPON_2(id,bit,function,ammotype,impulse,flags,rating,color,modelname,simplemdl,crosshair,wepimg,refname,wepname) \
int id; \
WepSet bit; \
- float function(float); \
+ bool function(int); \
void RegisterWeapons_##id() \
{ \
WEP_LAST = (id = WEP_FIRST + WEP_COUNT); \
self.frame2time = self.frame1time;
}
}
-void CSQCModel_InterpolateAnimation_PreNote(float sf)
+void CSQCModel_InterpolateAnimation_PreNote(int sf)
{
#ifdef CSQCMODEL_HAVE_TWO_FRAMES
CSQCModel_InterpolateAnimation_2To4_PreNote(sf);
self.frame1time = time;
}
}
-void CSQCModel_InterpolateAnimation_Note(float sf)
+void CSQCModel_InterpolateAnimation_Note(int sf)
{
#ifdef CSQCMODEL_HAVE_TWO_FRAMES
CSQCModel_InterpolateAnimation_2To4_Note(sf, true);
// this is exported for custom frame animation code. Use with care.
// to update frames, first call this:
-void CSQCModel_InterpolateAnimation_2To4_PreNote(float sf);
-void CSQCModel_InterpolateAnimation_1To2_PreNote(float sf);
+void CSQCModel_InterpolateAnimation_2To4_PreNote(int sf);
+void CSQCModel_InterpolateAnimation_1To2_PreNote(int sf);
// then update frame, frame1time (and possibly frame2, frame2time, lerpfrac)
// if set_times is not set, caller is responsible for frame1time, frame2time, csqcmodel_lerpfractime!
-void CSQCModel_InterpolateAnimation_2To4_Note(float sf, float set_times);
-void CSQCModel_InterpolateAnimation_1To2_Note(float sf, float set_times);
+void CSQCModel_InterpolateAnimation_2To4_Note(int sf, float set_times);
+void CSQCModel_InterpolateAnimation_1To2_Note(int sf, float set_times);
// to retrieve animation state, call this
void CSQCModel_InterpolateAnimation_2To4_Do();
void CSQCModel_InterpolateAnimation_1To2_Do();
// generic CSQC model code
-float CSQCModel_Send(entity to, int sf)
+bool CSQCModel_Send(entity to, int sf)
{
// some nice flags for CSQCMODEL_IF
float isplayer = (IS_CLIENT(self));
METHOD(ListBox, focusLeave, void(entity))
ATTRIB(ListBox, focusable, float, 1)
ATTRIB(ListBox, allowFocusSound, float, 1)
- ATTRIB(ListBox, selectedItem, float, 0)
+ ATTRIB(ListBox, selectedItem, int, 0)
ATTRIB(ListBox, size, vector, '0 0 0')
ATTRIB(ListBox, origin, vector, '0 0 0')
ATTRIB(ListBox, scrollPos, float, 0) // measured in window heights, fixed when needed
METHOD(TextSlider, configureTextSliderValues, void(entity, string))
ATTRIBARRAY(TextSlider, valueStrings, string, 256)
ATTRIBARRAY(TextSlider, valueIdentifiers, string, 256)
- ATTRIB(TextSlider, nValues, float, 0)
+ ATTRIB(TextSlider, nValues, int, 0)
ENDCLASS(TextSlider)
#endif
#ifdef IMPLEMENTATION
-string TextSlider_valueToIdentifier(entity me, float val)
+string TextSlider_valueToIdentifier(entity me, int val)
{
if(val >= me.nValues)
return "custom";
return "custom";
return me.(valueIdentifiers[val]);
}
-string TextSlider_valueToText(entity me, float val)
+string TextSlider_valueToText(entity me, int val)
{
if(val >= me.nValues)
return _("Custom");
}
void TextSlider_setValueFromIdentifier(entity me, string id)
{
- float i;
+ int i;
for(i = 0; i < me.nValues; ++i)
if(me.valueToIdentifier(me, i) == id)
{
me.(valueIdentifiers[me.nValues]) = theIdentifier;
me.nValues += 1;
}
-void TextSlider_insertValue(entity me, float pos, string theString, string theIdentifier)
+void TextSlider_insertValue(entity me, int pos, string theString, string theIdentifier)
{
- float i;
+ int i;
for (i = me.nValues; i > pos; --i)
{
me.(valueStrings[i]) = me.(valueStrings[i-1]);
menuMousePos = focus.origin + 0.5 * focus.size;
menuMousePos.x *= 1 / conwidth;
menuMousePos.y *= 1 / conheight;
- if(wnd.focused) // why does this never happen?
+ entity par = wnd.parent;
+ if(par.focused)
+ par.setFocus(par, wnd);
+ if(wnd.focused)
m_focus_item_chain(wnd, focus);
}
}
void rewrapCampaign(float w, float l0, float emptyheight, vector theFontSize)
{
- float i, j;
- float n, l;
+ int i, j;
+ int n;
+ float l;
string r, s;
for(i = 0; i < campaign_entries; ++i)
{
{
CampaignList_LoadMap(me, me);
}
-void XonoticCampaignList_drawListBoxItem(entity me, float i, vector absSize, float isSelected)
+void XonoticCampaignList_drawListBoxItem(entity me, int i, vector absSize, bool isSelected)
{
string s;
vector theColor;
e.configureXonoticTextSlider(e, pCvar);
// clear old values
- float i;
+ int i;
for(i = 0; i <= e.nValues; ++i);
{
if(e.(valueStrings[i])) { strunzone(e.(valueStrings[i])); }
#endif
#ifdef IMPLEMENTATION
-void XonoticMapInfoDialog_loadMapInfo(entity me, float i, entity mlb)
+void XonoticMapInfoDialog_loadMapInfo(entity me, int i, entity mlb)
{
me.currentMapIndex = i;
me.startButton.onClickEntity = mlb;
void XonoticMapInfoDialog_fill(entity me)
{
entity e;
- float w, wgt, i, n;
+ int i;
+ float w, wgt, n;
me.TR(me);
me.TDempty(me, 0.2);
me.TD(me, me.rows - 2, 3, e = makeXonoticImage(string_null, 4.0/3.0));
#ifdef INTERFACE
CLASS(XonoticKeyBinder) EXTENDS(XonoticListBox)
METHOD(XonoticKeyBinder, configureXonoticKeyBinder, void(entity))
- ATTRIB(XonoticKeyBinder, rowsPerItem, float, 1)
+ ATTRIB(XonoticKeyBinder, rowsPerItem, int, 1)
METHOD(XonoticKeyBinder, drawListBoxItem, void(entity, float, vector, float))
METHOD(XonoticKeyBinder, doubleClickListBoxItem, void(entity, float, vector))
METHOD(XonoticKeyBinder, resizeNotify, void(entity, vector, vector, vector, vector))
ATTRIB(XonoticKeyBinder, columnKeysOrigin, float, 0)
ATTRIB(XonoticKeyBinder, columnKeysSize, float, 0)
- ATTRIB(XonoticKeyBinder, previouslySelected, float, -1)
+ ATTRIB(XonoticKeyBinder, previouslySelected, int, -1)
ATTRIB(XonoticKeyBinder, inMouseHandler, float, 0)
ATTRIB(XonoticKeyBinder, userbindEditButton, entity, NULL)
ATTRIB(XonoticKeyBinder, keyGrabButton, entity, NULL)
const string KEY_NOT_BOUND_CMD = "// not bound";
-const float MAX_KEYS_PER_FUNCTION = 2;
-const float MAX_KEYBINDS = 256;
+const int MAX_KEYS_PER_FUNCTION = 2;
+const int MAX_KEYBINDS = 256;
string Xonotic_KeyBinds_Functions[MAX_KEYBINDS];
string Xonotic_KeyBinds_Descriptions[MAX_KEYBINDS];
-float Xonotic_KeyBinds_Count = -1;
+int Xonotic_KeyBinds_Count = -1;
void Xonotic_KeyBinds_Read()
{
- float fh;
+ int fh;
string s;
Xonotic_KeyBinds_Count = 0;
}
void replace_bind(string from, string to)
{
- float n, j, k;
+ int n, j;
+ float k; // not sure if float or int
n = tokenize(findkeysforcommand(from, 0)); // uses '...' strings
for(j = 0; j < n; ++j)
{
me.clearButton.disabled = 1;
keyGrabber = me;
}
-void XonoticKeyBinder_keyGrabbed(entity me, float key, float ascii)
+void XonoticKeyBinder_keyGrabbed(entity me, int key, bool ascii)
{
- float n, j, k, nvalid;
+ int n, j, nvalid;
+ float k;
string func;
me.keyGrabButton.forcePressed = 0;
{
KeyBinder_Bind_Change(NULL, me);
}
-void XonoticKeyBinder_setSelected(entity me, float i)
+void XonoticKeyBinder_setSelected(entity me, int i)
{
// handling of "unselectable" items
i = floor(0.5 + bound(0, i, me.nItems - 1));
me.userbindEditButton.disabled = (substring(Xonotic_KeyBinds_Descriptions[i], 0, 1) != "$");
SUPER(XonoticKeyBinder).setSelected(me, i);
}
-float XonoticKeyBinder_keyDown(entity me, float key, float ascii, float shift)
+float XonoticKeyBinder_keyDown(entity me, int key, bool ascii, float shift)
{
- float r;
- r = 1;
+ bool r = true;
switch(key)
{
case K_ENTER:
}
return r;
}
-void XonoticKeyBinder_drawListBoxItem(entity me, float i, vector absSize, float isSelected)
+void XonoticKeyBinder_drawListBoxItem(entity me, int i, vector absSize, bool isSelected)
{
string s;
- float j, k, n;
+ int j, n;
+ float k;
vector theColor;
float theAlpha;
string func, descr;
void ServerList_Update_favoriteButton(entity btn, entity me);
// fields for category entities
-const float MAX_CATEGORIES = 9;
-const float CATEGORY_FIRST = 1;
+const int MAX_CATEGORIES = 9;
+const int CATEGORY_FIRST = 1;
entity categories[MAX_CATEGORIES];
-float category_ent_count;
+int category_ent_count;
.string cat_name;
.string cat_string;
.string cat_enoverride_string;
.float cat_dioverride;
// fields for drawing categories
-float category_name[MAX_CATEGORIES];
-float category_item[MAX_CATEGORIES];
-float category_draw_count;
+int category_name[MAX_CATEGORIES];
+int category_item[MAX_CATEGORIES];
+int category_draw_count;
#define SLIST_CATEGORIES \
SLIST_CATEGORY(CAT_FAVORITED, "", "", ZCTX(_("SLCAT^Favorites"))) \
#define SLIST_CATEGORY_AUTOCVAR(name) autocvar_menu_slist_categories_##name##_override
#define SLIST_CATEGORY(name,enoverride,dioverride,str) \
- float name; \
+ int name; \
string SLIST_CATEGORY_AUTOCVAR(name) = enoverride;
SLIST_CATEGORIES
#undef SLIST_CATEGORY
SLIST_CATEGORIES
#undef SLIST_CATEGORY
- float i, x, catnum;
+ int i, x, catnum;
string s;
#define PROCESS_OVERRIDE(override_string,override_field) \
}
// Supporting Functions
-entity RetrieveCategoryEnt(float catnum)
+entity RetrieveCategoryEnt(int catnum)
{
if((catnum > 0) && (catnum <= category_ent_count))
{
}
}
-float IsServerInList(string list, string srv)
+bool IsServerInList(string list, string srv)
{
string p;
- float i, n;
+ int i, n;
if(srv == "")
return false;
srv = netaddress_resolve(srv, 26000);
return false;
}
-float CheckCategoryOverride(float cat)
+int CheckCategoryOverride(int cat)
{
entity catent = RetrieveCategoryEnt(cat);
if(catent)
{
- float override = (autocvar_menu_slist_categories ? catent.cat_enoverride : catent.cat_dioverride);
+ int override = (autocvar_menu_slist_categories ? catent.cat_enoverride : catent.cat_dioverride);
if(override) { return override; }
else { return cat; }
}
}
}
-float CheckCategoryForEntry(float entry)
+int CheckCategoryForEntry(int entry)
{
string s, k, v, modtype = "";
- float j, m, impure = 0, freeslots = 0, sflags = 0;
+ int j, m, impure = 0, freeslots = 0, sflags = 0;
s = gethostcachestring(SLIST_FIELD_QCSTATUS, entry);
m = tokenizebyseparator(s, ":");
void XonoticServerList_toggleFavorite(entity me, string srv)
{
string s, s0, s1, s2, srv_resolved, p;
- float i, n, f;
+ int i, n;
+ bool f = false;
srv_resolved = netaddress_resolve(srv, 26000);
p = crypto_getidfp(srv_resolved);
s = cvar_string("net_slist_favorites");
n = tokenize_console(s);
- f = 0;
for(i = 0; i < n; ++i)
{
if(substring(argv(i), 0, 1) != "[" && strlen(argv(i)) == 44 && strstrofs(argv(i), ".", 0) < 0)
cvar_set("net_slist_favorites", strcat(s0, s1, s2));
s = cvar_string("net_slist_favorites");
n = tokenize_console(s);
- f = 1;
+ f = true;
--i;
}
// clear list
me.nItems = 0;
}
-void XonoticServerList_setSelected(entity me, float i)
+void XonoticServerList_setSelected(entity me, int i)
{
- float save;
- save = me.selectedItem;
+ //int save = me.selectedItem;
SUPER(XonoticServerList).setSelected(me, i);
/*
if(me.selectedItem == save)
me.ipAddressBox.cursorPos = strlen(me.selectedServer);
me.ipAddressBoxFocused = -1;
}
-void XonoticServerList_refreshServerList(entity me, float mode)
+void XonoticServerList_refreshServerList(entity me, int mode)
{
//print("refresh of type ", ftos(mode), "\n");
if(mode >= REFRESHSERVERLIST_REFILTER)
{
- float m, i, n;
- float listflags = 0;
+ float m;
+ int i, n;
+ int listflags = 0;
string s, typestr, modstr;
s = me.filterString;
void XonoticServerList_draw(entity me)
{
- float i, found, owned;
+ int i;
+ bool found = false, owned;
if(_Nex_ExtResponseSystem_BannedServersNeedsRefresh)
{
me.infoButton.disabled = ((me.nItems == 0) || !owned);
me.favoriteButton.disabled = ((me.nItems == 0) && (me.ipAddressBox.text == ""));
- found = 0;
if(me.selectedServer)
{
for(i = 0; i < me.nItems; ++i)
if(gethostcachestring(SLIST_FIELD_CNAME, i) == me.selectedServer)
{
me.selectedItem = i;
- found = 1;
+ found = true;
break;
}
}
me.ipAddressBox.cursorPos = 0;
me.ipAddressBoxFocused = -1;
}
-void XonoticServerList_setSortOrder(entity me, float fld, float direction)
+void XonoticServerList_setSortOrder(entity me, int fld, int direction)
{
if(me.currentSortField == fld)
direction = -me.currentSortOrder;
me.positionSortButton(me, me.sortButton4, me.columnTypeOrigin, me.columnTypeSize, _("Type"), ServerList_TypeSort_Click);
me.positionSortButton(me, me.sortButton5, me.columnPlayersOrigin, me.columnPlayersSize, _("Players"), ServerList_PlayerSort_Click);
- float f;
- f = me.currentSortField;
+ int f = me.currentSortField;
if(f >= 0)
{
me.currentSortField = -1;
vector sz = boxToGlobalSize(eY * me.itemHeight + eX * (1 - me.controlWidth), me.size);
DialogOpenButton_Click_withCoords(me, main.serverInfoDialog, org, sz);
}
-void XonoticServerList_doubleClickListBoxItem(entity me, float i, vector where)
+void XonoticServerList_doubleClickListBoxItem(entity me, int i, vector where)
{
ServerList_Connect_Click(NULL, me);
}
-void XonoticServerList_drawListBoxItem(entity me, float i, vector absSize, float isSelected)
+void XonoticServerList_drawListBoxItem(entity me, int i, vector absSize, bool isSelected)
{
// layout: Ping, Server name, Map name, NP, TP, MP
- float p, q;
- float isv4, isv6;
+ float p;
+ int q;
+ bool isv4, isv6;
vector theColor;
float theAlpha;
- float m, pure, freeslots, j, sflags;
+ bool pure = false;
+ int freeslots = -1, sflags = -1, j, m;
string s, typestr, versionstr, k, v, modname;
//printf("time: %f, i: %d, item: %d, nitems: %d\n", time, i, item, me.nItems);
versionstr = argv(1);
}
freeslots = -1;
- sflags = -1;
modname = "";
- pure = 0;
for(j = 2; j < m; ++j)
{
if(argv(j) == "")
k = substring(argv(j), 0, 1);
v = substring(argv(j), 1, -1);
if(k == "P")
- pure = stof(v);
+ pure = stob(v);
else if(k == "S")
freeslots = stof(v);
else if(k == "F")
- sflags = stof(v);
+ sflags = stoi(v);
else if(k == "M")
modname = v;
}
if(modname != "CTS")
if(modname != "NIX")
if(modname != "NewToys")
- pure = 0;
+ pure = false;
if(gethostcachenumber(SLIST_FIELD_FREESLOTS, i) <= 0)
theAlpha = SKINALPHA_SERVERLIST_FULL;
theAlpha = 1;
p = gethostcachenumber(SLIST_FIELD_PING, i);
- const float PING_LOW = 75;
- const float PING_MED = 200;
- const float PING_HIGH = 500;
+ const int PING_LOW = 75;
+ const int PING_MED = 200;
+ const int PING_HIGH = 500;
if(p < PING_LOW)
theColor = SKINCOLOR_SERVERLIST_LOWPING + (SKINCOLOR_SERVERLIST_MEDPING - SKINCOLOR_SERVERLIST_LOWPING) * (p / PING_LOW);
else if(p < PING_MED)
s = gethostcachestring(SLIST_FIELD_CNAME, i);
- isv4 = isv6 = 0;
+ isv4 = isv6 = false;
if(substring(s, 0, 1) == "[")
{
- isv6 = 1;
+ isv6 = true;
me.seenIPv6 += 1;
}
else if(strstrofs("0123456789", substring(s, 0, 1), 0) >= 0)
{
- isv4 = 1;
+ isv4 = true;
me.seenIPv4 += 1;
}
draw_Text(me.realUpperMargin * eY + (me.columnPlayersOrigin + (me.columnPlayersSize - draw_TextWidth(s, 0, me.realFontSize)) * 0.5) * eX, s, me.realFontSize, theColor, theAlpha, 0);
}
-float XonoticServerList_keyDown(entity me, float scan, float ascii, float shift)
+bool XonoticServerList_keyDown(entity me, int scan, bool ascii, bool shift)
{
vector org, sz;
if(scan == K_ENTER || scan == K_KP_ENTER)
{
ServerList_Connect_Click(NULL, me);
- return 1;
+ return true;
}
else if(scan == K_MOUSE2 || scan == K_SPACE)
{
m_play_click_sound(MENU_SOUND_OPEN);
main.serverInfoDialog.loadServerInfo(main.serverInfoDialog, me.selectedItem);
DialogOpenButton_Click_withCoords(me, main.serverInfoDialog, org, sz);
- return 1;
+ return true;
}
- return 0;
+ return false;
}
else if(scan == K_INS || scan == K_MOUSE3 || scan == K_KP_INS)
{
{
me.toggleFavorite(me, me.selectedServer);
me.ipAddressBoxFocused = -1;
- return 1;
+ return true;
}
- return 0;
+ return false;
}
else if(SUPER(XonoticServerList).keyDown(me, scan, ascii, shift))
- return 1;
+ return true;
else if(!me.controlledTextbox)
- return 0;
+ return false;
else
return me.controlledTextbox.keyDown(me.controlledTextbox, scan, ascii, shift);
}
-float XonoticServerList_getTotalHeight(entity me) {
+float XonoticServerList_getTotalHeight(entity me)
+{
float num_normal_rows = me.nItems;
- float num_headers = category_draw_count;
+ int num_headers = category_draw_count;
return me.itemHeight * (num_normal_rows + me.categoriesHeight * num_headers);
}
-float XonoticServerList_getItemAtPos(entity me, float pos) {
+int XonoticServerList_getItemAtPos(entity me, float pos)
+{
pos = pos / me.itemHeight;
- float i;
+ int i;
for (i = category_draw_count - 1; i >= 0; --i) {
- float itemidx = category_item[i];
+ int itemidx = category_item[i];
float itempos = i * me.categoriesHeight + category_item[i];
if (pos >= itempos + me.categoriesHeight + 1)
return itemidx + 1 + floor(pos - (itempos + me.categoriesHeight + 1));
// No category matches? Note that category 0 is... 0. Therefore no headings exist at all.
return floor(pos);
}
-float XonoticServerList_getItemStart(entity me, float item) {
- float i;
+float XonoticServerList_getItemStart(entity me, int item)
+{
+ int i;
for (i = category_draw_count - 1; i >= 0; --i) {
- float itemidx = category_item[i];
+ int itemidx = category_item[i];
float itempos = i * me.categoriesHeight + category_item[i];
if (item >= itemidx + 1)
return (itempos + me.categoriesHeight + 1 + item - (itemidx + 1)) * me.itemHeight;
// No category matches? Note that category 0 is... 0. Therefore no headings exist at all.
return item * me.itemHeight;
}
-float XonoticServerList_getItemHeight(entity me, float item) {
- float i;
+float XonoticServerList_getItemHeight(entity me, int item)
+{
+ int i;
for (i = 0; i < category_draw_count; ++i) {
// Matches exactly the headings with increased height.
if (item == category_item[i])
}
float XonoticWeaponsList_mouseDrag(entity me, vector pos)
{
- float f, i;
- i = me.selectedItem;
- f = SUPER(XonoticWeaponsList).mouseDrag(me, pos);
+ int i = me.selectedItem;
+ float f = SUPER(XonoticWeaponsList).mouseDrag(me, pos);
if(me.pressed != 1) // don't change priority if the person is just scrolling
{
float autocvar_g_balance_keyhunt_dropvelocity;
float autocvar_g_balance_keyhunt_maxdist;
float autocvar_g_balance_keyhunt_protecttime;
-float autocvar_g_balance_keyhunt_score_capture;
-float autocvar_g_balance_keyhunt_score_carrierfrag;
-float autocvar_g_balance_keyhunt_score_collect;
-float autocvar_g_balance_keyhunt_score_destroyed;
-float autocvar_g_balance_keyhunt_score_destroyed_ownfactor;
-float autocvar_g_balance_keyhunt_score_push;
+int autocvar_g_balance_keyhunt_score_capture;
+int autocvar_g_balance_keyhunt_score_carrierfrag;
+int autocvar_g_balance_keyhunt_score_collect;
+int autocvar_g_balance_keyhunt_score_destroyed;
+int autocvar_g_balance_keyhunt_score_destroyed_ownfactor;
+int autocvar_g_balance_keyhunt_score_push;
float autocvar_g_balance_keyhunt_throwvelocity;
float autocvar_g_balance_kill_delay;
float autocvar_g_balance_kill_antispam;
float autocvar_g_balance_nexball_secondary_lifetime;
float autocvar_g_balance_nexball_secondary_refire;
float autocvar_g_balance_nexball_secondary_speed;
-float autocvar_g_balance_nix_ammo_cells;
-float autocvar_g_balance_nix_ammo_plasma;
-float autocvar_g_balance_nix_ammo_fuel;
-float autocvar_g_balance_nix_ammo_nails;
-float autocvar_g_balance_nix_ammo_rockets;
-float autocvar_g_balance_nix_ammo_shells;
-float autocvar_g_balance_nix_ammoincr_cells;
-float autocvar_g_balance_nix_ammoincr_plasma;
-float autocvar_g_balance_nix_ammoincr_fuel;
-float autocvar_g_balance_nix_ammoincr_nails;
-float autocvar_g_balance_nix_ammoincr_rockets;
-float autocvar_g_balance_nix_ammoincr_shells;
+int autocvar_g_balance_nix_ammo_cells;
+int autocvar_g_balance_nix_ammo_plasma;
+int autocvar_g_balance_nix_ammo_fuel;
+int autocvar_g_balance_nix_ammo_nails;
+int autocvar_g_balance_nix_ammo_rockets;
+int autocvar_g_balance_nix_ammo_shells;
+int autocvar_g_balance_nix_ammoincr_cells;
+int autocvar_g_balance_nix_ammoincr_plasma;
+int autocvar_g_balance_nix_ammoincr_fuel;
+int autocvar_g_balance_nix_ammoincr_nails;
+int autocvar_g_balance_nix_ammoincr_rockets;
+int autocvar_g_balance_nix_ammoincr_shells;
float autocvar_g_balance_nix_incrtime;
float autocvar_g_balance_nix_roundtime;
float autocvar_g_balance_pause_armor_rot;
float autocvar_g_balance_powerup_strength_time;
float autocvar_g_balance_superweapons_time;
float autocvar_g_balance_selfdamagepercent;
-float autocvar_g_balance_teams;
-float autocvar_g_balance_teams_prevent_imbalance;
+bool autocvar_g_balance_teams;
+bool autocvar_g_balance_teams_prevent_imbalance;
float autocvar_g_balance_teams_scorefactor;
float autocvar_g_ballistics_density_corpse;
float autocvar_g_ballistics_density_player;
float autocvar_g_ban_sync_interval;
float autocvar_g_ban_sync_timeout;
string autocvar_g_ban_sync_trusted_servers;
-float autocvar_g_ban_sync_trusted_servers_verify;
+bool autocvar_g_ban_sync_trusted_servers_verify;
string autocvar_g_ban_sync_uri;
string autocvar_g_banned_list;
-float autocvar_g_banned_list_idmode;
-float autocvar_g_bastet;
-float autocvar_g_botclip_collisions;
-float autocvar_g_bugrigs;
+bool autocvar_g_banned_list_idmode;
+bool autocvar_g_bastet;
+bool autocvar_g_botclip_collisions;
+bool autocvar_g_bugrigs;
float autocvar_g_ca_damage2score_multiplier;
-float autocvar_g_ca_point_leadlimit;
-float autocvar_g_ca_point_limit;
+int autocvar_g_ca_point_leadlimit;
+int autocvar_g_ca_point_limit;
float autocvar_g_ca_round_timelimit;
-float autocvar_g_ca_spectate_enemies;
-float autocvar_g_ca_teams;
-float autocvar_g_ca_teams_override;
-float autocvar_g_ca_team_spawns;
+bool autocvar_g_ca_spectate_enemies;
+int autocvar_g_ca_teams;
+int autocvar_g_ca_teams_override;
+bool autocvar_g_ca_team_spawns;
float autocvar_g_ca_warmup;
-float autocvar_g_campaign;
+bool autocvar_g_campaign;
#define autocvar_g_campaign_forceteam cvar("g_campaign_forceteam")
-float autocvar_g_campaign_skill;
-float autocvar_g_casings;
-float autocvar_g_changeteam_banned;
+int autocvar_g_campaign_skill;
+int autocvar_g_casings;
+bool autocvar_g_changeteam_banned;
float autocvar_g_chat_flood_burst;
float autocvar_g_chat_flood_burst_team;
float autocvar_g_chat_flood_burst_tell;
float autocvar_g_chat_flood_lmax;
float autocvar_g_chat_flood_lmax_team;
float autocvar_g_chat_flood_lmax_tell;
-float autocvar_g_chat_flood_notify_flooder;
+bool autocvar_g_chat_flood_notify_flooder;
float autocvar_g_chat_flood_spl;
float autocvar_g_chat_flood_spl_team;
float autocvar_g_chat_flood_spl_tell;
-float autocvar_g_chat_nospectators;
-float autocvar_g_chat_teamcolors;
-float autocvar_g_chat_tellprivacy;
+int autocvar_g_chat_nospectators;
+bool autocvar_g_chat_teamcolors;
+bool autocvar_g_chat_tellprivacy;
bool autocvar_g_ctf_allow_vehicle_carry;
bool autocvar_g_ctf_allow_vehicle_touch;
bool autocvar_g_ctf_allow_monster_touch;
float autocvar_g_ctf_drop_velocity_up;
float autocvar_g_ctf_drop_velocity_side;
bool autocvar_g_ctf_oneflag_reverse;
-float autocvar_g_ctf_portalteleport;
+bool autocvar_g_ctf_portalteleport;
bool autocvar_g_ctf_pass;
float autocvar_g_ctf_pass_arc;
float autocvar_g_ctf_pass_arc_max;
float autocvar_g_ctf_pass_directional_min;
float autocvar_g_ctf_pass_radius;
float autocvar_g_ctf_pass_wait;
-float autocvar_g_ctf_pass_request;
+bool autocvar_g_ctf_pass_request;
float autocvar_g_ctf_pass_turnrate;
float autocvar_g_ctf_pass_timelimit;
float autocvar_g_ctf_pass_velocity;
bool autocvar_g_ctf_flag_return;
float autocvar_g_ctf_flag_return_carried_radius;
float autocvar_g_ctf_flag_return_time;
-float autocvar_g_ctf_flag_return_when_unreachable;
+bool autocvar_g_ctf_flag_return_when_unreachable;
float autocvar_g_ctf_flag_return_damage;
float autocvar_g_ctf_flag_return_damage_delay;
float autocvar_g_ctf_flag_return_dropped;
int autocvar_g_ctf_score_capture_assist;
int autocvar_g_ctf_score_kill;
int autocvar_g_ctf_score_penalty_drop;
-//float autocvar_g_ctf_score_penalty_suicidedrop;
int autocvar_g_ctf_score_penalty_returned;
int autocvar_g_ctf_score_pickup_base;
int autocvar_g_ctf_score_pickup_dropped_early;
int autocvar_g_ctf_score_return;
float autocvar_g_ctf_shield_force;
float autocvar_g_ctf_shield_max_ratio;
-float autocvar_g_ctf_shield_min_negscore;
+int autocvar_g_ctf_shield_min_negscore;
bool autocvar_g_ctf_stalemate;
int autocvar_g_ctf_stalemate_endcondition;
float autocvar_g_ctf_stalemate_time;
float autocvar_g_ctf_dropped_capture_delay;
float autocvar_g_ctf_dropped_capture_radius;
float autocvar_g_cts_finish_kill_delay;
-float autocvar_g_cts_selfdamage;
-float autocvar_g_debug_bot_commands;
-float autocvar_g_domination_default_teams;
-float autocvar_g_domination_disable_frags;
-float autocvar_g_domination_point_amt;
-float autocvar_g_domination_point_fullbright;
-float autocvar_g_domination_point_leadlimit;
-float autocvar_g_domination_roundbased;
-float autocvar_g_domination_roundbased_point_limit;
+bool autocvar_g_cts_selfdamage;
+bool autocvar_g_debug_bot_commands;
+int autocvar_g_domination_default_teams;
+bool autocvar_g_domination_disable_frags;
+int autocvar_g_domination_point_amt;
+bool autocvar_g_domination_point_fullbright;
+int autocvar_g_domination_point_leadlimit;
+bool autocvar_g_domination_roundbased;
+int autocvar_g_domination_roundbased_point_limit;
float autocvar_g_domination_round_timelimit;
float autocvar_g_domination_warmup;
#define autocvar_g_domination_point_limit cvar("g_domination_point_limit")
float autocvar_g_domination_point_rate;
-float autocvar_g_domination_teams_override;
-float autocvar_g_forced_respawn;
+int autocvar_g_domination_teams_override;
+bool autocvar_g_forced_respawn;
string autocvar_g_forced_team_blue;
string autocvar_g_forced_team_otherwise;
string autocvar_g_forced_team_pink;
string autocvar_g_forced_team_red;
string autocvar_g_forced_team_yellow;
-float autocvar_g_freezetag_frozen_damage_trigger;
+bool autocvar_g_freezetag_frozen_damage_trigger;
float autocvar_g_freezetag_frozen_force;
float autocvar_g_freezetag_frozen_maxtime;
float autocvar_g_freezetag_revive_falldamage;
float autocvar_g_freezetag_revive_falldamage_health;
-float autocvar_g_freezetag_revive_nade;
+bool autocvar_g_freezetag_revive_nade;
float autocvar_g_freezetag_revive_nade_health;
-float autocvar_g_freezetag_point_leadlimit;
-float autocvar_g_freezetag_point_limit;
+int autocvar_g_freezetag_point_leadlimit;
+int autocvar_g_freezetag_point_limit;
float autocvar_g_freezetag_revive_extra_size;
float autocvar_g_freezetag_revive_speed;
float autocvar_g_freezetag_revive_clearspeed;
float autocvar_g_freezetag_round_timelimit;
-float autocvar_g_freezetag_teams;
-float autocvar_g_freezetag_teams_override;
-float autocvar_g_freezetag_team_spawns;
+int autocvar_g_freezetag_teams;
+int autocvar_g_freezetag_teams_override;
+bool autocvar_g_freezetag_team_spawns;
float autocvar_g_freezetag_warmup;
#define autocvar_g_friendlyfire cvar("g_friendlyfire")
#define autocvar_g_friendlyfire_virtual cvar("g_friendlyfire_virtual")
#define autocvar_g_friendlyfire_virtual_force cvar("g_friendlyfire_virtual_force")
-float autocvar_g_full_getstatus_responses;
-float autocvar_g_fullbrightitems;
-float autocvar_g_fullbrightplayers;
+bool autocvar_g_full_getstatus_responses;
+bool autocvar_g_fullbrightitems;
+bool autocvar_g_fullbrightplayers;
#define autocvar_g_grappling_hook cvar("g_grappling_hook")
-float autocvar_g_grappling_hook_tarzan;
-float autocvar_g_hitplots;
+int autocvar_g_grappling_hook_tarzan;
+bool autocvar_g_hitplots;
string autocvar_g_hitplots_individuals;
float autocvar_g_jetpack_acceleration_side;
float autocvar_g_jetpack_acceleration_up;
float autocvar_g_jetpack_antigravity;
-float autocvar_g_jetpack_fuel;
+int autocvar_g_jetpack_fuel;
float autocvar_g_jetpack_maxspeed_side;
float autocvar_g_jetpack_maxspeed_up;
-float autocvar_g_keepaway_ballcarrier_effects;
+int autocvar_g_keepaway_ballcarrier_effects;
float autocvar_g_keepaway_ballcarrier_damage;
float autocvar_g_keepaway_ballcarrier_force;
float autocvar_g_keepaway_ballcarrier_highspeed;
float autocvar_g_keepaway_noncarrier_force;
float autocvar_g_keepaway_noncarrier_selfdamage;
float autocvar_g_keepaway_noncarrier_selfforce;
-float autocvar_g_keepaway_noncarrier_warn;
-float autocvar_g_keepaway_score_bckill;
-float autocvar_g_keepaway_score_killac;
-float autocvar_g_keepaway_score_timepoints;
+bool autocvar_g_keepaway_noncarrier_warn;
+int autocvar_g_keepaway_score_bckill;
+int autocvar_g_keepaway_score_killac;
+int autocvar_g_keepaway_score_timepoints;
float autocvar_g_keepaway_score_timeinterval;
float autocvar_g_keepawayball_damageforcescale;
-float autocvar_g_keepawayball_effects;
+int autocvar_g_keepawayball_effects;
float autocvar_g_keepawayball_respawntime;
-float autocvar_g_keepawayball_trail_color;
-float autocvar_g_keyhunt_point_leadlimit;
+int autocvar_g_keepawayball_trail_color;
+int autocvar_g_keyhunt_point_leadlimit;
#define autocvar_g_keyhunt_point_limit cvar("g_keyhunt_point_limit")
-float autocvar_g_keyhunt_teams;
-float autocvar_g_keyhunt_teams_override;
-float autocvar_g_lms_extra_lives;
-float autocvar_g_lms_join_anytime;
-float autocvar_g_lms_last_join;
+int autocvar_g_keyhunt_teams;
+int autocvar_g_keyhunt_teams_override;
+int autocvar_g_lms_extra_lives;
+bool autocvar_g_lms_join_anytime;
+int autocvar_g_lms_last_join;
#define autocvar_g_lms_lives_override cvar("g_lms_lives_override")
-float autocvar_g_lms_regenerate;
+bool autocvar_g_lms_regenerate;
#define autocvar_g_maplist cvar_string("g_maplist")
-float autocvar_g_maplist_check_waypoints;
-float autocvar_g_maplist_index;
+bool autocvar_g_maplist_check_waypoints;
+int autocvar_g_maplist_index;
string autocvar_g_maplist_mostrecent;
-float autocvar_g_maplist_mostrecent_count;
-float autocvar_g_maplist_selectrandom;
+int autocvar_g_maplist_mostrecent_count;
+bool autocvar_g_maplist_selectrandom;
float autocvar_g_maplist_shuffle;
#define autocvar_g_maplist_votable cvar("g_maplist_votable")
-float autocvar_g_maplist_votable_abstain;
+bool autocvar_g_maplist_votable_abstain;
float autocvar_g_maplist_votable_keeptwotime;
-float autocvar_g_maplist_votable_nodetail;
+bool autocvar_g_maplist_votable_nodetail;
string autocvar_g_maplist_votable_screenshot_dir;
-float autocvar_g_maplist_votable_suggestions;
-float autocvar_g_maplist_votable_suggestions_override_mostrecent;
+bool autocvar_g_maplist_votable_suggestions;
+bool autocvar_g_maplist_votable_suggestions_override_mostrecent;
float autocvar_g_maplist_votable_timeout;
-float autocvar_g_maxplayers;
+int autocvar_g_maxplayers;
float autocvar_g_maxplayers_spectator_blocktime;
float autocvar_g_maxpushtime;
float autocvar_g_maxspeed;
float autocvar_g_midair_shieldtime;
#define autocvar_g_instagib cvar("g_instagib")
-float autocvar_g_instagib_ammo_drop;
-float autocvar_g_instagib_extralives;
+int autocvar_g_instagib_ammo_drop;
+int autocvar_g_instagib_extralives;
float autocvar_g_instagib_speed_highspeed;
float autocvar_g_instagib_invis_alpha;
#define autocvar_g_mirrordamage cvar("g_mirrordamage")
#define autocvar_g_mirrordamage_virtual cvar("g_mirrordamage_virtual")
float autocvar_g_movement_highspeed = 1;
-float autocvar_g_multijump;
+int autocvar_g_multijump;
float autocvar_g_multijump_add;
float autocvar_g_multijump_speed;
string autocvar_g_mutatormsg;
float autocvar_g_nexball_basketball_bouncefactor;
float autocvar_g_nexball_basketball_bouncestop;
float autocvar_g_nexball_basketball_carrier_highspeed;
-float autocvar_g_nexball_basketball_meter;
+bool autocvar_g_nexball_basketball_meter;
float autocvar_g_nexball_basketball_meter_maxpower;
float autocvar_g_nexball_basketball_meter_minpower;
float autocvar_g_nexball_delay_collect;
float autocvar_g_nexball_delay_start;
float autocvar_g_nexball_football_bouncefactor;
float autocvar_g_nexball_football_bouncestop;
-float autocvar_g_nexball_goalleadlimit;
+int autocvar_g_nexball_goalleadlimit;
#define autocvar_g_nexball_goallimit cvar("g_nexball_goallimit")
-float autocvar_g_nexball_radar_showallplayers;
-float autocvar_g_nexball_sound_bounce;
-float autocvar_g_nexball_trail_color;
+bool autocvar_g_nexball_radar_showallplayers;
+bool autocvar_g_nexball_sound_bounce;
+int autocvar_g_nexball_trail_color;
//float autocvar_g_nick_flood_penalty;
-float autocvar_g_nick_flood_penalty_red;
-float autocvar_g_nick_flood_penalty_yellow;
+int autocvar_g_nick_flood_penalty_red;
+int autocvar_g_nick_flood_penalty_yellow;
//float autocvar_g_nick_flood_timeout;
-float autocvar_g_nix_with_healtharmor;
-float autocvar_g_nix_with_blaster;
-float autocvar_g_nix_with_powerups;
-float autocvar_g_nodepthtestitems;
-float autocvar_g_nodepthtestplayers;
-float autocvar_g_norecoil;
+bool autocvar_g_nix_with_healtharmor;
+bool autocvar_g_nix_with_blaster;
+bool autocvar_g_nix_with_powerups;
+bool autocvar_g_nodepthtestitems;
+bool autocvar_g_nodepthtestplayers;
+bool autocvar_g_norecoil;
float autocvar_g_onslaught_cp_buildhealth;
float autocvar_g_onslaught_cp_buildtime;
float autocvar_g_onslaught_cp_health;
float autocvar_g_onslaught_cp_regen;
float autocvar_g_onslaught_gen_health;
-float autocvar_g_pickup_cells_max;
-float autocvar_g_pickup_plasma_max;
-float autocvar_g_pickup_fuel_max;
-float autocvar_g_pickup_items;
-float autocvar_g_pickup_nails_max;
-float autocvar_g_pickup_rockets_max;
-float autocvar_g_pickup_shells_max;
+int autocvar_g_pickup_cells_max;
+int autocvar_g_pickup_plasma_max;
+int autocvar_g_pickup_fuel_max;
+int autocvar_g_pickup_items;
+int autocvar_g_pickup_nails_max;
+int autocvar_g_pickup_rockets_max;
+int autocvar_g_pickup_shells_max;
float autocvar_g_player_alpha;
float autocvar_g_player_brightness;
-float autocvar_g_playerclip_collisions;
-float autocvar_g_powerups;
-float autocvar_g_projectiles_damage;
-float autocvar_g_projectiles_keep_owner;
-float autocvar_g_projectiles_newton_style;
+bool autocvar_g_playerclip_collisions;
+int autocvar_g_powerups;
+int autocvar_g_projectiles_damage;
+bool autocvar_g_projectiles_keep_owner;
+int autocvar_g_projectiles_newton_style;
float autocvar_g_projectiles_newton_style_2_maxfactor;
float autocvar_g_projectiles_newton_style_2_minfactor;
-float autocvar_g_projectiles_spread_style;
+int autocvar_g_projectiles_spread_style;
#define autocvar_g_race_laps_limit cvar("g_race_laps_limit")
float autocvar_g_race_qualifying_timelimit;
float autocvar_g_race_qualifying_timelimit_override;
-float autocvar_g_race_teams;
+int autocvar_g_race_teams;
float autocvar_g_respawn_delay_small;
-float autocvar_g_respawn_delay_small_count;
+int autocvar_g_respawn_delay_small_count;
float autocvar_g_respawn_delay_large;
-float autocvar_g_respawn_delay_large_count;
+int autocvar_g_respawn_delay_large_count;
float autocvar_g_respawn_delay_max;
-float autocvar_g_respawn_ghosts;
+bool autocvar_g_respawn_ghosts;
float autocvar_g_respawn_ghosts_maxtime;
float autocvar_g_respawn_ghosts_speed;
-float autocvar_g_respawn_waves;
-float autocvar_g_running_guns;
-float autocvar_g_shootfromcenter;
-float autocvar_g_shootfromclient;
-float autocvar_g_shootfromeye;
+int autocvar_g_respawn_waves;
+bool autocvar_g_running_guns;
+bool autocvar_g_shootfromcenter;
+int autocvar_g_shootfromclient;
+bool autocvar_g_shootfromeye;
string autocvar_g_shootfromfixedorigin;
-float autocvar_g_showweaponspawns;
-float autocvar_g_spawn_alloweffects;
+int autocvar_g_showweaponspawns;
+bool autocvar_g_spawn_alloweffects;
float autocvar_g_spawn_furthest;
-float autocvar_g_spawn_useallspawns;
-float autocvar_g_spawnpoints_auto_move_out_of_solid;
+bool autocvar_g_spawn_useallspawns;
+bool autocvar_g_spawnpoints_auto_move_out_of_solid;
#define autocvar_g_spawnshieldtime cvar("g_spawnshieldtime")
-float autocvar_g_tdm_team_spawns;
-float autocvar_g_tdm_point_limit;
-float autocvar_g_tdm_point_leadlimit;
-float autocvar_g_tdm_teams;
-float autocvar_g_tdm_teams_override;
+bool autocvar_g_tdm_team_spawns;
+int autocvar_g_tdm_point_limit;
+int autocvar_g_tdm_point_leadlimit;
+int autocvar_g_tdm_teams;
+int autocvar_g_tdm_teams_override;
float autocvar_g_teamdamage_resetspeed;
float autocvar_g_teamdamage_threshold;
-float autocvar_g_telefrags;
-float autocvar_g_telefrags_avoid;
-float autocvar_g_telefrags_teamplay;
+bool autocvar_g_telefrags;
+bool autocvar_g_telefrags_avoid;
+bool autocvar_g_telefrags_teamplay;
float autocvar_g_teleport_maxspeed;
-float autocvar_g_throughfloor_debug;
+bool autocvar_g_throughfloor_debug;
float autocvar_g_throughfloor_damage;
float autocvar_g_throughfloor_force;
float autocvar_g_throughfloor_damage_max_stddev;
float autocvar_g_triggerimpulse_accel_power;
float autocvar_g_triggerimpulse_directional_multiplier;
float autocvar_g_triggerimpulse_radial_multiplier;
-float autocvar_g_turrets;
+bool autocvar_g_turrets;
float autocvar_g_turrets_aimidle_delay;
-float autocvar_g_turrets_nofire;
-float autocvar_g_turrets_reloadcvars;
+bool autocvar_g_turrets_nofire;
+bool autocvar_g_turrets_reloadcvars;
float autocvar_g_turrets_targetscan_maxdelay;
float autocvar_g_turrets_targetscan_mindelay;
float autocvar_g_turrets_unit_ewheel_speed_fast;
float autocvar_g_turrets_unit_walker_turn_run;
float autocvar_g_turrets_unit_walker_turn_strafe;
float autocvar_g_turrets_unit_walker_turn_swim;
-float autocvar_g_use_ammunition;
-float autocvar_g_waypointeditor;
-float autocvar_g_waypointeditor_auto;
-float autocvar_g_waypoints_for_items;
+bool autocvar_g_use_ammunition;
+bool autocvar_g_waypointeditor;
+int autocvar_g_waypointeditor_auto;
+int autocvar_g_waypoints_for_items;
float autocvar_g_weapon_charge_colormod_blue_full;
float autocvar_g_weapon_charge_colormod_blue_half;
float autocvar_g_weapon_charge_colormod_green_full;
float autocvar_g_weapon_charge_colormod_red_full;
float autocvar_g_weapon_charge_colormod_red_half;
#define autocvar_g_weapon_stay cvar("g_weapon_stay")
-float autocvar_g_weapon_throwable;
+bool autocvar_g_weapon_throwable;
#define autocvar_g_weaponarena cvar_string("g_weaponarena")
string autocvar_g_xonoticversion;
float autocvar_gameversion;
float autocvar_gameversion_min;
float autocvar_gameversion_max;
string autocvar_hostname;
-float autocvar_lastlevel;
-float autocvar_leadlimit;
-float autocvar_leadlimit_and_fraglimit;
-float autocvar_leadlimit_override;
-float autocvar_loddebug;
-float autocvar_minplayers;
+bool autocvar_lastlevel;
+int autocvar_leadlimit;
+int autocvar_leadlimit_and_fraglimit;
+int autocvar_leadlimit_override;
+int autocvar_loddebug;
+int autocvar_minplayers;
string autocvar_nextmap;
-float autocvar_prvm_backtraceforwarnings;
+bool autocvar_prvm_backtraceforwarnings;
string autocvar_quit_and_redirect;
float autocvar_quit_and_redirect_timer;
-float autocvar_quit_when_empty;
+bool autocvar_quit_when_empty;
float autocvar_r_showbboxes;
-float autocvar_rescan_pending;
-float autocvar_samelevel;
+int autocvar_rescan_pending;
+bool autocvar_samelevel;
string autocvar_sessionid;
#define autocvar_skill cvar("skill")
float autocvar_skill_auto;
#define autocvar_slowmo cvar("slowmo")
float autocvar_snd_soundradius;
-float autocvar_spawn_debug;
-float autocvar_speedmeter;
+int autocvar_spawn_debug;
+bool autocvar_speedmeter;
float autocvar_sv_accelerate;
float autocvar_sv_accuracy_data_share = 1;
string autocvar_sv_adminnick;
float autocvar_sv_airstopaccelerate;
float autocvar_sv_airstrafeaccel_qw;
float autocvar_sv_airstrafeaccelerate;
-float autocvar_sv_autoscreenshot;
-float autocvar_sv_cheats;
+bool autocvar_sv_autoscreenshot;
+int autocvar_sv_cheats;
float autocvar_sv_clientcommand_antispam_time;
-float autocvar_sv_clientcommand_antispam_count;
-float autocvar_sv_curl_serverpackages_auto;
-float autocvar_sv_db_saveasdump;
-float autocvar_sv_defaultcharacter;
+int autocvar_sv_clientcommand_antispam_count;
+bool autocvar_sv_curl_serverpackages_auto;
+bool autocvar_sv_db_saveasdump;
+bool autocvar_sv_defaultcharacter;
string autocvar_sv_defaultplayercolors;
string autocvar_sv_defaultplayermodel;
string autocvar_sv_defaultplayermodel_blue;
string autocvar_sv_defaultplayermodel_pink;
string autocvar_sv_defaultplayermodel_red;
string autocvar_sv_defaultplayermodel_yellow;
-float autocvar_sv_defaultplayerskin;
+int autocvar_sv_defaultplayerskin;
float autocvar_sv_dodging_delay;
float autocvar_sv_dodging_height_threshold;
float autocvar_sv_dodging_horiz_speed;
float autocvar_sv_dodging_horiz_speed_frozen;
float autocvar_sv_dodging_ramp_time;
-float autocvar_sv_dodging_sound;
+bool autocvar_sv_dodging_sound;
float autocvar_sv_dodging_up_speed;
float autocvar_sv_dodging_wall_distance_threshold;
-float autocvar_sv_dodging_wall_dodging;
-float autocvar_sv_dodging_frozen;
-float autocvar_sv_dodging_frozen_doubletap;
-float autocvar_sv_doublejump;
-float autocvar_sv_eventlog;
-float autocvar_sv_eventlog_console;
-float autocvar_sv_eventlog_files;
-float autocvar_sv_eventlog_files_counter;
+bool autocvar_sv_dodging_wall_dodging;
+bool autocvar_sv_dodging_frozen;
+bool autocvar_sv_dodging_frozen_doubletap;
+bool autocvar_sv_doublejump;
+bool autocvar_sv_eventlog;
+bool autocvar_sv_eventlog_console;
+bool autocvar_sv_eventlog_files;
+int autocvar_sv_eventlog_files_counter;
string autocvar_sv_eventlog_files_nameprefix;
string autocvar_sv_eventlog_files_namesuffix;
-float autocvar_sv_eventlog_files_timestamps;
+bool autocvar_sv_eventlog_files_timestamps;
float autocvar_sv_friction;
float autocvar_sv_friction_on_land;
float autocvar_sv_gameplayfix_q2airaccelerate;
-float autocvar_sv_gentle;
+int autocvar_sv_gentle;
#define autocvar_sv_gravity cvar("sv_gravity")
string autocvar_sv_intermission_cdtrack;
string autocvar_sv_jumpspeedcap_max;
float autocvar_sv_jumpspeedcap_max_disable_on_ramps;
string autocvar_sv_jumpspeedcap_min;
float autocvar_sv_jumpvelocity;
-float autocvar_sv_logscores_bots;
-float autocvar_sv_logscores_console;
-float autocvar_sv_logscores_file;
+bool autocvar_sv_logscores_bots;
+bool autocvar_sv_logscores_console;
+bool autocvar_sv_logscores_file;
string autocvar_sv_logscores_filename;
float autocvar_sv_mapchange_delay;
float autocvar_sv_maxairspeed;
float autocvar_sv_maxairstrafespeed;
float autocvar_sv_maxspeed;
string autocvar_sv_motd;
-float autocvar_sv_precacheplayermodels;
+bool autocvar_sv_precacheplayermodels;
//float autocvar_sv_precacheweapons; // WEAPONTODO?
-float autocvar_sv_q3acompat_machineshotgunswap;
-float autocvar_sv_ready_restart;
-float autocvar_sv_ready_restart_after_countdown;
-float autocvar_sv_ready_restart_repeatable;
-float autocvar_sv_servermodelsonly;
-float autocvar_sv_spectate;
+bool autocvar_sv_q3acompat_machineshotgunswap;
+bool autocvar_sv_ready_restart;
+bool autocvar_sv_ready_restart_after_countdown;
+bool autocvar_sv_ready_restart_repeatable;
+bool autocvar_sv_servermodelsonly;
+int autocvar_sv_spectate;
float autocvar_sv_spectator_speed_multiplier;
-float autocvar_sv_status_privacy;
+bool autocvar_sv_status_privacy;
float autocvar_sv_stepheight;
float autocvar_sv_stopspeed;
float autocvar_sv_strengthsound_antispam_refire_threshold;
float autocvar_sv_strengthsound_antispam_time;
-float autocvar_sv_teamnagger;
-float autocvar_sv_timeout;
+bool autocvar_sv_teamnagger;
+bool autocvar_sv_timeout;
float autocvar_sv_timeout_leadtime;
float autocvar_sv_timeout_length;
-float autocvar_sv_timeout_number;
+int autocvar_sv_timeout_number;
float autocvar_sv_timeout_resumetime;
-float autocvar_sv_vote_call;
-float autocvar_sv_vote_change;
+bool autocvar_sv_vote_call;
+bool autocvar_sv_vote_change;
string autocvar_sv_vote_commands;
-float autocvar_sv_vote_gametype;
+bool autocvar_sv_vote_gametype;
float autocvar_sv_vote_gametype_timeout;
string autocvar_sv_vote_gametype_options;
float autocvar_sv_vote_gametype_keeptwotime;
-float autocvar_sv_vote_gametype_default_current;
-float autocvar_sv_vote_limit;
+bool autocvar_sv_vote_gametype_default_current;
+int autocvar_sv_vote_limit;
float autocvar_sv_vote_majority_factor;
float autocvar_sv_vote_majority_factor_of_voted;
-float autocvar_sv_vote_master;
-float autocvar_sv_vote_master_callable;
+bool autocvar_sv_vote_master;
+bool autocvar_sv_vote_master_callable;
string autocvar_sv_vote_master_commands;
string autocvar_sv_vote_master_password;
-float autocvar_sv_vote_master_playerlimit;
-float autocvar_sv_vote_no_stops_vote;
-float autocvar_sv_vote_nospectators;
+int autocvar_sv_vote_master_playerlimit;
+bool autocvar_sv_vote_no_stops_vote;
+int autocvar_sv_vote_nospectators;
//string autocvar_sv_vote_only_commands;
-float autocvar_sv_vote_override_mostrecent;
-float autocvar_sv_vote_singlecount;
+bool autocvar_sv_vote_override_mostrecent;
+bool autocvar_sv_vote_singlecount;
float autocvar_sv_vote_stop;
float autocvar_sv_vote_timeout;
float autocvar_sv_vote_wait;
-float autocvar_sv_vote_gamestart;
+bool autocvar_sv_vote_gamestart;
float autocvar_sv_warsowbunny_accel;
float autocvar_sv_warsowbunny_airforwardaccel;
float autocvar_sv_warsowbunny_backtosideratio;
string autocvar_sv_weaponstats_file;
float autocvar_sv_gibhealth;
float autocvar_sys_ticrate;
-float autocvar_teamplay_lockonrestart;
-float autocvar_teamplay_mode;
+bool autocvar_teamplay_lockonrestart;
+int autocvar_teamplay_mode;
#define autocvar_timelimit cvar("timelimit")
#define autocvar_timelimit_override cvar("timelimit_override")
float autocvar_timelimit_increment;
float autocvar_timelimit_min;
float autocvar_timelimit_max;
float autocvar_timelimit_overtime;
-float autocvar_timelimit_overtimes;
+int autocvar_timelimit_overtimes;
float autocvar_timelimit_suddendeath;
#define autocvar_utf8_enable cvar("utf8_enable")
-float autocvar_waypoint_benchmark;
-float autocvar_sv_gameplayfix_gravityunaffectedbyticrate;
+bool autocvar_waypoint_benchmark;
+bool autocvar_sv_gameplayfix_gravityunaffectedbyticrate;
float autocvar_g_trueaim_minrange;
-float autocvar_g_debug_defaultsounds;
+bool autocvar_g_debug_defaultsounds;
float autocvar_g_grab_range;
-float autocvar_g_sandbox_info;
-float autocvar_g_sandbox_readonly;
+int autocvar_g_sandbox_info;
+bool autocvar_g_sandbox_readonly;
string autocvar_g_sandbox_storage_name;
float autocvar_g_sandbox_storage_autosave;
-float autocvar_g_sandbox_storage_autoload;
+bool autocvar_g_sandbox_storage_autoload;
float autocvar_g_sandbox_editor_flood;
-float autocvar_g_sandbox_editor_maxobjects;
-float autocvar_g_sandbox_editor_free;
+int autocvar_g_sandbox_editor_maxobjects;
+int autocvar_g_sandbox_editor_free;
float autocvar_g_sandbox_editor_distance_spawn;
float autocvar_g_sandbox_editor_distance_edit;
float autocvar_g_sandbox_object_scale_min;
float autocvar_g_sandbox_object_scale_max;
float autocvar_g_sandbox_object_material_velocity_min;
float autocvar_g_sandbox_object_material_velocity_factor;
-float autocvar_g_max_info_autoscreenshot;
-float autocvar_physics_ode;
-float autocvar_g_physical_items;
+int autocvar_g_max_info_autoscreenshot;
+bool autocvar_physics_ode;
+int autocvar_g_physical_items;
float autocvar_g_physical_items_damageforcescale;
float autocvar_g_physical_items_reset;
float autocvar_g_monsters;
-float autocvar_g_monsters_edit;
-float autocvar_g_monsters_sounds;
+bool autocvar_g_monsters_edit;
+bool autocvar_g_monsters_sounds;
float autocvar_g_monsters_think_delay;
-float autocvar_g_monsters_max;
-float autocvar_g_monsters_max_perplayer;
+int autocvar_g_monsters_max;
+int autocvar_g_monsters_max_perplayer;
float autocvar_g_monsters_target_range;
-float autocvar_g_monsters_target_infront;
+bool autocvar_g_monsters_target_infront;
float autocvar_g_monsters_attack_range;
-float autocvar_g_monsters_score_kill;
-float autocvar_g_monsters_score_spawned;
-float autocvar_g_monsters_typefrag;
-float autocvar_g_monsters_owners;
+int autocvar_g_monsters_score_kill;
+int autocvar_g_monsters_score_spawned;
+bool autocvar_g_monsters_typefrag;
+bool autocvar_g_monsters_owners;
float autocvar_g_monsters_miniboss_chance;
float autocvar_g_monsters_miniboss_healthboost;
float autocvar_g_monsters_drop_time;
float autocvar_g_monsters_spawnshieldtime;
-float autocvar_g_monsters_teams;
+bool autocvar_g_monsters_teams;
float autocvar_g_monsters_respawn_delay;
-float autocvar_g_monsters_respawn;
+bool autocvar_g_monsters_respawn;
float autocvar_g_monsters_armor_blockpercent;
float autocvar_g_touchexplode_radius;
float autocvar_g_touchexplode_damage;
float autocvar_g_touchexplode_edgedamage;
float autocvar_g_touchexplode_force;
float autocvar_g_invasion_round_timelimit;
-float autocvar_g_invasion_teams;
-float autocvar_g_invasion_team_spawns;
+int autocvar_g_invasion_teams;
+bool autocvar_g_invasion_team_spawns;
float autocvar_g_invasion_spawnpoint_spawn_delay;
#define autocvar_g_invasion_point_limit cvar("g_invasion_point_limit")
float autocvar_g_invasion_warmup;
-float autocvar_g_invasion_monster_count;
-float autocvar_g_invasion_zombies_only;
+int autocvar_g_invasion_monster_count;
+bool autocvar_g_invasion_zombies_only;
float autocvar_g_invasion_spawn_delay;
#define autocvar_g_bloodloss cvar("g_bloodloss")
float autocvar_g_random_gravity_negative_chance;
float autocvar_g_random_gravity_positive;
float autocvar_g_random_gravity_negative;
float autocvar_g_random_gravity_delay;
-float autocvar_g_nades;
+bool autocvar_g_nades;
vector autocvar_g_nades_throw_offset;
-float autocvar_g_nades_spawn;
-float autocvar_g_nades_spawn_count;
-float autocvar_g_nades_client_select;
+bool autocvar_g_nades_spawn;
+int autocvar_g_nades_spawn_count;
+bool autocvar_g_nades_client_select;
float autocvar_g_nades_nade_lifetime;
float autocvar_g_nades_nade_minforce;
float autocvar_g_nades_nade_maxforce;
float autocvar_g_nades_nade_edgedamage;
float autocvar_g_nades_nade_radius;
float autocvar_g_nades_nade_force;
-float autocvar_g_nades_nade_newton_style;
+int autocvar_g_nades_nade_newton_style;
int autocvar_g_nades_napalm_ball_count;
float autocvar_g_nades_napalm_ball_spread;
float autocvar_g_nades_napalm_ball_damage;
float autocvar_g_nades_napalm_ball_damageforcescale;
float autocvar_g_nades_napalm_ball_lifetime;
float autocvar_g_nades_napalm_ball_radius;
-float autocvar_g_nades_napalm_blast;
+bool autocvar_g_nades_napalm_blast;
float autocvar_g_nades_napalm_fountain_lifetime;
float autocvar_g_nades_napalm_fountain_delay;
float autocvar_g_nades_napalm_fountain_radius;
float autocvar_g_nades_napalm_fountain_damage;
float autocvar_g_nades_napalm_fountain_edgedamage;
float autocvar_g_nades_napalm_burntime;
-float autocvar_g_nades_napalm_selfdamage;
-float autocvar_g_nades_nade_type;
-float autocvar_g_nades_bonus_type;
-float autocvar_g_nades_bonus;
-float autocvar_g_nades_bonus_onstrength;
-float autocvar_g_nades_bonus_client_select;
-float autocvar_g_nades_bonus_max;
-float autocvar_g_nades_bonus_score_max;
-float autocvar_g_nades_bonus_score_time;
-float autocvar_g_nades_bonus_score_time_flagcarrier;
-float autocvar_g_nades_bonus_score_minor;
-float autocvar_g_nades_bonus_score_low;
-float autocvar_g_nades_bonus_score_high;
-float autocvar_g_nades_bonus_score_medium;
-float autocvar_g_nades_bonus_score_spree;
+bool autocvar_g_nades_napalm_selfdamage;
+int autocvar_g_nades_nade_type;
+int autocvar_g_nades_bonus_type;
+bool autocvar_g_nades_bonus;
+bool autocvar_g_nades_bonus_onstrength;
+bool autocvar_g_nades_bonus_client_select;
+int autocvar_g_nades_bonus_max;
+int autocvar_g_nades_bonus_score_max;
+int autocvar_g_nades_bonus_score_time;
+int autocvar_g_nades_bonus_score_time_flagcarrier;
+int autocvar_g_nades_bonus_score_minor;
+int autocvar_g_nades_bonus_score_low;
+int autocvar_g_nades_bonus_score_high;
+int autocvar_g_nades_bonus_score_medium;
+int autocvar_g_nades_bonus_score_spree;
float autocvar_g_nades_ice_freeze_time;
float autocvar_g_nades_ice_health;
-float autocvar_g_nades_ice_explode;
-float autocvar_g_nades_ice_teamcheck;
+bool autocvar_g_nades_ice_explode;
+bool autocvar_g_nades_ice_teamcheck;
float autocvar_g_nades_heal_time;
float autocvar_g_nades_heal_rate;
float autocvar_g_nades_heal_friend;
float autocvar_g_campcheck_damage;
float autocvar_g_campcheck_distance;
float autocvar_g_campcheck_interval;
-float autocvar_g_jump_grunt;
-float autocvar_g_overkill_powerups_replace;
+bool autocvar_g_jump_grunt;
+bool autocvar_g_overkill_powerups_replace;
float autocvar_g_overkill_superguns_respawn_time;
-float autocvar_g_overkill_100h_anyway;
-float autocvar_g_overkill_100a_anyway;
-float autocvar_g_overkill_ammo_charge;
+bool autocvar_g_overkill_100h_anyway;
+bool autocvar_g_overkill_100a_anyway;
+bool autocvar_g_overkill_ammo_charge;
float autocvar_g_overkill_ammo_charge_notice;
float autocvar_g_overkill_ammo_charge_limit;
float autocvar_g_spawn_near_teammate_distance;
-float autocvar_g_spawn_near_teammate_ignore_spawnpoint;
+bool autocvar_g_spawn_near_teammate_ignore_spawnpoint;
float autocvar_g_spawn_near_teammate_ignore_spawnpoint_delay;
float autocvar_g_spawn_near_teammate_ignore_spawnpoint_delay_death;
-float autocvar_g_spawn_near_teammate_ignore_spawnpoint_check_health;
-float autocvar_g_spawn_near_teammate_ignore_spawnpoint_closetodeath;
+int autocvar_g_spawn_near_teammate_ignore_spawnpoint_check_health;
+bool autocvar_g_spawn_near_teammate_ignore_spawnpoint_closetodeath;
float autocvar_g_buffs_waypoint_distance;
-float autocvar_g_buffs_randomize;
+bool autocvar_g_buffs_randomize;
float autocvar_g_buffs_random_lifetime;
-float autocvar_g_buffs_random_location;
-float autocvar_g_buffs_random_location_attempts;
-float autocvar_g_buffs_spawn_count;
-float autocvar_g_buffs_replace_powerups;
+bool autocvar_g_buffs_random_location;
+int autocvar_g_buffs_random_location_attempts;
+int autocvar_g_buffs_spawn_count;
+bool autocvar_g_buffs_replace_powerups;
float autocvar_g_buffs_cooldown_activate;
float autocvar_g_buffs_cooldown_respawn;
float autocvar_g_buffs_resistance_blockpercent;
defaultskin = 0;
chmdl = false;
- if(autocvar_sv_defaultcharacter == 1)
+ if(autocvar_sv_defaultcharacter)
{
if(teamplay)
{
.float ebouncefactor, ebouncestop; // electro's values
// TODO do we need all these fields, or should we stop autodetecting runtime
// changes and just have a console command to update this?
-float ClientInit_SendEntity(entity to, float sf)
+float ClientInit_SendEntity(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_INIT);
WriteByte(MSG_ENTITY, g_nexball_meter_period * 32);
}
}
-void PlayerCorpseDamage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void PlayerCorpseDamage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
float take, save;
vector v;
void player_anim (void);
-void PlayerCorpseDamage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
+void PlayerCorpseDamage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force);
// g_<gametype>_str:
// If 0, default is used.
// Fields
-.void(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force) event_damage;
+.void(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force) event_damage;
//.string wad;
//.string map;
.entity killindicator;
.float killindicator_teamchange;
-void Damage (entity targ, entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
+void Damage (entity targ, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force);
float lockteams;
.float Version;
.int SendFlags;
-.float(entity to, float sendflags) SendEntity;
+.bool(entity to, int sendflags) SendEntity;
// player sounds, voice messages
// TODO implemented fall and falling
.float stat_leadlimit;
-float radar_showennemies;
+bool radar_showennemies;
#ifdef PROFILING
float client_cefc_accumulator;
#endif
.float weapon_load[WEP_MAXCOUNT];
-.float ammo_none; // used by the reloading system, must always be 0
+.int ammo_none; // used by the reloading system, must always be 0
.float clip_load;
.float old_clip_load;
.float clip_size;
.float vortex_chargepool_ammo;
.float hagar_load;
-.float grab; // 0 = can't grab, 1 = owner can grab, 2 = owner and team mates can grab, 3 = anyone can grab
+.int grab; // 0 = can't grab, 1 = owner can grab, 2 = owner and team mates can grab, 3 = anyone can grab
#define PROJECTILE_MAKETRIGGER(e) (e).solid = SOLID_CORPSE; (e).dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE
// when doing this, hagar can go through clones
#include "defs.qh"
#endif
-float Casing_SendEntity(entity to, float sf)
+float Casing_SendEntity(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_CASING);
WriteByte(MSG_ENTITY, self.state); // actually type
#include "spawnpoints.qh"
#endif
-float Damage_DamageInfo_SendEntity(entity to, float sf)
+float Damage_DamageInfo_SendEntity(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_DAMAGEINFO);
WriteShort(MSG_ENTITY, self.projectiledeathtype);
return true;
}
-void Damage_DamageInfo(vector org, float coredamage, float edgedamage, float rad, vector force, float deathtype, float bloodtype, entity dmgowner)
+void Damage_DamageInfo(vector org, float coredamage, float edgedamage, float rad, vector force, int deathtype, float bloodtype, entity dmgowner)
{
// TODO maybe call this from non-edgedamage too?
// TODO maybe make the client do the particle effects for the weapons and the impact sounds using this info?
PlayerTeamScore_AddScore(player, f);
}
-void GiveFrags (entity attacker, entity targ, float f, float deathtype)
+void GiveFrags (entity attacker, entity targ, float f, int deathtype)
{
// TODO route through PlayerScores instead
if(gameover) return;
return s;
}
-void LogDeath(string mode, float deathtype, entity killer, entity killed)
+void LogDeath(string mode, int deathtype, entity killer, entity killed)
{
string s;
if(!autocvar_sv_eventlog)
void Obituary_SpecialDeath(
entity notif_target,
float murder,
- float deathtype,
+ int deathtype,
string s1, string s2, string s3,
float f1, float f2, float f3)
{
float Obituary_WeaponDeath(
entity notif_target,
float murder,
- float deathtype,
+ int deathtype,
string s1, string s2, string s3,
float f1, float f2)
{
return false;
}
-void Obituary(entity attacker, entity inflictor, entity targ, float deathtype)
+void Obituary(entity attacker, entity inflictor, entity targ, int deathtype)
{
// Sanity check
if (!IS_PLAYER(targ)) { backtrace("Obituary called on non-player?!\n"); return; }
targ.iceblock = world;
}
-void Damage (entity targ, entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void Damage (entity targ, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
float mirrordamage;
float mirrorforce;
}
}
-float RadiusDamageForSource (entity inflictor, vector inflictororigin, vector inflictorvelocity, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float inflictorselfdamage, float forceintensity, float deathtype, entity directhitentity)
+float RadiusDamageForSource (entity inflictor, vector inflictororigin, vector inflictorvelocity, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float inflictorselfdamage, float forceintensity, int deathtype, entity directhitentity)
// Returns total damage applies to creatures
{
entity targ;
return total_damage_to_creatures;
}
-float RadiusDamage (entity inflictor, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float forceintensity, float deathtype, entity directhitentity)
+float RadiusDamage (entity inflictor, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float forceintensity, int deathtype, entity directhitentity)
{
return RadiusDamageForSource (inflictor, (inflictor.origin + (inflictor.mins + inflictor.maxs) * 0.5), inflictor.velocity, attacker, coredamage, edgedamage, rad, cantbe, mustbe, false, forceintensity, deathtype, directhitentity);
}
.float dmg_force;
.float dmg_radius;
-float Damage_DamageInfo_SendEntity(entity to, float sf);
+float Damage_DamageInfo_SendEntity(entity to, int sf);
-void Damage_DamageInfo(vector org, float coredamage, float edgedamage, float rad, vector force, float deathtype, float bloodtype, entity dmgowner);
+void Damage_DamageInfo(vector org, float coredamage, float edgedamage, float rad, vector force, int deathtype, float bloodtype, entity dmgowner);
float checkrules_firstblood;
// NOTE: f=0 means still count as a (positive) kill, but count no frags for it
void W_SwitchWeapon_Force(entity e, float w);
entity GiveFrags_randomweapons;
-void GiveFrags (entity attacker, entity targ, float f, float deathtype);
+void GiveFrags (entity attacker, entity targ, float f, int deathtype);
string AppendItemcodes(string s, entity player);
-void LogDeath(string mode, float deathtype, entity killer, entity killed);
+void LogDeath(string mode, int deathtype, entity killer, entity killed);
void Obituary_SpecialDeath(
entity notif_target,
float murder,
- float deathtype,
+ int deathtype,
string s1, string s2, string s3,
float f1, float f2, float f3);
float Obituary_WeaponDeath(
entity notif_target,
float murder,
- float deathtype,
+ int deathtype,
string s1, string s2, string s3,
float f1, float f2);
-void Obituary(entity attacker, entity inflictor, entity targ, float deathtype);
+void Obituary(entity attacker, entity inflictor, entity targ, int deathtype);
void Ice_Think();
entity damage_inflictor;
entity damage_attacker;
-void Damage (entity targ, entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
+void Damage (entity targ, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force);
float RadiusDamage_running;
-float RadiusDamageForSource (entity inflictor, vector inflictororigin, vector inflictorvelocity, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float inflictorselfdamage, float forceintensity, float deathtype, entity directhitentity);
+float RadiusDamageForSource (entity inflictor, vector inflictororigin, vector inflictorvelocity, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float inflictorselfdamage, float forceintensity, int deathtype, entity directhitentity);
// Returns total damage applies to creatures
-float RadiusDamage (entity inflictor, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float forceintensity, float deathtype, entity directhitentity);
+float RadiusDamage (entity inflictor, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float forceintensity, int deathtype, entity directhitentity);
.float fire_damagepersec;
.float fire_endtime;
}
.vector hook_start, hook_end;
-float GrapplingHookSend(entity to, float sf)
+float GrapplingHookSend(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_HOOK);
sf = sf & 0x7F;
//self.realowner.disableclientprediction = true;
}
-void GrapplingHook_Damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void GrapplingHook_Damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.health <= 0)
return;
self.SendFlags |= 2;
}
-float g_clientmodel_genericsendentity (entity to, float sf)
+float g_clientmodel_genericsendentity (entity to, int sf)
{
sf = sf & 0x0F;
if(self.angles != '0 0 0')
multi_trigger ();
}
-void multi_eventdamage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void multi_eventdamage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if (!self.takedamage)
return;
spawnfunc_func_pointparticles();
}
-float rainsnow_SendEntity(entity to, float sf)
+float rainsnow_SendEntity(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_RAINSNOW);
WriteByte(MSG_ENTITY, self.state);
void multi_touch();
-void multi_eventdamage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
+void multi_eventdamage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force);
void multi_reset();
void spawnfunc_func_sparks();
-float rainsnow_SendEntity(entity to, float sf);
+float rainsnow_SendEntity(entity to, int sf);
/*QUAKED spawnfunc_func_rain (0 .5 .8) ?
This is an invisible area like a trigger, which rain falls inside of.
#include "g_violence.qh"
-float Violence_GibSplash_SendEntity(entity to, float sf)
+float Violence_GibSplash_SendEntity(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_GIBSPLASH);
WriteByte(MSG_ENTITY, self.state); // actually type
#ifndef G_VIOLENCE_H
#define G_VIOLENCE_H
-float Violence_GibSplash_SendEntity(entity to, float sf);
+float Violence_GibSplash_SendEntity(entity to, int sf);
// TODO maybe convert this to a TE?
void Violence_GibSplash_At(vector org, vector dir, float type, float amount, entity gibowner, entity attacker);
}
entity randomseed;
-float RandomSeed_Send(entity to, float sf)
+float RandomSeed_Send(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_RANDOMSEED);
WriteShort(MSG_ENTITY, self.cnt);
// character set: ASCII 33-126 without the following characters: : ; ' " \ $
if(autocvar_sv_eventlog)
{
- s = sprintf("%d.%s.%06d", ftos(autocvar_sv_eventlog_files_counter), strftime(false, "%s"), floor(random() * 1000000));
+ s = sprintf("%d.%s.%06d", itos(autocvar_sv_eventlog_files_counter), strftime(false, "%s"), floor(random() * 1000000));
matchid = strzone(s);
GameLogEcho(strcat(":gamestart:", GetGametype(), "_", GetMapname(), ":", s));
if(have_team_spawns <= 0)
return WINNING_NO;
- if(autocvar_g_spawn_useallspawns <= 0)
+ if(!autocvar_g_spawn_useallspawns)
return WINNING_NO;
if(!some_spawn_has_been_used)
}
}
-float MapVote_SendEntity(entity to, float sf)
+float MapVote_SendEntity(entity to, int sf)
{
float i;
void GameLogEcho(string s)
{
string fn;
- float matches;
+ int matches;
if (autocvar_sv_eventlog_files)
{
{
logfile_open = true;
matches = autocvar_sv_eventlog_files_counter + 1;
- cvar_set("sv_eventlog_files_counter", ftos(matches));
+ cvar_set("sv_eventlog_files_counter", itos(matches));
fn = ftos(matches);
if (strlen(fn) < 8)
fn = strcat(substring("00000000", 0, 8 - strlen(fn)), fn);
entno = num_for_edict(e);
idx = precache_sound_index(samp);
- float sflags;
+ int sflags;
sflags = 0;
_atten = floor(_atten * 64);
}
-void Net_LinkEntity(entity e, float docull, float dt, float(entity, float) sendfunc)
+void Net_LinkEntity(entity e, float docull, float dt, bool(entity, int) sendfunc)
{
vector mi, ma;
.float scale2;
-float modeleffect_SendEntity(entity to, float sf)
+float modeleffect_SendEntity(entity to, int sf)
{
float f;
WriteByte(MSG_ENTITY, ENT_CLIENT_MODELEFFECT);
}
}
-void kh_Key_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void kh_Key_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.owner)
return;
entity ons_red_generator;
entity ons_blue_generator;
-void ons_gib_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce)
+void ons_gib_damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce)
{
self.velocity = self.velocity + vforce;
}
self.count = self.count - 1;
}
-void onslaught_generator_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void onslaught_generator_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
float i;
if (damage <= 0)
float ons_notification_time_team1;
float ons_notification_time_team2;
-void onslaught_controlpoint_icon_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void onslaught_controlpoint_icon_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
entity oself;
float nag;
self.velocity
+ (autocvar_sv_dodging_up_speed * v_up);
- if (autocvar_sv_dodging_sound == 1)
+ if (autocvar_sv_dodging_sound)
PlayerSound(playersound_jump, CH_PLAYER, VOICETYPE_PLAYERSOUND);
animdecide_setaction(self, ANIMACTION_JUMP, true);
// returns 1 if the player is close to a wall
-float check_close_to_wall(float threshold) {
- if (autocvar_sv_dodging_wall_dodging == 0)
- return 0;
+bool check_close_to_wall(float threshold)
+{
+ if(!autocvar_sv_dodging_wall_dodging)
+ return false;
vector trace_start;
vector trace_end;
trace_end = self.origin + (1000*v_right);
tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
- return 1;
+ return true;
trace_end = self.origin - (1000*v_right);
tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
- return 1;
+ return true;
trace_end = self.origin + (1000*v_forward);
tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
- return 1;
+ return true;
trace_end = self.origin - (1000*v_forward);
tracebox(trace_start, self.mins, self.maxs, trace_end, true, self);
if (trace_fraction < 1 && vlen (self.origin - trace_endpos) < threshold)
- return 1;
+ return true;
- return 0;
+ return false;
}
-float check_close_to_ground(float threshold) {
+bool check_close_to_ground(float threshold)
+{
if (self.flags & FL_ONGROUND)
- return 1;
+ return true;
- return 0;
+ return false;
}
void nade_boom()
{
string expef;
- float nade_blast = 1;
+ bool nade_blast = true;
switch ( self.nade_type )
{
expef = "explosion_medium";
break;
case NADE_TYPE_ICE:
- nade_blast = 0;
+ nade_blast = false;
expef = "electro_combo"; // hookbomb_explode electro_combo bigplasma_impact
break;
case NADE_TYPE_TRANSLOCATE:
- nade_blast = 0;
+ nade_blast = false;
expef = "";
break;
case NADE_TYPE_MONSTER:
case NADE_TYPE_SPAWN:
- nade_blast = 0;
+ nade_blast = false;
switch(self.realowner.team)
{
case NUM_TEAM_1: expef = "spawn_event_red"; break;
}
break;
case NADE_TYPE_HEAL:
- nade_blast = 0;
+ nade_blast = false;
expef = "spawn_event_red";
break;
self.nextthink = max(self.wait, time);
}
-void nade_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void nade_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(ITEM_DAMAGE_NEEDKILL(deathtype))
{
}
}
-void physical_item_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void physical_item_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(!self.cnt) // not for dropped items
if(ITEM_DAMAGE_NEEDKILL(deathtype))
}
}
-void Portal_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void Portal_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(deathtype == DEATH_TELEFRAG)
return;
}
}
-float ScoreInfo_SendEntity(entity to, float sf)
+float ScoreInfo_SendEntity(entity to, int sf)
{
float i;
WriteByte(MSG_ENTITY, ENT_CLIENT_SCORES_INFO);
#include "race.qh"
#endif
-float SpawnPoint_Send(entity to, float sf)
+float SpawnPoint_Send(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_SPAWNPOINT);
return true;
}
-float SpawnEvent_Send(entity to, float sf)
+float SpawnEvent_Send(entity to, int sf)
{
float send;
.vector spawnpoint_score;
float spawnpoint_nag;
-float SpawnEvent_Send(entity to, float sf);
+float SpawnEvent_Send(entity to, int sf);
entity Spawn_FilterOutBadSpots(entity firstspot, float mindist, float teamcheck);
entity SelectSpawnPoint (float anypoint);
#endif
#endif
#ifdef SVQC
-float ItemSend(entity to, float sf)
+bool ItemSend(entity to, int sf)
{
if(self.gravity)
sf |= ISF_DROP;
return item.bot_pickupbasevalue * c;
}
-void Item_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void Item_Damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(ITEM_DAMAGE_NEEDKILL(deathtype))
RemoveItem();
#endif
#ifdef SVQC
float autocvar_sv_simple_items;
-float ItemSend(entity to, float sf);
+bool ItemSend(entity to, int sf);
float have_pickup_item(void);
// Savage: used for item garbage-collection
// TODO: perhaps nice special effect?
-float ItemSend(entity to, float sf);
+bool ItemSend(entity to, int sf);
void ItemUpdate(entity item);
// pickup evaluation functions
button_fire ();
}
-void button_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void button_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(self.spawnflags & DOOR_NOSPLASH)
if(!(DEATH_ISSPECIAL(deathtype)) && (deathtype & HITTYPE_SPLASH))
}
-void door_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void door_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
entity oself;
if(self.spawnflags & DOOR_NOSPLASH)
sound(self, CH_TRIGGER_SINGLE, self.noise2, VOL_BASE, ATTEN_NORM);
}
-void fd_secret_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void fd_secret_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
fd_secret_use();
}
// spawnflags:
// 1 = START_OFF
// when triggered, it is disabled/enabled for everyone
-float trigger_music_SendEntity(entity to, float sf)
+float trigger_music_SendEntity(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_TRIGGER_MUSIC);
sf &= ~0x80;
void turret_stdproc_track();
/// Generic damage handeling. blows up the turret when health <= 0
-void turret_stdproc_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce);
+void turret_stdproc_damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce);
/// Spawns a explotion, does some damage & trows bits arround.
void turret_stdproc_die();
/// reassembles the turret.
/*
* Standard damage proc.
*/
-void turret_stdproc_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce)
+void turret_stdproc_damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce)
{
// Enougth allready!
if(self.deadflag == DEAD_DEAD)
}
-float turret_send(entity to, float sf)
+float turret_send(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_TURRET);
turret_projectile_explode();
}
-void turret_projectile_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce)
+void turret_projectile_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce)
{
self.velocity += vforce;
self.health -= damage;
void turret_fire()
{
- if (autocvar_g_turrets_nofire != 0)
+ if (autocvar_g_turrets_nofire)
return;
self.turret_firefunc();
self.nextthink = time + 1;
entity e;
- if (autocvar_g_turrets_reloadcvars == 1)
+ if (autocvar_g_turrets_reloadcvars)
{
e = nextent(world);
while (e)
if (!(self.spawnflags & TSF_SUSPENDED))
builtin_droptofloor(); // why can't we use regular droptofloor here?
- // Terrainbase spawnflag. This puts a enlongated model
- // under the turret, so it looks ok on uneaven surfaces.
- /* TODO: Handle this with CSQC
- if (self.spawnflags & TSF_TERRAINBASE)
- {
- entity tb;
- tb = spawn();
- setmodel(tb,"models/turrets/terrainbase.md3");
- setorigin(tb,self.origin);
- tb.solid = SOLID_BBOX;
- }
- */
-
self.cvar_basename = cvar_base_name;
load_unit_settings(self, self.cvar_basename, 0);
* Railgun-like beam, but has thickness and suppots slowing of target
*/
void FireImoBeam (vector start, vector end, vector smin, vector smax,
- float bforce, float f_dmg, float f_velfactor, float deathtype)
+ float bforce, float f_dmg, float f_velfactor, int deathtype)
{
vector hitloc, force, endpoint, dir;
remove (self);
}
-void walker_rocket_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce)
+void walker_rocket_damage (entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce)
{
self.health = self.health - damage;
self.velocity = self.velocity + vforce;
}
}
-float bumble_raygun_send(entity to, float sf)
+float bumble_raygun_send(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_BUMBLE_RAYGUN);
float autocvar_g_vehicle_bumblebee = 0;
-float bumble_raygun_send(entity to, float sf);
+float bumble_raygun_send(entity to, int sf);
const vector BUMB_MIN = '-130 -130 -130';
const vector BUMB_MAX = '130 130 130';
void spawnfunc_vehicle_bumblebee();
-float bumble_raygun_send(entity to, float sf);
+float bumble_raygun_send(entity to, int sf);
#endif // SVQC
#ifdef CSQC
void racer_fire_rocket(string tagname, entity trg)
{
vector v = gettaginfo(self, gettagindex(self, tagname));
- entity rocket = rocket = vehicles_projectile("wakizashi_rocket_launch", "weapons/rocket_fire.wav",
+ entity rocket = vehicles_projectile("wakizashi_rocket_launch", "weapons/rocket_fire.wav",
v, v_forward * autocvar_g_vehicle_racer_rocket_speed,
autocvar_g_vehicle_racer_rocket_damage, autocvar_g_vehicle_racer_rocket_radius, autocvar_g_vehicle_racer_rocket_force, 3,
DEATH_VH_WAKI_ROCKET, PROJECTILE_WAKIROCKET, 20, false, false, self.owner);
return;
}
}
-#endif // SVQC
+#endif // SVQC
\ No newline at end of file
remove(self);
}
-void raptor_flare_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void raptor_flare_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
self.health -= damage;
if(self.health <= 0)
float autocvar_g_vehicles;
-void vehicles_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
+void vehicles_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force);
void vehicles_return();
void vehicles_enter();
void vehicles_touch();
const float MAX_AXH = 4;
.entity AuxiliaryXhair[MAX_AXH];
-float SendAuxiliaryXhair(entity to, float sf)
+float SendAuxiliaryXhair(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_AUXILIARYXHAIR);
#if 0
void targetdrone_think();
-void targetdrone_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
+void targetdrone_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force);
void targetdrone_renwe()
{
self.think = targetdrone_think;
setsize(self, '-100 -100 -100', '100 100 100');
}
-void targetdrone_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void targetdrone_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
self.health -= damage;
if(self.health <= 0)
if(trace_ent.deadflag != DEAD_NO)
trace_ent = world;
-
- if(!trace_ent.vehicle_flags & VHF_ISVEHICLE ||
- trace_ent.turrcaps_flags & TFL_TURRCAPS_ISTURRET ||
- trace_ent.takedamage == DAMAGE_TARGETDRONE)
- trace_ent = world;
+ if(!(
+ (trace_ent.vehicle_flags & VHF_ISVEHICLE) ||
+ (trace_ent.turrcaps_flags & TFL_TURRCAPS_ISTURRET) ||
+ (trace_ent.takedamage == DAMAGE_TARGETDRONE)
+ )) { trace_ent = world; }
}
if(self.lock_target == world && trace_ent != world)
}
// Generic vehile projectile system
-void vehicles_projectile_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void vehicles_projectile_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
// Ignore damage from oterh projectiles from my owner (dont mess up volly's)
if(inflictor.owner == self.owner)
}
}
-void vehicles_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void vehicles_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
self.dmg_time = time;
player.prevstrengthsoundattempt = time;
}
-float W_CheckProjectileDamage(entity inflictor, entity projowner, float deathtype, float exception)
+float W_CheckProjectileDamage(entity inflictor, entity projowner, int deathtype, float exception)
{
float is_from_contents = (deathtype == DEATH_SLIME || deathtype == DEATH_LAVA);
float is_from_owner = (inflictor == projowner);
.float prevstrengthsound;
.float prevstrengthsoundattempt;
void W_PlayStrengthSound(entity player);
-float W_CheckProjectileDamage(entity inflictor, entity projowner, float deathtype, float exception);
+float W_CheckProjectileDamage(entity inflictor, entity projowner, int deathtype, float exception);
void W_PrepareExplosionByDamage(entity attacker, void() explode);
#endif
.float csqcprojectile_type;
-float CSQCProjectile_SendEntity(entity to, int sf)
+bool CSQCProjectile_SendEntity(entity to, int sf)
{
float ft, fr;
if(sf & 2)
WriteByte(MSG_ENTITY, self.csqcprojectile_type); // TODO maybe put this into sf?
- return 1;
+ return true;
}
.vector csqcprojectile_oldorigin;
// Ballistics Tracing
// ====================
-void FireRailgunBullet (vector start, vector end, float bdamage, float bforce, float mindist, float maxdist, float halflifedist, float forcehalflifedist, float deathtype)
+void FireRailgunBullet (vector start, vector end, float bdamage, float bforce, float mindist, float maxdist, float halflifedist, float forcehalflifedist, int deathtype)
{
vector hitloc, force, endpoint, dir;
entity ent, endent;
.float railgundistance;
.vector railgunforce;
-void FireRailgunBullet (vector start, vector end, float bdamage, float bforce, float mindist, float maxdist, float halflifedist, float forcehalflifedist, float deathtype);
+void FireRailgunBullet (vector start, vector end, float bdamage, float bforce, float mindist, float maxdist, float halflifedist, float forcehalflifedist, int deathtype);
float fireBullet_trace_callback_eff;
entity fireBullet_last_hit;
WarpZone_PostTeleportPlayer_Callback(player);
}
-float WarpZone_Teleported_Send(entity to, float sf)
+bool WarpZone_Teleported_Send(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE_TELEPORTED);
WriteCoord(MSG_ENTITY, self.angles.x);
}
}
-float WarpZone_Send(entity to, float sendflags)
+bool WarpZone_Send(entity to, int sendflags)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE);
return true;
}
-float WarpZone_Camera_Send(entity to, float sendflags)
+bool WarpZone_Camera_Send(entity to, int sendflags)
{
int f = 0;
WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE_CAMERA);
Severin "sev" Meyer
*Music / Sound FX
+AquaNova (Archer)
blkrbt
chooksta
Independent.nu
{SC0RP} - Ian "ID" Dorrell
Stephan
unfa
-AquaNova (Archer)
*Game Code
Samual "Ares" Lenks
**Other Active Contributors
+BuddyFriendGuy
Erik "Ablu" Schilling
Jope "Sless" Withers
Mircea "Taoki" Kitsune
*Asturian
Llumex03
+Tornes "Tornes.Llume" Ḷḷume
Ximielga
*Belarusian
lokster
set_killer
+*Chinese (China)
+Antonidas
+kalawore
+sapphireliu
+
*Czech
shogun assassin/woky
+Superovoce
Tomáš "CZHeron" Volavka
*Dutch
vegiburger
*English (Australia)
+Laurene "sunflowers" Albrand
Zac "Mario" Jardine
*Finnish
Yepoleb
*Greek
-Γιάννης "Evropi" Α.
+Γιάννης "Evropi" Ανθυμίδης
Konstantinos "LDinos" Mihalenas
Savoritias
Vindex
Ruszkai "CuBe0wL" Ákos
xaN1C4n3
-*Japanese
-Lento
-
*Italian
Antonio "terencehill" Piu
Felice "MaidenBeast" Sallustio
Amadeusz "amade/proraide" Sławiński
*Portuguese
-Ricardo "Hellgardia" Silva
+Ricardo Manuel "Hellgardia" da Cruz Coelho da Silva
xXxCHAOTICxXx
*Romanian
+Adrian-Ciprian "adrian.tinjala" Tînjală
BusterDBK
Mircea "Taoki" Kitsune
Tudor "TropiKo" Ionel
*Serbian
Саша "salepetronije" Петровић
Pendulla
-Ristovski
+Rafael "Ristovski"
*Spanish
0000simon
projects / xonotic / xonotic-data.pk3dir.git / commitdiff