previous_game_starttime = startTime;
}
-#define ANNOUNCER_CHECKMINUTE(minute) MACRO_BEGIN { \
+#define ANNOUNCER_CHECKMINUTE(minute) MACRO_BEGIN \
if(announcer_##minute##min) { \
if(timeleft > minute * 60) \
announcer_##minute##min = false; \
Local_Notification(MSG_ANNCE, ANNCE_REMAINING_MIN_##minute); \
} \
} \
-} MACRO_END
+MACRO_END
void Announcer_Time()
{
// player "pops in"
if(isnew)
{
-#define FIX_FRAMETIME(f,ft) MACRO_BEGIN { \
+#define FIX_FRAMETIME(f,ft) MACRO_BEGIN \
if(IS_DEAD_FRAME(this.f) && this.ft != 0 && this.death_time != 0) \
this.ft = this.death_time; \
-} MACRO_END
+MACRO_END
FIX_FRAMETIME(frame, frame1time);
FIX_FRAMETIME(frame2, frame2time);
#ifdef CSQCMODEL_HAVE_TWO_FRAMES
#define HUD_PANEL(NAME) HUD_PANEL_##NAME
// draw the background/borders
-#define HUD_Panel_DrawBg() MACRO_BEGIN { \
+#define HUD_Panel_DrawBg() MACRO_BEGIN \
if(panel.current_panel_bg != "0" && panel.current_panel_bg != "") \
draw_BorderPicture( \
HUD_Shift(panel_pos - '1 1 0' * panel_bg_border), \
panel_bg_color, panel_bg_alpha, \
HUD_Scale('1 1 0' * BORDER_MULTIPLIER * panel_bg_border) \
); \
-} MACRO_END
+MACRO_END
int panel_order[hud_panels_MAX];
string hud_panelorder_prev;
// Get value for panel.current_panel_bg: if "" fetch default, else use panel_bg_str
// comment on last line of macro: // we probably want to see a background in config mode at all times...
-#define HUD_Panel_GetBg() MACRO_BEGIN { \
+#define HUD_Panel_GetBg() MACRO_BEGIN \
string panel_bg; \
if (!autocvar__hud_configure && panel_bg_str == "0") { \
panel_bg = "0"; \
if (panel.current_panel_bg) \
strunzone(panel.current_panel_bg); \
panel.current_panel_bg = strzone(panel_bg); \
-} MACRO_END
+MACRO_END
// Get value for panel_bg_color: if "" fetch default, else use panel_bg_color. Convert pants, shirt or teamcolor into a vector.
-#define HUD_Panel_GetColor() MACRO_BEGIN { \
+#define HUD_Panel_GetColor() MACRO_BEGIN \
if ((teamplay) && panel_bg_color_team > 0) { \
if (autocvar__hud_configure && myteam == NUM_SPECTATOR) \
panel_bg_color = '1 0 0' * panel_bg_color_team; \
} \
} \
} \
-} MACRO_END
+MACRO_END
// Get value for panel_bg_color_team: if "" fetch default, else use panel_bg_color_team_str
-#define HUD_Panel_GetColorTeam() MACRO_BEGIN { \
+#define HUD_Panel_GetColorTeam() MACRO_BEGIN \
if (panel_bg_color_team_str == "") { \
panel_bg_color_team = autocvar_hud_panel_bg_color_team; \
} else { \
panel_bg_color_team = stof(panel_bg_color_team_str); \
} \
-} MACRO_END
+MACRO_END
// Get value for panel_bg_alpha: if "" fetch default, else use panel_bg_alpha. Also do various menu dialog fadeout/in checks, and minalpha checks
// comment on line 3 of macro: // do not set a minalpha cap when showing the config dialog for this panel
-#define HUD_Panel_GetBgAlpha() MACRO_BEGIN { \
+#define HUD_Panel_GetBgAlpha() MACRO_BEGIN \
if (panel_bg_alpha_str == "") { \
panel_bg_alpha_str = ftos(autocvar_hud_panel_bg_alpha); \
} \
else \
panel_bg_alpha = max(cvar("hud_configure_bg_minalpha"), panel_bg_alpha); \
} \
-} MACRO_END
+MACRO_END
// Get value for panel_fg_alpha. Also do various minalpha checks
// comment on line 2 of macro: // ALWAYS show disabled panels at 0.25 alpha when in config mode
-#define HUD_Panel_GetFgAlpha() MACRO_BEGIN { \
+#define HUD_Panel_GetFgAlpha() MACRO_BEGIN \
panel_fg_alpha = autocvar_hud_panel_fg_alpha; \
if (autocvar__hud_configure && !panel_enabled) \
panel_fg_alpha = 0.25; \
-} MACRO_END
+MACRO_END
// Get border. See comments above, it's similar.
-#define HUD_Panel_GetBorder() MACRO_BEGIN { \
+#define HUD_Panel_GetBorder() MACRO_BEGIN \
if (panel_bg_border_str == "") { \
panel_bg_border = autocvar_hud_panel_bg_border; \
} else { \
panel_bg_border = stof(panel_bg_border_str); \
} \
-} MACRO_END
+MACRO_END
// Get padding. See comments above, it's similar.
// last line is a port of the old function, basically always make sure the panel contents are at least 5 pixels tall/wide, to disallow extreme padding values
-#define HUD_Panel_GetPadding() MACRO_BEGIN { \
+#define HUD_Panel_GetPadding() MACRO_BEGIN \
if (panel_bg_padding_str == "") { \
panel_bg_padding = autocvar_hud_panel_bg_padding; \
} else { \
panel_bg_padding = stof(panel_bg_padding_str); \
} \
panel_bg_padding = min(min(panel_size.x, panel_size.y)/2 - 5, panel_bg_padding); \
-} MACRO_END
+MACRO_END
// return smoothly faded pos and size of given panel when a dialog is active
// don't center too wide panels, it doesn't work with different resolutions
-#define HUD_Panel_UpdatePosSize_ForMenu() MACRO_BEGIN { \
+#define HUD_Panel_UpdatePosSize_ForMenu() MACRO_BEGIN \
vector new_size = panel_size; \
float max_panel_width = 0.52 * vid_conwidth; \
if(panel_size.x > max_panel_width) \
vector new_pos = vec2(panel_bg_border + 0.5 * max_panel_width, 0.5 * vid_conheight) - 0.5 * new_size; \
panel_pos = (1 - autocvar__menu_alpha) * panel_pos + (autocvar__menu_alpha) * new_pos; \
panel_size = (1 - autocvar__menu_alpha) * panel_size + (autocvar__menu_alpha) * new_size; \
-} MACRO_END
+MACRO_END
// Scale the pos and size vectors to absolute coordinates
-#define HUD_Panel_ScalePosSize() MACRO_BEGIN { \
+#define HUD_Panel_ScalePosSize() MACRO_BEGIN \
panel_pos.x *= vid_conwidth; panel_pos.y *= vid_conheight; \
panel_size.x *= vid_conwidth; panel_size.y *= vid_conheight; \
-} MACRO_END
+MACRO_END
float panel_fade_alpha;
void HUD_Panel_LoadCvars();
panel_enabled = ((panel.panel_configflags & PANEL_CONFIG_CANBEOFF) \
? cvar(strcat("hud_panel_", panel.panel_name)) : true)
-#define HUD_Panel_UpdatePosSize() MACRO_BEGIN { \
+#define HUD_Panel_UpdatePosSize() MACRO_BEGIN \
Hud_Panel_GetPanelEnabled(); \
panel_pos = stov(cvar_string(strcat("hud_panel_", panel.panel_name, "_pos"))); \
panel_size = stov(cvar_string(strcat("hud_panel_", panel.panel_name, "_size"))); \
} \
panel_bg_border_str = cvar_string(strcat("hud_panel_", panel.panel_name, "_bg_border")); \
HUD_Panel_GetBorder(); \
-} MACRO_END
+MACRO_END
const int NOTIFY_MAX_ENTRIES = 10;
const float NOTIFY_ICON_MARGIN = 0.02;
return pos;
}
-#define InfoMessage(s) MACRO_BEGIN { \
+#define InfoMessage(s) MACRO_BEGIN \
pos = InfoMessages_drawstring(s, pos, mySize, ((img_curr_group >= 0) ? panel_fg_alpha * img_fade[img_curr_group] : panel_fg_alpha), fontsize); \
img_curr_group = -1; \
-} MACRO_END
+MACRO_END
void HUD_InfoMessages()
{
}
// when status CHANGES, set old status into prevstatus and current status into status
- #define X(team) MACRO_BEGIN { \
+ #define X(team) MACRO_BEGIN \
if (team##flag != team##flag_prevframe) { \
team##flag_statuschange_time = time; \
team##flag_prevstatus = team##flag_prevframe; \
team##flag_prevframe = team##flag; \
} \
team##flag_statuschange_elapsedtime = time - team##flag_statuschange_time; \
- } MACRO_END
+ MACRO_END
X(red);
X(blue);
X(yellow);
string team##_icon = string_null, team##_icon_prevstatus = string_null; \
int team##_alpha, team##_alpha_prevstatus; \
team##_alpha = team##_alpha_prevstatus = 1; \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
switch (team##flag) { \
case 1: team##_icon = "flag_" #team "_taken"; break; \
case 2: team##_icon = "flag_" #team "_lost"; break; \
} \
break; \
} \
- } MACRO_END
+ MACRO_END
X(red, myteam != NUM_TEAM_1 && (nteams & BIT(0)));
X(blue, myteam != NUM_TEAM_2 && (nteams & BIT(1)));
X(yellow, myteam != NUM_TEAM_3 && (nteams & BIT(2)));
neutralflag_pos = pos;
flag_size = e1 * fs * size1 + e2 * size2;
- #define X(team) MACRO_BEGIN { \
+ #define X(team) MACRO_BEGIN \
f = bound(0, team##flag_statuschange_elapsedtime * 2, 1); \
if (team##_icon && ctf_stalemate) \
drawpic_aspect_skin(team##flag_pos, "flag_stalemate", flag_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL); \
drawpic_aspect_skin_expanding(team##flag_pos, team##_icon_prevstatus, flag_size, '1 1 1', panel_fg_alpha * team##_alpha_prevstatus, DRAWFLAG_NORMAL, f); \
if (team##_icon) \
drawpic_aspect_skin(team##flag_pos, team##_icon, flag_size, '1 1 1', panel_fg_alpha * team##_alpha * f, DRAWFLAG_NORMAL); \
- } MACRO_END
+ MACRO_END
X(red);
X(blue);
X(yellow);
if(time > physics_update_time)
{
// workaround for ftos_decimals returning a negative 0
- if(discrete_acceleration > -1 / (10 ** acc_decimals) && discrete_acceleration < 0)
+ if(discrete_acceleration > -1 / POW(10, acc_decimals) && discrete_acceleration < 0)
discrete_acceleration = 0;
discrete_acceleration = acceleration;
discrete_speed = speed;
// distribution display
distribution = me.(scores(ps_primary)) - pl.(scores(ps_primary));
- distrtimer = ftos_decimals(fabs(distribution/(10 ** TIME_DECIMALS)), TIME_DECIMALS);
+ distrtimer = ftos_decimals(fabs(distribution/POW(10, TIME_DECIMALS)), TIME_DECIMALS);
if (distribution <= 0) {
distribution_color = '0 1 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)
}
-#define HUD_WEAPONS_GET_FULL_LAYOUT() MACRO_BEGIN { \
+#define HUD_WEAPONS_GET_FULL_LAYOUT() MACRO_BEGIN \
int nHidden = 0; \
FOREACH(Weapons, it != WEP_Null, { \
if (weapons_stat & WepSet_FromWeapon(it)) continue; \
rows = table_size.y; \
weapon_size.x = panel_size.x / columns; \
weapon_size.y = panel_size.y / rows; \
-} MACRO_END
+MACRO_END
void HUD_Weapons()
{
float _drawpic_oldsz;
string _drawpic_picpath;
#define drawpic_aspect(pos,pic,mySize,color,theAlpha,drawflag)\
- MACRO_BEGIN {\
+ MACRO_BEGIN\
_drawpic_imgsize = draw_getimagesize(pic);\
if(_drawpic_imgsize != '0 0 0') {\
_drawpic_imgaspect = _drawpic_imgsize.x/_drawpic_imgsize.y;\
drawpic(pos + eY * 0.5 * (_drawpic_oldsz - _drawpic_sz.y), pic, _drawpic_sz, color, theAlpha, drawflag);\
}\
}\
- } MACRO_END
+ MACRO_END
// draw HUD element with image from gfx/hud/hud_skin/foo.tga if it exists, otherwise gfx/hud/default/foo.tga
#define drawpic_aspect_skin(pos,pic,sz,color,theAlpha,drawflag)\
- MACRO_BEGIN {\
+ MACRO_BEGIN\
_drawpic_picpath = strcat(hud_skin_path, "/", pic);\
if(precache_pic(_drawpic_picpath) == "") {\
_drawpic_picpath = strcat("gfx/hud/default/", pic);\
}\
drawpic_aspect(pos, _drawpic_picpath, sz, color, theAlpha, drawflag);\
_drawpic_picpath = string_null;\
- } MACRO_END
+ MACRO_END
// draw HUD element with image from gfx/hud/hud_skin/foo.tga if it exists, otherwise gfx/hud/default/foo.tga
#define drawpic_skin(pos,pic,sz,color,theAlpha,drawflag)\
- MACRO_BEGIN {\
+ MACRO_BEGIN\
_drawpic_picpath = strcat(hud_skin_path, "/", pic);\
if(precache_pic(_drawpic_picpath) == "") {\
_drawpic_picpath = strcat("gfx/hud/default/", pic);\
}\
drawpic(pos, _drawpic_picpath, sz, color, theAlpha, drawflag);\
_drawpic_picpath = string_null;\
- } MACRO_END
+ MACRO_END
void drawpic_aspect_skin_expanding(vector position, string pic, vector theScale, vector rgb, float theAlpha, float flag, float fadelerp);
void drawpic_aspect_skin_expanding_two(vector position, string pic, vector theScale, vector rgb, float theAlpha, float flag, float fadelerp);
-#define SET_POS_AND_SZ_Y_ASPECT(allow_colors) MACRO_BEGIN { \
+#define SET_POS_AND_SZ_Y_ASPECT(allow_colors) MACRO_BEGIN \
float textaspect, oldsz; \
vector dfs = drawfontscale; \
drawfontscale = '1 1 0'; \
sz.y = sz.x / textaspect; \
pos.y += (oldsz - sz.y) * 0.5; \
} \
-} MACRO_END
+MACRO_END
// drawstring wrapper to draw a string as large as possible with preserved aspect ratio into a box
void drawstring_aspect(vector pos, string text, vector sz, vector color, float theAlpha, float drawflag);
ret = ref_store = ref_store * (1 - frac) + (value) * frac;
#define lowpass_limited(value, frac, limit, ref_store, ret) MACRO_BEGIN \
-{ \
float __ignore; lowpass(value, frac, ref_store, __ignore); \
ret = ref_store = bound((value) - (limit), ref_store, (value) + (limit)); \
-} MACRO_END
+MACRO_END
#define highpass(value, frac, ref_store, ret) MACRO_BEGIN \
-{ \
float __f = 0; lowpass(value, frac, ref_store, __f); \
ret = (value) - __f; \
-} MACRO_END
+MACRO_END
#define highpass_limited(value, frac, limit, ref_store, ret) MACRO_BEGIN \
-{ \
float __f = 0; lowpass_limited(value, frac, limit, ref_store, __f); \
ret = (value) - __f; \
-} MACRO_END
+MACRO_END
#define lowpass2(value, frac, ref_store, ref_out) MACRO_BEGIN \
-{ \
lowpass(value.x, frac, ref_store.x, ref_out.x); \
lowpass(value.y, frac, ref_store.y, ref_out.y); \
-} MACRO_END
+MACRO_END
#define highpass2(value, frac, ref_store, ref_out) MACRO_BEGIN \
-{ \
highpass(value.x, frac, ref_store.x, ref_out.x); \
highpass(value.y, frac, ref_store.y, ref_out.y); \
-} MACRO_END
+MACRO_END
#define highpass2_limited(value, frac, limit, ref_store, ref_out) MACRO_BEGIN \
-{ \
highpass_limited(value.x, frac, limit, ref_store.x, ref_out.x); \
highpass_limited(value.y, frac, limit, ref_store.y, ref_out.y); \
-} MACRO_END
+MACRO_END
#define lowpass3(value, frac, ref_store, ref_out) MACRO_BEGIN \
-{ \
lowpass(value.x, frac, ref_store.x, ref_out.x); \
lowpass(value.y, frac, ref_store.y, ref_out.y); \
lowpass(value.z, frac, ref_store.z, ref_out.z); \
-} MACRO_END
+MACRO_END
#define highpass3(value, frac, ref_store, ref_out) MACRO_BEGIN \
-{ \
highpass(value.x, frac, ref_store.x, ref_out.x); \
highpass(value.y, frac, ref_store.y, ref_out.y); \
highpass(value.z, frac, ref_store.z, ref_out.z); \
-} MACRO_END
+MACRO_END
void calc_followmodel_ofs(entity view)
{
current_zoomfraction = (current_viewzoom - 1) / (1/zoomfactor - 1);
if(zoomsensitivity < 1)
- setsensitivityscale(current_viewzoom ** (1 - zoomsensitivity));
+ setsensitivityscale(POW(current_viewzoom, (1 - zoomsensitivity)));
else
setsensitivityscale(1);
}
#define CROSSHAIR_DO_BLUR(M,sz,wcross_name,wcross_alpha) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
if(wcross_blur > 0) \
{ \
for(i = -2; i <= 2; ++i) \
{ \
M(0,0,sz,wcross_name,wcross_alpha); \
} \
- } MACRO_END
+ MACRO_END
#define CROSSHAIR_DRAW_SINGLE(i,j,sz,wcross_name,wcross_alpha) \
drawpic(wcross_origin - ('0.5 0 0' * (sz * wcross_size.x + i * wcross_blur) + '0 0.5 0' * (sz * wcross_size.y + j * wcross_blur)), wcross_name, sz * wcross_size, wcross_color, wcross_alpha, DRAWFLAG_NORMAL)
t = (time - blurtest_time0) / (blurtest_time1 - blurtest_time0);
r = t * blurtest_radius;
- f = 1 / (t ** blurtest_power) - 1;
+ f = 1 / POW(t, blurtest_power) - 1;
cvar_set("r_glsl_postprocess", "1");
cvar_set("r_glsl_postprocess_uservec1", strcat(ftos(r), " ", ftos(f), " 0 0"));
rpn_setf(f2 - f * floor(f2 / f));
} else if(rpncmd == "pow" || rpncmd == "**") {
f = rpn_popf();
- rpn_setf(rpn_getf() ** f);
+ rpn_setf(POW(rpn_getf(), f));
} else if(rpncmd == "bitand" || rpncmd == "&") {
f = rpn_popf();
rpn_setf(rpn_getf() & f);
void effectinfo_dump(int fh, bool alsoprint)
{
- #define WRITE(s) MACRO_BEGIN { \
+ #define WRITE(s) MACRO_BEGIN \
fputs(fh, s); \
if (alsoprint) LOG_INFO(s); \
- } MACRO_END
+ MACRO_END
WRITE("// ********************************************** //\n");
WRITE("// ** WARNING - DO NOT MANUALLY EDIT THIS FILE ** //\n");
WRITE("// ** ** //\n");
{
#define X() \
MACRO_BEGIN \
- { \
float atten = (CS(msg_entity).cvar_cl_voice_directional == 1) ? ATTEN_MIN : ATTEN_NONE; \
if (gs) globalsound(MSG_ONE, this, gs, r, chan, vol, atten); \
else if (ps) playersound(MSG_ONE, this, ps, r, chan, vol, atten); \
else soundto(MSG_ONE, this, chan, sample, vol, atten); \
- } MACRO_END
+ MACRO_END
if (fake) { msg_entity = this; X(); }
else
if (voicetype == VOICETYPE_AUTOTAUNT) tauntrand = random();
#define X() \
MACRO_BEGIN \
- { \
if (voicetype != VOICETYPE_AUTOTAUNT || tauntrand < CS(msg_entity).cvar_cl_autotaunt) \
{ \
float atten = (CS(msg_entity).cvar_cl_voice_directional >= 1) \
else if (ps) playersound(MSG_ONE, this, ps, r, chan, vol, atten); \
else soundto(MSG_ONE, this, chan, sample, vol, atten); \
} \
- } MACRO_END
+ MACRO_END
if (fake)
{
msg_entity = this;
#define PlayerSound(this, def, chan, vol, voicetype) _GlobalSound(this, NULL, def, string_null, chan, vol, voicetype, false)
#define VoiceMessage(this, def, msg) \
MACRO_BEGIN \
- { \
entity VM = def; \
int voicetype = VM.m_playersoundvt; \
bool ownteam = (voicetype == VOICETYPE_TEAMRADIO); \
else if (flood > 0) fake = false; \
else break; \
_GlobalSound(this, NULL, VM, string_null, CH_VOICE, VOL_BASEVOICE, voicetype, fake); \
- } MACRO_END
+ MACRO_END
#endif
#include "ent_cs.qh"
+// *INDENT-OFF* uncrustify is too dumb to handle all the macros
+
REGISTRY(EntCSProps, BITS(16) - 1)
#define EntCSProps_from(i) _EntCSProps_from(i, NULL)
REGISTER_REGISTRY(EntCSProps)
* @param spprio player score priority (if frags aren't enabled)
* @param stprio team score priority (if frags aren't enabled)
*/
-#define GameRules_scoring(teams, spprio, stprio, fields) MACRO_BEGIN { \
+#define GameRules_scoring(teams, spprio, stprio, fields) MACRO_BEGIN \
_GameRules_scoring_begin((teams), (spprio), (stprio)); \
noref void(entity, string, float) field = _GameRules_scoring_field; \
/* todo: just have the one `field` function */ \
noref void(int, string, float) field_team = _GameRules_scoring_field_team; \
LAMBDA(fields); \
_GameRules_scoring_end(); \
-} MACRO_END
+MACRO_END
void _GameRules_scoring_begin(int teams, float spprio, float stprio);
void _GameRules_scoring_field(entity i, string label, int scoreflags);
Gametype MapInfo_Type_FromString(string t)
{
-#define deprecate(from, to) MACRO_BEGIN { \
+#define deprecate(from, to) MACRO_BEGIN \
if (t == #from) { \
string replacement = #to; \
if(!autocvar_g_mapinfo_ignore_warnings) \
LOG_WARNF("MapInfo_Type_FromString (probably %s): using deprecated name '%s'. Should use '%s'.", MapInfo_Map_bspname, t, replacement); \
t = replacement; \
} \
-} MACRO_END
+MACRO_END
deprecate(nexball, nb);
deprecate(freezetag, ft);
deprecate(keepaway, ka);
#define MUTATOR_ONREMOVE if (mode == MUTATOR_REMOVING)
#define MUTATOR_ONROLLBACK_OR_REMOVE if (mode == MUTATOR_REMOVING || mode == MUTATOR_ROLLING_BACK)
-#define MUTATOR_STATIC() MACRO_BEGIN { \
+#define MUTATOR_STATIC() MACRO_BEGIN \
MUTATOR_ONADD { \
/* game loads at time 1 */ \
if (time > 1) { \
LOG_INFO("This is a game type and it cannot be removed at runtime."); \
return -1; \
} \
-} MACRO_END
+MACRO_END
#define MUTATOR_ADD(name) Mutator_Add(MUTATOR_##name)
#define MUTATOR_REMOVE(name) Mutator_Remove(MUTATOR_##name)
bool mut##_##cb() { return = false; } \
[[accumulate]] bool mut##_##cb()
-#define MUTATOR_HOOK(cb, func, order) MACRO_BEGIN { \
+#define MUTATOR_HOOK(cb, func, order) MACRO_BEGIN \
MUTATOR_ONADD { \
if (!CallbackChain_Add(HOOK_##cb, CALLBACK_##func, order)) { \
LOG_INFO("HOOK FAILED: ", #cb, ":", #func); \
MUTATOR_ONROLLBACK_OR_REMOVE { \
CallbackChain_Remove(HOOK_##cb, CALLBACK_##func); \
} \
-} MACRO_END
+MACRO_END
#include "events.qh"
float upspeed = this.velocity * v_up;
// responsiveness factor for steering and acceleration
- float f = 1 / (1 + ((max(-myspeed, myspeed) / PHYS_BUGRIGS_SPEED_REF(this)) ** PHYS_BUGRIGS_SPEED_POW(this)));
+ float f = 1 / (1 + POW((max(-myspeed, myspeed) / PHYS_BUGRIGS_SPEED_REF(this)), PHYS_BUGRIGS_SPEED_POW(this)));
//MAXIMA: f(v) := 1 / (1 + (v / PHYS_BUGRIGS_SPEED_REF(this)) ^ PHYS_BUGRIGS_SPEED_POW(this));
float steerfactor;
float myspeed = vlen(this.velocity);
// responsiveness factor for steering and acceleration
- float f = 1 / (1 + (max(0, myspeed / PHYS_BUGRIGS_SPEED_REF(this)) ** PHYS_BUGRIGS_SPEED_POW(this)));
+ float f = 1 / (1 + POW(max(0, myspeed / PHYS_BUGRIGS_SPEED_REF(this)), PHYS_BUGRIGS_SPEED_POW(this)));
float steerfactor = -myspeed * f;
this.angles_y += steer * dt * steerfactor; // apply steering
if(!pushdeltatime) return;
// div0: ticrate independent, 1 = identity (not 20)
- toucher.velocity = toucher.velocity * (autocvar_g_nades_entrap_strength ** pushdeltatime);
+ toucher.velocity = toucher.velocity * POW(autocvar_g_nades_entrap_strength, pushdeltatime);
#ifdef SVQC
UpdateCSQCProjectile(toucher);
void Draw_WaypointSprite(entity this)
{
if (this.lifetime > 0)
- this.alpha = (bound(0, (this.fadetime - time) / this.lifetime, 1) ** waypointsprite_timealphaexponent);
+ this.alpha = POW(bound(0, (this.fadetime - time) / this.lifetime, 1), waypointsprite_timealphaexponent);
else
this.alpha = 1;
float a = this.alpha * autocvar_hud_panel_fg_alpha;
if (this.maxdistance > waypointsprite_normdistance)
- a *= (bound(0, (this.maxdistance - dist) / (this.maxdistance - waypointsprite_normdistance), 1) ** waypointsprite_distancealphaexponent);
+ a *= POW(bound(0, (this.maxdistance - dist) / (this.maxdistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent);
else if (this.maxdistance > 0)
- a *= (bound(0, (waypointsprite_fadedistance - dist) / (waypointsprite_fadedistance - waypointsprite_normdistance), 1) ** waypointsprite_distancealphaexponent) * (1 - waypointsprite_minalpha) + waypointsprite_minalpha;
+ a *= POW(bound(0, (waypointsprite_fadedistance - dist) / (waypointsprite_fadedistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent) * (1 - waypointsprite_minalpha) + waypointsprite_minalpha;
vector rgb = spritelookupcolor(this, spriteimage, this.teamradar_color);
if (rgb == '0 0 0')
(vid_conwidth - (vid_conwidth * waypointsprite_edgeoffset_right)) - o.x,
(vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)) - o.y);
- float crosshairdistance = sqrt( ((o.x - vid_conwidth/2) ** 2) + ((o.y - vid_conheight/2) ** 2) );
+ float crosshairdistance = sqrt(POW((o.x - vid_conwidth/2), 2) + POW((o.y - vid_conheight/2), 2) );
t = waypointsprite_scale;
a *= waypointsprite_alpha;
drawfill(v1, v2, '0.5 0.5 0.5', 0.5, DRAWFLAG_NORMAL);
vector v3 = v1 + '10 10 0';
- #define OUT(s, z) MACRO_BEGIN { drawcolorcodedstring(v3, s, '1 1 0' * z, 1, DRAWFLAG_NORMAL); v3.y += z + 4; } MACRO_END
+ #define OUT(s, z) MACRO_BEGIN drawcolorcodedstring(v3, s, '1 1 0' * z, 1, DRAWFLAG_NORMAL); v3.y += z + 4; MACRO_END
float cur_time = 0;
float time_width = 48;
// ======================
// Process Notif String
// ======================
- #define SET_NOTIF_STRING(string,stringname) MACRO_BEGIN { \
+ #define SET_NOTIF_STRING(string,stringname) MACRO_BEGIN \
notif.nent_string = strzone(CCR( \
Process_Notif_Line( \
typeId, \
stringname \
)) \
); \
- } MACRO_END
+ MACRO_END
if(GENTLE)
{
/** used to output notifications.cfg file */
void Dump_Notifications(int fh, bool alsoprint)
{
- #define NOTIF_WRITE(a) MACRO_BEGIN { \
+ #define NOTIF_WRITE(a) MACRO_BEGIN \
fputs(fh, a); \
if (alsoprint) LOG_INFO(a); \
- } MACRO_END
+ MACRO_END
- #define NOTIF_WRITE_ENTITY(e, description) MACRO_BEGIN { \
+ #define NOTIF_WRITE_ENTITY(e, description) MACRO_BEGIN \
string notif_msg = sprintf( \
"seta notification_%s \"%d\" \"%s\"\n", \
Get_Notif_CvarName(e), e.nent_default, description \
); \
NOTIF_WRITE(notif_msg); \
- } MACRO_END
+ MACRO_END
- #define NOTIF_WRITE_ENTITY_CHOICE(e, descriptiona, descriptionb) MACRO_BEGIN { \
+ #define NOTIF_WRITE_ENTITY_CHOICE(e, descriptiona, descriptionb) MACRO_BEGIN \
string notif_msg = sprintf( \
"seta notification_%s \"%d\" \"%s\"\n" \
"seta notification_%s_ALLOWED \"%d\" \"%s\"\n", \
Get_Notif_CvarName(e), e.nent_challow_def, descriptionb \
); \
NOTIF_WRITE(notif_msg); \
- } MACRO_END
+ MACRO_END
- #define NOTIF_WRITE_HARDCODED(cvar, default, description) MACRO_BEGIN { \
+ #define NOTIF_WRITE_HARDCODED(cvar, default, description) MACRO_BEGIN \
string notif_msg = sprintf( \
"seta notification_%s \"%s\" \"%s\"\n", \
cvar, default, description \
); \
NOTIF_WRITE(notif_msg); \
- } MACRO_END
+ MACRO_END
// Note: This warning only applies to the notifications.cfg file that is output...
// You ARE supposed to manually edit this function to add i.e. hard coded
// 2. Manually handling each separate call on per-usage basis (See old CTF usage of verbose)
entity found_choice;
- #define RECURSE_FROM_CHOICE(ent,action) MACRO_BEGIN { \
+ #define RECURSE_FROM_CHOICE(ent,action) MACRO_BEGIN \
if (notif.nent_challow_var && (warmup_stage || (notif.nent_challow_var == 2))) { \
switch (CS(ent).msg_choice_choices[net_name.nent_choice_idx]) \
{ \
found_choice.nent_floatcount, \
s1, s2, s3, s4, \
f1, f2, f3, f4); \
- } MACRO_END
+ MACRO_END
switch (broadcast)
{
ARG_CASE(ARG_CS_SV_HA, "minigame1_name",find(NULL,netname,s1).descriptor.message) \
ARG_CASE(ARG_CS_SV_HA, "minigame1_d", find(NULL,netname,s1).descriptor.netname)
-#define NOTIF_HIT_MAX(count,funcname) MACRO_BEGIN { \
+#define NOTIF_HIT_MAX(count,funcname) MACRO_BEGIN \
if(sel_num == count) { backtrace(sprintf("%s: Hit maximum arguments!\n", funcname)); break; } \
-} MACRO_END
+MACRO_END
#define NOTIF_HIT_UNKNOWN(token,funcname) { backtrace(sprintf("%s: Hit unknown token in selected string! '%s'\n", funcname, selected)); break; }
#define KILL_SPREE_LIST \
{
return a == 0 ? (_lerp < 1 ? 0 : b)
: b == 0 ? (_lerp > 0 ? 0 : a)
- : a * (fabs(b / a) ** _lerp);
+ : a * POW(fabs(b / a), _lerp);
}
void PM_ClientMovement_UpdateStatus(entity this)
if (dot > 0) // we can't change direction while slowing down
{
- k *= (dot ** PHYS_AIRCONTROL_POWER(this)) * dt;
+ k *= POW(dot, PHYS_AIRCONTROL_POWER(this)) * dt;
xyspeed = max(0, xyspeed - PHYS_AIRCONTROL_PENALTY(this) * sqrt(max(0, 1 - dot*dot)) * k/32);
k *= PHYS_AIRCONTROL(this);
this.velocity = normalize(this.velocity * xyspeed + wishdir * k);
#ifdef SVQC
#define _sound(e, c, s, v, a) \
MACRO_BEGIN \
- { \
entity __e = e; \
if (sound_allowed(MSG_BROADCAST, __e)) \
sound7(__e, c, s, v, a, 0, 0); \
- } MACRO_END
+ MACRO_END
#else
#define _sound(e, c, s, v, a) sound7(e, c, s, v, a, 0, 0)
#endif
*/
#define sound8(e, o, chan, samp, vol, atten, speed, sf) \
MACRO_BEGIN \
- { \
entity __e; \
int __chan = chan; \
string __samp = samp; \
setorigin(__e, old_origin); \
setsize(__e, old_mins, old_maxs); \
} \
- } MACRO_END
+ MACRO_END
CLASS(Sound, Object)
ATTRIB(Sound, m_id, int, 0);
this.movedir *= this.speed;
setthink(this, conveyor_think);
this.nextthink = time;
- IFTARGETED
+ if(THIS_TARGETED)
{
this.use = conveyor_use;
this.reset = conveyor_reset;
void door_trigger_touch(entity this, entity toucher)
{
- if (toucher.health < 1)
+ if (toucher.health < 1){
#ifdef SVQC
- if (!((toucher.iscreature || (toucher.flags & FL_PROJECTILE)) && !IS_DEAD(toucher)))
+ if (!((toucher.iscreature || (toucher.flags & FL_PROJECTILE)) && !IS_DEAD(toucher))){
#elif defined(CSQC)
- if(!((IS_CLIENT(toucher) || toucher.classname == "csqcprojectile") && !IS_DEAD(toucher)))
+ if(!((IS_CLIENT(toucher) || toucher.classname == "csqcprojectile") && !IS_DEAD(toucher))){
#endif
return;
+ }
+ }
- if (time < this.door_finished)
+ if (time < this.door_finished){
return;
+ }
// check if door is locked
- if (!door_check_keys(this, toucher))
+ if (!door_check_keys(this, toucher)){
return;
+ }
this.door_finished = time + 1;
door_link();
#endif
- if (this.enemy)
+ if (this.enemy){
return; // already linked by another door
+ }
if (this.spawnflags & 4)
{
this.owner = this.enemy = this;
if (this.health)
return;
- IFTARGETED
+ if(THIS_TARGETED)
return;
if (this.items)
return;
cmaxs = this.absmax;
for(t = this; ; t = t.enemy)
{
- if(t.health && !this.health)
+ if(t.health && !this.health){
this.health = t.health;
- if((t.targetname != "") && (this.targetname == ""))
+ }
+ if((t.targetname != "") && (this.targetname == "")){
this.targetname = t.targetname;
- if((t.message != "") && (this.message == ""))
+ }
+ if((t.message != "") && (this.message == "")){
this.message = t.message;
- if (t.absmin_x < cmins_x)
+ }
+ if (t.absmin_x < cmins_x){
cmins_x = t.absmin_x;
- if (t.absmin_y < cmins_y)
+ }
+ if (t.absmin_y < cmins_y){
cmins_y = t.absmin_y;
- if (t.absmin_z < cmins_z)
+ }
+ if (t.absmin_z < cmins_z){
cmins_z = t.absmin_z;
- if (t.absmax_x > cmaxs_x)
+ }
+ if (t.absmax_x > cmaxs_x){
cmaxs_x = t.absmax_x;
- if (t.absmax_y > cmaxs_y)
+ }
+ if (t.absmax_y > cmaxs_y){
cmaxs_y = t.absmax_y;
- if (t.absmax_z > cmaxs_z)
+ }
+ if (t.absmax_z > cmaxs_z){
cmaxs_z = t.absmax_z;
- if(t.enemy == this)
+ }
+ if(t.enemy == this){
break;
+ }
}
// distribute health, targetname, message
// shootable, or triggered doors just needed the owner/enemy links,
// they don't spawn a field
- if (this.health)
+ if (this.health) {
return;
- IFTARGETED
+ }
+ if(THIS_TARGETED) {
return;
- if (this.items)
+ }
+ if (this.items) {
return;
+ }
door_spawnfield(this, cmins, cmaxs);
}
spawnfunc(func_door)
{
// Quake 1 keys compatibility
- if (this.spawnflags & SPAWNFLAGS_GOLD_KEY)
+ if (this.spawnflags & SPAWNFLAGS_GOLD_KEY) {
this.itemkeys |= ITEM_KEY_BIT(0);
- if (this.spawnflags & SPAWNFLAGS_SILVER_KEY)
+ }
+ if (this.spawnflags & SPAWNFLAGS_SILVER_KEY) {
this.itemkeys |= ITEM_KEY_BIT(1);
+ }
SetMovedir(this);
this.max_health = this.health;
- if (!InitMovingBrushTrigger(this))
+ if (!InitMovingBrushTrigger(this)) {
return;
+ }
this.effects |= EF_LOWPRECISION;
this.classname = "door";
- if(this.noise == "")
+ if(this.noise == "") {
this.noise = "misc/talk.wav";
- if(this.noise3 == "")
+ }
+ if(this.noise3 == "") {
this.noise3 = "misc/talk.wav";
+ }
precache_sound(this.noise);
precache_sound(this.noise3);
setblocked(this, door_blocked);
this.use = door_use;
- if(this.dmg && (this.message == ""))
+ if(this.dmg && (this.message == "")) {
this.message = "was squished";
- if(this.dmg && (this.message2 == ""))
+ }
+ if(this.dmg && (this.message2 == "")) {
this.message2 = "was squished by";
+ }
- if (this.sounds > 0)
- {
+ if (this.sounds > 0) {
this.noise2 = "plats/medplat1.wav";
this.noise1 = "plats/medplat2.wav";
}
if(this.noise1 && this.noise1 != "") { precache_sound(this.noise1); }
if(this.noise2 && this.noise2 != "") { precache_sound(this.noise2); }
- if (!this.speed)
+ if (!this.speed) {
this.speed = 100;
- if (!this.wait)
+ }
+ if (!this.wait) {
this.wait = 3;
- if (!this.lip)
+ }
+ if (!this.lip) {
this.lip = 8;
+ }
this.pos1 = this.origin;
this.pos2 = this.pos1 + this.movedir*(fabs(this.movedir*this.size) - this.lip);
- if(this.spawnflags & DOOR_NONSOLID)
+ if(this.spawnflags & DOOR_NONSOLID) {
this.solid = SOLID_NOT;
+ }
-// DOOR_START_OPEN is to allow an entity to be lighted in the closed position
-// but spawn in the open position
- if (this.spawnflags & DOOR_START_OPEN)
+ // DOOR_START_OPEN is to allow an entity to be lighted in the closed position
+ // but spawn in the open position
+ if (this.spawnflags & DOOR_START_OPEN) {
InitializeEntity(this, door_init_startopen, INITPRIO_SETLOCATION);
+ }
this.state = STATE_BOTTOM;
- if (this.health)
- {
+ if (this.health) {
this.takedamage = DAMAGE_YES;
this.event_damage = door_damage;
}
- if (this.items)
+ if (this.items) {
this.wait = -1;
+ }
settouch(this, door_touch);
-// LinkDoors can't be done until all of the doors have been spawned, so
-// the sizes can be detected properly.
+ // LinkDoors can't be done until all of the doors have been spawned, so
+ // the sizes can be detected properly.
InitializeEntity(this, LinkDoors, INITPRIO_LINKDOORS);
this.reset = door_reset;
setblocked(this, secret_blocked);
this.speed = 50;
this.use = fd_secret_use;
- IFTARGETED
+ if(THIS_TARGETED)
{
}
else
Net_LinkEntity(this, (this.spawnflags & 4), 0, pointparticles_SendEntity);
- IFTARGETED
+ if(THIS_TARGETED)
{
this.use = pointparticles_use;
this.reset = pointparticles_reset;
Net_LinkEntity(this, false, 0, laser_SendEntity);
- IFTARGETED
+ if(THIS_TARGETED)
{
this.reset = laser_reset;
this.reset(this);
//setorigin(this, this.origin + '0 0 27'); // To fix a mappers' habit as old as Quake
setorigin(this, this.origin);
- IFTARGETED
+ if(THIS_TARGETED)
{
}
else
void plat_reset(entity this)
{
- IFTARGETED
+ if(THIS_TARGETED)
{
setorigin(this, this.pos1);
this.state = 4;
if(!this.atten && !(this.spawnflags & 4))
{
- IFTARGETED
+ if(THIS_TARGETED)
this.atten = ATTEN_NORM;
else
this.atten = ATTEN_STATIC;
if(!this.volume)
this.volume = 1;
- IFTARGETED
+ if(THIS_TARGETED)
{
if(this.spawnflags & 8) // ACTIVATOR
this.use = target_speaker_use_activator;
precache_sound(this.noise);
this.state = true;
- IFTARGETED
+ if(THIS_TARGETED)
{
this.use = trigger_gravity_use;
if(this.spawnflags & 2)
if(!pushdeltatime) return;
// div0: ticrate independent, 1 = identity (not 20)
- toucher.velocity = toucher.velocity * (this.strength ** pushdeltatime);
+ toucher.velocity = toucher.velocity * POW(this.strength, pushdeltatime);
#ifdef SVQC
UpdateCSQCProjectile(toucher);
else
{
if(!this.strength) this.strength = 0.9;
- this.strength = (this.strength ** autocvar_g_triggerimpulse_accel_power) * autocvar_g_triggerimpulse_accel_multiplier;
+ this.strength = POW(this.strength, autocvar_g_triggerimpulse_accel_power) * autocvar_g_triggerimpulse_accel_multiplier;
settouch(this, trigger_impulse_touch2);
}
}
setthink(this, multivibrator_send_think);
this.nextthink = max(1, time);
- IFTARGETED
+ if(THIS_TARGETED)
multivibrator_reset(this);
}
#endif
.float height;
+// we love double negation around here
+// TODO check why grep doesn't find any assignments to it
.float nottargeted;
-#define IFTARGETED if(!this.nottargeted && this.targetname != "")
+#define THIS_TARGETED !this.nottargeted && this.targetname != ""
.float lip;
if(this.maxdistance > waypointsprite_normdistance)
- a *= (bound(0, (this.maxdistance - dist) / (this.maxdistance - waypointsprite_normdistance), 1) ** waypointsprite_distancealphaexponent);
+ a *= POW(bound(0, (this.maxdistance - dist) / (this.maxdistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent);
else if(this.maxdistance > 0)
- a *= (bound(0, (waypointsprite_fadedistance - dist) / (waypointsprite_fadedistance - waypointsprite_normdistance), 1) ** waypointsprite_distancealphaexponent) * (1 - waypointsprite_minalpha) + waypointsprite_minalpha;
+ a *= POW(bound(0, (waypointsprite_fadedistance - dist) / (waypointsprite_fadedistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent) * (1 - waypointsprite_minalpha) + waypointsprite_minalpha;
if(rgb == '0 0 0')
{
(vid_conwidth - (vid_conwidth * waypointsprite_edgeoffset_right)) - o_x,
(vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)) - o_y);
- float crosshairdistance = sqrt( ((o.x - vid_conwidth/2) ** 2) + ((o.y - vid_conheight/2) ** 2) );
+ float crosshairdistance = sqrt( POW((o.x - vid_conwidth/2), 2) + POW((o.y - vid_conheight/2), 2) );
t = waypointsprite_scale;
a *= waypointsprite_alpha;
STATIC_INIT(compressShortVector)
{
float l = 1;
- float f = (2 ** (1/8));
+ float f = POW(2, (1/8));
int i;
for(i = 0; i < 128; ++i)
{
if(PHYS_CS(this).movement_x > 0) // right
this.angles_y = forward_y;
- if(old_movement_x > 0)
+ if(old_movement_x > 0) {
#ifdef CSQC
input_angles_x =
#endif
this.v_angle_x = this.angles_x = -50;
- else if(old_movement_x < 0)
+ } else if(old_movement_x < 0) {
#ifdef CSQC
input_angles_x =
#endif
this.v_angle_x = this.angles_x = 50;
+ }
//if(!PHYS_INPUT_BUTTON_CROUCH(this) && !IS_DUCKED(this))
#ifdef SVQC
//PHYS_INPUT_BUTTON_CROUCH(this) = (old_movement_x < 0);
- if (old_movement.x < 0)
+ if (old_movement.x < 0) {
PHYS_INPUT_BUTTON_CROUCH(this) = true;
+ }
#elif defined(CSQC)
- if (old_movement.x < 0)
- {
+ if (old_movement.x < 0) {
input_buttons |= BIT(4);
this.flags |= FL_DUCKED;
}
if (a >= 24)
{
a -= 24;
- return '0 0 1' * (2 ** a);
+ return '0 0 1' * POW(2, a);
}
- return '0 1 0' * (2 ** a);
+ return '0 1 0' * POW(2, a);
}
- return '1 0 0' * (2 ** a);
+ return '1 0 0' * POW(2, a);
}
#ifdef SVQC
void WriteWepSet(float dst, WepSet w)
config_queue[WEP_CONFIG_COUNT] = a; \
++WEP_CONFIG_COUNT; }
-#define WEP_CONFIG_WRITETOFILE(a) MACRO_BEGIN { \
+#define WEP_CONFIG_WRITETOFILE(a) MACRO_BEGIN \
fputs(wep_config_file, a); \
if(wep_config_alsoprint) { LOG_INFO(a); } \
-} MACRO_END
+MACRO_END
#define WEP_CONFIG_WRITE_CVARS(wepname, name, T) WEP_CONFIG_WRITE_PROPS_##T(wepname, name)
return avg_origin; // nothing to do
// yes, mathematically we can do this in ONE step, but beware of 32bit floats...
- avg_dist = (vlen(e.origin - avg_origin) ** 2);
+ avg_dist = POW(vlen(e.origin - avg_origin), 2);
for(p = e; (p = p.queuenext) != e; )
- avg_dist += (vlen(WarpZone_RefSys_TransformOrigin(p, e, p.origin) - avg_origin) ** 2);
+ avg_dist += POW(vlen(WarpZone_RefSys_TransformOrigin(p, e, p.origin) - avg_origin), 2);
avg_dist *= (1.0 / n);
avg_dist = sqrt(avg_dist);
float dt, dmg_remaining_next, f;
dt = time - this.teleport_time;
- dmg_remaining_next = (bound(0, 1 - dt / this.dmg_duration, 1) ** this.dmg_power);
+ dmg_remaining_next = POW(bound(0, 1 - dt / this.dmg_duration, 1), this.dmg_power);
f = this.dmg_last - dmg_remaining_next;
this.dmg_last = dmg_remaining_next;
if (restart) {
snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m + Tuba_PitchStep);
}
- speed1 = (2.0 ** ((m - Tuba_PitchStep) / 12.0));
+ speed1 = POW(2.0, ((m - Tuba_PitchStep) / 12.0));
} else if (e.note - m + Tuba_PitchStep > TUBA_MAX) {
if (restart) {
snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m);
}
- speed1 = (2.0 ** (m / 12.0));
+ speed1 = POW(2.0, (m / 12.0));
} else {
if (restart) {
snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m);
}
vol1 = cos(M_PI_2 * m / Tuba_PitchStep);
- speed1 = (2.0 ** (m / 12.0));
+ speed1 = POW(2.0, (m / 12.0));
if (restart) {
snd2 = TUBA_STARTNOTE(e.tuba_instrument, e.note - m + Tuba_PitchStep);
}
vol2 = sin(M_PI_2 * m / Tuba_PitchStep);
- speed2 = (2.0 ** ((m - Tuba_PitchStep) / 12.0));
+ speed2 = POW(2.0, ((m - Tuba_PitchStep) / 12.0));
}
} else if (restart) {
snd1 = TUBA_STARTNOTE(e.tuba_instrument, e.note);
#define AL_NEW(this, n, default, T) \
MACRO_BEGIN \
- { \
ArrayList _al = this = new_pure(ArrayList); \
_al.al_buf = buf_create(); \
for (int i = 0, _n = _al.al_len = n; i < _n; ++i) \
const _AL_type__##T() it = default; \
AL_set##T(this, i, it); \
} \
- } MACRO_END
+ MACRO_END
#define AL_DELETE(this) \
MACRO_BEGIN \
- { \
buf_del(this.al_buf); \
delete(this); \
this = NULL; \
- } MACRO_END
+ MACRO_END
#define _AL_type__s() string
#define AL_gets(this, idx) bufstr_get(this.al_buf, idx)
#define AL_EACH(this, T, cond, body) \
MACRO_BEGIN \
- { \
const noref ArrayList _al = this; \
for (int i = 0, n = _al.al_len; i < n; ++i) \
{ \
const noref _AL_type__##T() it = AL_get##T(_al, i); \
if (cond) { body } \
} \
- } MACRO_END
+ MACRO_END
#endif
#endif
+// uncrustify segfaults on this
+// *INDENT-OFF*
#ifdef GMQCC
- #define LABEL(id) :id
+ #define LABEL(id) :id
#else
- #define LABEL(id) id:
+ #define LABEL(id) id:
#endif
+// *INDENT_ON*
*/
#define IL_CLEAR(this) \
MACRO_BEGIN \
- { \
IntrusiveList __il = this; \
assert(__il); \
.entity il_prev = __il.il_prevfld; \
IL_EACH(__il, true, it.(il_next) = it.(il_prev) = NULL); \
__il.il_head = __il.il_tail = NULL; \
- } MACRO_END
+ MACRO_END
/**
* Delete the list
*/
#define IL_DELETE(this) \
MACRO_BEGIN \
- { \
delete(this); \
this = NULL; \
- } MACRO_END
+ MACRO_END
#define IL_EACH(this, cond, body) \
MACRO_BEGIN \
- { \
IntrusiveList _il = this; \
assert(_il); \
.entity il_next = _il.il_nextfld; \
{ \
const noref entity it = _it; \
_next = it.(il_next); \
- if (cond) { LAMBDA(body) } \
+ if (cond) { LAMBDA(body); } \
} \
- } MACRO_END
+ MACRO_END
.int il_id;
IntrusiveList il_links[IL_MAX];
#define FOREACH_ARRAY(arr, start, end, cond, body) \
MACRO_BEGIN \
- { \
for (int _i = start; _i < end; ++_i) \
{ \
const noref int i = _i; \
ITER_CONST noref entity it = arr[i]; \
- if (cond) { LAMBDA(body) } \
+ if (cond) { LAMBDA(body); } \
} \
- } MACRO_END
+ MACRO_END
#define FOREACH(list, cond, body) FOREACH_LIST(list, enemy, cond, body)
#define FOREACH_LIST(list, next, cond, body) \
MACRO_BEGIN \
- { \
int _i = 0; \
for (entity _it = list##_first, _next = NULL; _it; (_it = _next, ++_i)) \
{ \
const noref int i = _i; \
ITER_CONST noref entity it = _it; \
_next = _it.next; \
- if (cond) { LAMBDA(body) } \
+ if (cond) { LAMBDA(body); } \
} \
- } MACRO_END
+ MACRO_END
#define FOREACH_WORD(words, cond, body) \
MACRO_BEGIN \
- { \
string _words = words; \
int _i = 0; \
for (string _it; (_it = car(_words)); (_words = cdr(_words), ++_i)) \
{ \
const noref int i = _i; \
const noref string it = _it; \
- if (cond) { LAMBDA(body) } \
+ if (cond) { LAMBDA(body); } \
} \
- } MACRO_END
+ MACRO_END
#define STRING_ITERATOR(this, s, i) \
string this##_s = s; \
int this##_i = i
#define STRING_ITERATOR_SET(this, s, i) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
this##_s = s; \
this##_i = i; \
- } MACRO_END
+ MACRO_END
#define STRING_ITERATOR_GET(this) str2chr(this##_s, this##_i++)
#define STRING_ITERATOR_PEEK(this) str2chr(this##_s, this##_i)
-#define STRING_ITERATOR_NEXT(this) MACRO_BEGIN ++this##_i; MACRO_END
-#define STRING_ITERATOR_UNGET(this) MACRO_BEGIN --this##_i; MACRO_END
+#define STRING_ITERATOR_NEXT(this) MACRO_BEGIN { ++this##_i; } MACRO_END
+#define STRING_ITERATOR_UNGET(this) MACRO_BEGIN { --this##_i; } MACRO_END
#define STRING_ITERATOR_SAVE(this) this##_i
#define STRING_ITERATOR_LOAD(this, n) MACRO_BEGIN this##_i = n; MACRO_END
#define FOREACH_CHAR(s, cond, body) \
MACRO_BEGIN \
- { \
STRING_ITERATOR(iter, s, 0); \
int _it; \
while ((_it = STRING_ITERATOR_GET(iter)) > 0) \
{ \
const noref int it = _it; \
- if (cond) { LAMBDA(body) } \
+ if (cond) { LAMBDA(body); } \
} \
- } MACRO_END
+ MACRO_END
#if defined(CSQC)
entity(entity start, .string fld, string match) _findstring = #18;
#define ORDERED(F) F##_UNORDERED
#define _FOREACH_ENTITY_FIND_ORDERED(T, fld, match, cond, body) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
int _i = 0; \
for (entity _it = NULL; (_it = _find##T(_it, fld, match)); ++_i) \
{ \
const noref int i = _i; \
ITER_CONST noref entity it = _it; \
- if (cond) LAMBDA(body) \
+ if (cond) LAMBDA(body); \
} \
- } MACRO_END
+ MACRO_END
#define MUTEX_LOCK(this) MACRO_BEGIN \
if (this) LOG_SEVEREF("Loop mutex held by %s", this); \
this = __FUNC__; \
this = string_null; \
MACRO_END
#define _FOREACH_ENTITY_FIND_UNORDERED(id, T, fld, match, cond, body) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
MUTEX_LOCK(_FOREACH_ENTITY_FIND_##T##_##id##mutex); \
entity _foundchain_first = _findchain##T##_tofield(fld, match, _FOREACH_ENTITY_FIND_##T##_next##id); \
FOREACH_LIST(_foundchain, _FOREACH_ENTITY_FIND_##T##_next##id, cond, body); \
MUTEX_UNLOCK(_FOREACH_ENTITY_FIND_##T##_##id##mutex); \
- } MACRO_END
+ MACRO_END
#define FOREACH_ENTITY(cond, body) ORDERED(FOREACH_ENTITY)(cond, body)
#define FOREACH_ENTITY_ORDERED(cond, body) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
int _i = 0; \
for (entity _it = NULL; (_it = nextent(_it)); ++_i) \
{ \
const noref int i = _i; \
ITER_CONST noref entity it = _it; \
- if (cond) LAMBDA(body) \
+ if (cond) LAMBDA(body); \
} \
- } MACRO_END
+ MACRO_END
/** marker field, always NULL */
.entity _FOREACH_ENTITY_fld;
.entity _FOREACH_ENTITY_FIND_entity_nextall; noref string _FOREACH_ENTITY_FIND_entity_allmutex;
#define JSON_FAIL(reason) goto fail
#define JSON_END() \
return true; \
-:fail \
+LABEL(fail) \
STRING_ITERATOR_LOAD(_json, __i); \
return false;
// Current namespace
#define LL_CLEAR_1(this) LL_CLEAR_2(this, LAMBDA())
#define LL_CLEAR_2(this, dtor) \
MACRO_BEGIN \
- { \
LinkedList _ll = this; \
assert(_ll); \
while (_ll.ll_tail) \
dtor \
delete(it); \
} \
- } MACRO_END
+ MACRO_END
#define LL_DELETE(...) EVAL_LL_DELETE(OVERLOAD(LL_DELETE, __VA_ARGS__))
#define EVAL_LL_DELETE(...) __VA_ARGS__
#define LL_DELETE_1(this) LL_DELETE_2(this, LAMBDA())
#define LL_DELETE_2(this, dtor) \
MACRO_BEGIN \
- { \
LL_CLEAR_2(this, dtor); \
delete(this); \
this = NULL; \
- } MACRO_END
+ MACRO_END
#define LL_EACH(list, cond, body) \
- MACRO_BEGIN \
- { \
+ MACRO_BEGIN \
noref int i = 0; \
for (entity _it = list.ll_head; _it; (_it = _it.ll_next, ++i)) \
{ \
ITER_CONST noref entity it = _it.ll_data; \
if (cond) { body } \
} \
- } MACRO_END
+ MACRO_END
#define devassert(...) MACRO_BEGIN if (autocvar_developer) assert(__VA_ARGS__); MACRO_END
#define assert_once(expr, ...) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
static bool __once; \
if (!__once) \
{ \
assert(expr, __VA_ARGS__); \
__once = true; \
} \
- } MACRO_END
+ MACRO_END
#define devassert_once(...) MACRO_BEGIN if (autocvar_developer) assert_once(__VA_ARGS__); MACRO_END
#define demand(expr, ...) _assert(LOG_FATAL, expr, __VA_ARGS__)
#define _assert(f, expr, then) \
MACRO_BEGIN \
- { \
if (!(expr)) \
{ \
f("assertion failed: `" #expr "`\n"); \
then; \
} \
- } MACRO_END
+ MACRO_END
#define ASSERT_LESS(name, var, const) noref int name[(const - var + 1)];
#define _LOG_HEADER(level) "^9[::" "^7"PROGNAME"^9" "::" level"^9" "] ", __SOURCELOC__
#define _LOG(f, level, s) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
f(strcat1n(_LOG_HEADER(level), "\n^7", s, "\n")); \
- } MACRO_END
+ MACRO_END
#define LOG_FATAL(...) _LOG_FATAL(strcat1n(__VA_ARGS__))
#define LOG_FATALF(...) _LOG_FATAL(sprintf(__VA_ARGS__))
#define LOG_INFO(...) _LOG_INFO(strcat1n(__VA_ARGS__))
#define LOG_INFOF(...) _LOG_INFO(sprintf(__VA_ARGS__))
#define _LOG_INFO(s) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
dprint(_LOG_HEADER("^5INFO")); \
string __s = s; \
print("\n^7", __s); \
/* TODO: unconditionally add a newline when possible */ \
if (str2chr(__s, strlen(__s) - 1) != '\n') { print("\n"); } \
- } MACRO_END
+ MACRO_END
#define LOG_TRACE(...) _LOG_TRACE(strcat1n(__VA_ARGS__))
#define LOG_TRACEF(...) _LOG_TRACE(sprintf(__VA_ARGS__))
#define _LOG_DEBUG(s) _LOG(dprint2, "^2DEBUG", s)
#define dprint2(msg) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
if (autocvar_developer > 1) dprint(msg); \
- } MACRO_END
+ MACRO_END
// TODO: this sucks, lets find a better way to do backtraces?
#define _backtrace() builtin_remove(NULL)
#define backtrace(msg) \
MACRO_BEGIN \
- { \
int dev = autocvar_developer; \
bool war = autocvar_prvm_backtraceforwarnings; \
bt_cvar_set("developer", "1"); \
print("\n--- CUT UNTIL HERE ---\n"); \
bt_cvar_set("developer", ftos(dev)); \
bt_cvar_set("prvm_backtraceforwarnings", ftos(war)); \
- } MACRO_END
+ MACRO_END
#include "lib/float.qh"
+// uncrustify doesn't like the ** operator so let's wrap it in this wonderful macro
+// *INDENT-OFF*
+#define POW(a, e) ((a) ** (e))
+// *INDENT-ON*
+
ERASEABLE
void mean_accumulate(entity e, .float a, .float c, float mean, float value, float weight)
{
if (weight == 0) return;
- if (mean == 0) e.(a) *= (value ** weight);
- else e.(a) += (value ** mean) * weight;
+ if (mean == 0) e.(a) *= POW(value, weight);
+ else e.(a) += POW(value, mean) * weight;
e.(c) += weight;
}
float mean_evaluate(entity e, .float a, .float c, float mean)
{
if (e.(c) == 0) return 0;
- if (mean == 0) return (e.(a) ** (1.0 / e.(c)));
- else return ((e.(a) / e.(c)) ** (1.0 / mean));
+ if (mean == 0) return POW(e.(a), (1.0 / e.(c)));
+ else return POW((e.(a) / e.(c)), (1.0 / mean));
}
#define MEAN_ACCUMULATE(s, prefix, v, w) mean_accumulate(s, prefix##_accumulator, prefix##_count, prefix##_mean, v, w)
ERASEABLE
float ExponentialFalloff(float mindist, float maxdist, float halflifedist, float d)
{
- if (halflifedist > 0) return (0.5 ** ((bound(mindist, d, maxdist) - mindist) / halflifedist));
- else if (halflifedist < 0) return (0.5 ** ((bound(mindist, d, maxdist) - maxdist) / halflifedist));
+ if (halflifedist > 0) return POW(0.5, ((bound(mindist, d, maxdist) - mindist) / halflifedist));
+ else if (halflifedist < 0) return POW(0.5, ((bound(mindist, d, maxdist) - maxdist) / halflifedist));
else return 1;
}
-#define power2of(e) (2 ** e)
+#define power2of(e) POW(2, e)
ERASEABLE
float log2of(float e)
// With block may not contain continue or break
#define WITH(type, name, value, block) \
MACRO_BEGIN \
- { \
type __with_save = (name); \
name = (value); \
LAMBDA(block) \
name = __with_save; \
- } MACRO_END
+ MACRO_END
const int MSG_C2S = 0;
#define Net_Accept(classname) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
if (!this) this = new(classname); \
- } MACRO_END
+ MACRO_END
#define Net_Reject() \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
if (this) delete(this); \
- } MACRO_END
+ MACRO_END
string g_buf;
#if defined(CSQC)
#define WriteHeader(to, id) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
WriteByte(to, NET_##id.m_id); \
- } MACRO_END
+ MACRO_END
#elif defined(SVQC)
#define WriteHeader(to, id) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
if (NET_##id##_istemp) WriteByte(to, SVC_TEMPENTITY); \
WriteByte(to, NET_##id.m_id); \
bool _net_valid = false; serialize_marker(to, _net_valid); \
- } MACRO_END
+ MACRO_END
#endif
// serialization: new style
}
#define WriteFloat(to, f) WriteCoord(to, f)
- #define WriteVector(to, v) MACRO_BEGIN { WriteFloat(to, v.x); WriteFloat(to, v.y); WriteFloat(to, v.z); } MACRO_END
- #define WriteVector2D(to, v) MACRO_BEGIN { WriteFloat(to, v.x); WriteFloat(to, v.y); } MACRO_END
+ #define WriteVector(to, v) MACRO_BEGIN WriteFloat(to, v.x); WriteFloat(to, v.y); WriteFloat(to, v.z); MACRO_END
+ #define WriteVector2D(to, v) MACRO_BEGIN WriteFloat(to, v.x); WriteFloat(to, v.y); MACRO_END
// this will use the value:
// 128
}
// allow writing to also pass through to spectators (like so spectators see the same centerprints as players for example)
- #define WRITESPECTATABLE_MSG_ONE(to, statement) MACRO_BEGIN { \
+ #define WRITESPECTATABLE_MSG_ONE(to, statement) MACRO_BEGIN \
entity prev = msg_entity; \
entity dst = to; \
FOREACH_CLIENT(IS_REAL_CLIENT(it), { \
} \
}); \
msg_entity = prev; \
- } MACRO_END
+ MACRO_END
#endif
#endif
float f;
f = dt * 60;
// http://home.earthlink.net/~ltrammell/tech/pinkalg.htm
- if (random() > (0.3190 ** f)) e.noise_paccum = 0.34848 * (2 * random() - 1);
- if (random() > (0.7756 ** f)) e.noise_paccum2 = 0.28768 * (2 * random() - 1);
- if (random() > (0.9613 ** f)) e.noise_paccum3 = 0.43488 * (2 * random() - 1);
+ if (random() > POW(0.3190, f)) e.noise_paccum = 0.34848 * (2 * random() - 1);
+ if (random() > POW(0.7756, f)) e.noise_paccum2 = 0.28768 * (2 * random() - 1);
+ if (random() > POW(0.9613, f)) e.noise_paccum3 = 0.43488 * (2 * random() - 1);
return e.noise_paccum + e.noise_paccum2 + e.noise_paccum3;
}
ERASEABLE
ERASEABLE
float Noise_Burst(entity e, float dt, float p)
{
- if (random() > (p ** dt)) e.noise_bstate = !e.noise_bstate;
+ if (random() > POW(p, dt)) e.noise_bstate = !e.noise_bstate;
return 2 * e.noise_bstate - 1;
}
/** @deprecated use new_pure or NEW(class) */
#define make_pure(e) \
MACRO_BEGIN \
- { \
(e).pure_data = true; \
- } MACRO_END
+ MACRO_END
#define make_impure(e) \
MACRO_BEGIN \
- { \
(e).pure_data = false; \
- } MACRO_END
+ MACRO_END
#define is_pure(e) ((e).pure_data)
.string classname;
#define delete_fn builtin_remove
#endif
-#define delete(this) MACRO_BEGIN { \
+#define delete(this) MACRO_BEGIN \
entity _this = (this); \
void(entity) _dtor = _this.dtor; \
ONREMOVE(this); \
if (_dtor) _dtor(_this); else delete_fn(_this); \
/* this = NULL; */ \
-} MACRO_END
+MACRO_END
entity _clearentity_ent;
STATIC_INIT(clearentity)
ACCUMULATE_FUNCTION(_Register##registry, Register_##id) \
REGISTER_INIT(id)
-#define REGISTRY_PUSH(registry, fld, it) MACRO_BEGIN { \
+#define REGISTRY_PUSH(registry, fld, it) MACRO_BEGIN \
it.fld = registry##_COUNT; \
_R_SET(_##registry, registry##_COUNT, it); \
++registry##_COUNT; \
if (!registry##_first) registry##_first = it; \
if (registry##_last) registry##_last.REGISTRY_NEXT = it; \
registry##_last = it; \
-} MACRO_END
+MACRO_END
-#define REGISTRY_RESERVE(registry, fld, id, suffix) MACRO_BEGIN { \
+#define REGISTRY_RESERVE(registry, fld, id, suffix) MACRO_BEGIN \
entity e = new_pure(registry_reserved); \
e.registered_id = #id "/" #suffix; \
REGISTRY_PUSH(registry, fld, e); \
-} MACRO_END
+MACRO_END
#define REGISTER_INIT(id) [[accumulate]] void Register_##id##_init(entity this)
{
#define heapify(_count) \
MACRO_BEGIN \
- { \
for (int start = floor(((_count) - 2) / 2); start >= 0; --start) \
{ \
siftdown(start, (_count) - 1); \
} \
- } MACRO_END
+ MACRO_END
#define siftdown(_start, _end) \
MACRO_BEGIN \
- { \
for (int root = (_start); root * 2 + 1 <= (_end); ) \
{ \
int child = root * 2 + 1; \
swap(root, child, pass); \
root = child; \
} \
- } MACRO_END
+ MACRO_END
heapify(n);
int end = n - 1;
#define addstat_int(id, fld) addstat(id, AS_INT, fld)
#define addstat_bool(id, fld) addstat(id, AS_INT, fld)
#define addstat_float(id, fld) addstat(id, AS_FLOAT, fld)
- #define addstat_vector(id, fld) MACRO_BEGIN { \
+ #define addstat_vector(id, fld) MACRO_BEGIN \
addstat_float(id + 0, fld##_x); \
addstat_float(id + 1, fld##_y); \
addstat_float(id + 2, fld##_z); \
- } MACRO_END
- #define addstat_vectori(id, fld) MACRO_BEGIN { \
+ MACRO_END
+ #define addstat_vectori(id, fld) MACRO_BEGIN \
addstat_int(id + 0, fld##_x); \
addstat_int(id + 1, fld##_y); \
addstat_int(id + 2, fld##_z); \
- } MACRO_END
+ MACRO_END
const int AS_STRING = 1;
const int AS_INT = 2;
const int AS_FLOAT = 8;
// difference between expect/assert: assert returns early
-#define EXPECT_EQ(expected_, actual_) MACRO_BEGIN { \
+#define EXPECT_EQ(expected_, actual_) MACRO_BEGIN \
int expected = expected_; \
int actual = actual_; \
if ((expected) != (actual)) { \
actual, expected \
)); \
} \
-} MACRO_END
+MACRO_END
#define ASSERT_EQ(expected, actual) _TEST_ASSERT(EXPECT_EQ(expected, actual))
#define EXPECT_TRUE(condition) EXPECT_EQ(true, condition)
int TEST_failed;
#define _TEST_ASSERT(statement) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
LAMBDA(statement); \
++TEST_fatal; return; \
- } MACRO_END
+ MACRO_END
#define EXPECT_NO_FATAL_FAILURE__(statement, then) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
int TEST_prevfatal = TEST_fatal; \
LAMBDA(statement); \
if (TEST_fatal != TEST_prevfatal) \
LAMBDA(then); \
- } MACRO_END
+ MACRO_END
#define EXPECT_NO_FATAL_FAILURE_(statement, then) \
EXPECT_NO_FATAL_FAILURE__(statement, { \
#define YAW(v) ((v).y)
#define ROLL(v) ((v).z)
-#define MAKEVECTORS(f, angles, forward, right, up) MACRO_BEGIN { \
+#define MAKEVECTORS(f, angles, forward, right, up) MACRO_BEGIN \
f(angles); \
forward = v_forward; \
right = v_right; \
up = v_up; \
-} MACRO_END
+MACRO_END
//pseudo prototypes:
// vector vec2(vector v); // returns a vector with just the x and y components of the given vector
#include "mathlib.qh"
-#if defined(CSQC)
-#elif defined(MENUQC)
-#elif defined(SVQC)
-#endif
+
+#include <lib/math.qh>
int fpclassify(float e)
{
float exp(float e)
{
- return (M_E ** e);
+ return POW(M_E, e);
}
float exp2(float e)
{
- return (2 ** e);
+ return POW(2, e);
}
float expm1(float e)
{
vector v;
v.z = 0;
v.y = ilogb(e) + 1;
- v.x = e / (2 ** v.y);
+ v.x = e / POW(2, v.y);
return v;
}
int ilogb(float e)
}
float ldexp(float e, int e)
{
- return e * (2 ** e);
+ return e * POW(2, e);
}
float logn(float e, float base)
{
float scalbn(float e, int n)
{
- return e * (2 ** n);
+ return e * POW(2, n);
}
float cbrt(float e)
{
- return copysign((fabs(e) ** (1.0/3.0)), e);
+ return copysign(POW(fabs(e), (1.0/3.0)), e);
}
float hypot(float e, float f)
{
.float warpzone_teleport_finishtime;
.entity warpzone_teleport_zone;
-#define WarpZone_StoreProjectileData(e_) MACRO_BEGIN { \
+#define WarpZone_StoreProjectileData(e_) MACRO_BEGIN \
entity e = e_; \
e.warpzone_oldorigin = e.origin; \
e.warpzone_oldvelocity = e.velocity; \
e.warpzone_oldangles = e.angles; \
- } MACRO_END
+ MACRO_END
void WarpZone_TeleportPlayer(entity teleporter, entity player, vector to, vector to_angles, vector to_velocity)
{
#include "test.qh"
#define yenc_single(c, ret) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
int conv = c; \
conv += 42; \
if (conv >= 256) conv -= 256; \
break; \
} \
} \
- } MACRO_END
+ MACRO_END
#define ydec_single(stringiter, ret) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
int conv = STRING_ITERATOR_GET(stringiter); \
if (conv <= 0) { \
ret = -1; \
conv -= 42; \
ret = conv; \
} \
- } MACRO_END
+ MACRO_END
TEST(yEnc, EncodeDecode)
{
{
Xonotic_KeyBinds_Count = 0;
- #define KEYBIND_DEF(func, desc) MACRO_BEGIN { \
+ #define KEYBIND_DEF(func, desc) MACRO_BEGIN \
if((Xonotic_KeyBinds_Count < MAX_KEYBINDS)) { \
Xonotic_KeyBinds_Functions[Xonotic_KeyBinds_Count] = strzone(func); \
Xonotic_KeyBinds_Descriptions[Xonotic_KeyBinds_Count] = strzone(desc); \
++Xonotic_KeyBinds_Count; \
} \
- } MACRO_END
+ MACRO_END
KEYBIND_DEF("" , _("Moving"));
KEYBIND_DEF("+forward" , _("forward"));
{
return
(
- 2500 * (0.25 ** max(0, cvar("gl_picmip") + cvar("gl_picmip_other")))
- + 1500 * (0.25 ** max(0, cvar("gl_picmip") + cvar("gl_picmip_world")))
+ 2500 * POW(0.25, max(0, cvar("gl_picmip") + cvar("gl_picmip_other")))
+ + 1500 * POW(0.25, max(0, cvar("gl_picmip") + cvar("gl_picmip_world")))
) * ((s3tc && (cvar("r_texture_dds_load") || cvar("gl_texturecompression"))) ? 0.2 : 1.0); // TC: normalmaps 50%, other 25%, few incompressible, guessing 40% as conservative average
}
void XonoticPicmipSlider_autofix(entity me)
blendrate = autocvar_bot_ai_aimskill_blendrate;
r = max(fixedrate, blendrate);
//this.v_angle = this.v_angle + diffang * bound(frametime, r * frametime * (2+skill*skill*0.05-random()*0.05*(10-skill)), 1);
- this.v_angle = this.v_angle + diffang * bound(delta_t, r * delta_t * (2 + ((skill + this.bot_mouseskill) ** 3) * 0.005 - random()), 1);
+ this.v_angle = this.v_angle + diffang * bound(delta_t, r * delta_t * (2 + POW((skill + this.bot_mouseskill), 3) * 0.005 - random()), 1);
this.v_angle = this.v_angle * bound(0,autocvar_bot_ai_aimskill_mouse,1) + desiredang * bound(0,(1-autocvar_bot_ai_aimskill_mouse),1);
//this.v_angle = this.v_angle + diffang * bound(0, r * frametime * (skill * 0.5 + 2), 1);
//this.v_angle = this.v_angle + diffang * (1/ blendrate);
if(autocvar_bot_god)
this.flags |= FL_GODMODE;
- this.bot_nextthink = max(time, this.bot_nextthink) + max(0.01, autocvar_bot_ai_thinkinterval * (0.5 ** this.bot_aiskill) * min(14 / (skill + 14), 1));
+ this.bot_nextthink = max(time, this.bot_nextthink) + max(0.01, autocvar_bot_ai_thinkinterval * POW(0.5, this.bot_aiskill) * min(14 / (skill + 14), 1));
//if (this.bot_painintensity > 0)
// this.bot_painintensity = this.bot_painintensity - (skill + 1) * 40 * frametime;
prio = 6;
- #define READSKILL(f, w, r) MACRO_BEGIN { \
+ #define READSKILL(f, w, r) MACRO_BEGIN \
if(argv(prio) != "") \
this.f = stof(argv(prio)) * w; \
else \
this.f = (!autocvar_g_campaign) * (2 * random() - 1) * r * w; \
prio++; \
- } MACRO_END
+ MACRO_END
//print(bot_name, ": ping=", argv(9), "\n");
READSKILL(havocbot_keyboardskill, 0.5, 0.5); // keyboard skill
dxy = this.origin - ( ( this.goalcurrent.absmin + this.goalcurrent.absmax ) * 0.5 ); dxy.z = 0;
d = vlen(dxy);
v = vlen(this.velocity - this.velocity.z * '0 0 1');
- db = ((v ** 2) / (autocvar_g_jetpack_acceleration_side * 2)) + 100;
+ db = (POW(v, 2) / (autocvar_g_jetpack_acceleration_side * 2)) + 100;
// dprint("distance ", ftos(ceil(d)), " velocity ", ftos(ceil(v)), " brake at ", ftos(ceil(db)), "\n");
if(d < db || d < 500)
{
this.lastcombotime = time;
}
- distance *= (2 ** this.bot_rangepreference);
+ distance *= POW(2, this.bot_rangepreference);
// Custom weapon list based on distance to the enemy
if(bot_custom_weapon){
{
case "all":
if(enabled)
- this.bot_cmd_keys = (2 ** 20) - 1; // >:)
+ this.bot_cmd_keys = POW(2, 20) - 1; // >:)
else
this.bot_cmd_keys = BOT_CMD_KEY_NONE;
case "forward":
dragger.dragdistance = vlen(touchpoint - dragger.origin - dragger.view_ofs);
dragger.draglocalangle = draggee.angles.y - dragger.v_angle.y;
touchpoint = touchpoint - gettaginfo(draggee, 0);
- tagscale = (vlen(v_forward) ** -2);
+ tagscale = POW(vlen(v_forward), -2);
dragger.draglocalvector_x = touchpoint * v_forward * tagscale;
dragger.draglocalvector_y = touchpoint * v_right * tagscale;
dragger.draglocalvector_z = touchpoint * v_up * tagscale;
void Drag_SetSpeed(entity dragger, float s)
{
- dragger.dragspeed = (2 ** s);
+ dragger.dragspeed = POW(2, s);
}
void Drag_MoveBackward(entity dragger)
LOG_INFOF("THROUGHFLOOR: D=%f F=%f max(dD)=1/%f max(dF)=1/%f", finaldmg, vlen(force), mininv_d, mininv_f);
- total = 0.25 * (max(mininv_f, mininv_d) ** 2);
+ total = 0.25 * POW(max(mininv_f, mininv_d), 2);
if(autocvar_g_throughfloor_debug)
LOG_INFOF(" steps=%f", total);
s = cons(s, pkg);
}
// add automatically managed files to the list
- #define X(match) MACRO_BEGIN { \
+ #define X(match) MACRO_BEGIN \
int fd = search_begin(match, true, false); \
if (fd >= 0) \
{ \
} \
search_end(fd); \
} \
- } MACRO_END
+ MACRO_END
X("*-serverpackage.txt");
X("*.serverpackage");
#undef X
string newlist;
// now reinsert this at another position
- insertpos = (random() ** (1 / exponent)); // ]0, 1]
+ insertpos = POW(random(), (1 / exponent)); // ]0, 1]
insertpos = insertpos * (Map_Count - 1); // ]0, Map_Count - 1]
insertpos = ceil(insertpos) + 1; // {2, 3, 4, ..., Map_Count}
LOG_TRACE("SHUFFLE: insert pos = ", ftos(insertpos));
float tagscale;
org = e.origin - gettaginfo(to, gettagindex(to, tag));
- tagscale = (vlen(v_forward) ** -2); // undo a scale on the tag
+ tagscale = POW(vlen(v_forward), -2); // undo a scale on the tag
t_forward = v_forward * tagscale;
t_left = v_right * -tagscale;
t_up = v_up * tagscale;
f = key.team;
else
f = 30;
- s |= (32 ** key.count) * f;
+ s |= POW(32, key.count) * f;
}
FOREACH_CLIENT(true, { it.kh_state = s; });
FOR_EACH_KH_KEY(key)
{
if(key.owner)
- key.owner.kh_state |= (32 ** key.count) * 31;
+ key.owner.kh_state |= POW(32, key.count) * 31;
}
//print(ftos((nextent(NULL)).kh_state), "\n");
}
++players;
});
if (!players)
- missing_teams |= (2 ** i);
+ missing_teams |= POW(2, i);
}
return missing_teams;
}
}
if(score)
if(teamscores_label(scorefield) != "")
- s.SendFlags |= (2 ** scorefield);
+ s.SendFlags |= POW(2, scorefield);
return (s.(teamscores(scorefield)) += score);
}
FOREACH(Scores, true, {
if(sk.(scores(it)) != 0)
if(scores_label(it) != "")
- sk.SendFlags |= (2 ** (i % 16));
+ sk.SendFlags |= POW(2, (i % 16));
if(i != SP_ELO.m_id)
sk.(scores(it)) = 0;
});
FOREACH(Scores, true, {
if(sk.(scores(it)) != 0)
if(scores_label(it) != "")
- sk.SendFlags |= (2 ** (i % 16));
+ sk.SendFlags |= POW(2, (i % 16));
if(i != SP_ELO.m_id)
sk.(scores(it)) = 0;
});
{
if(sk.(teamscores(j)) != 0)
if(teamscores_label(j) != "")
- sk.SendFlags |= (2 ** j);
+ sk.SendFlags |= POW(2, j);
sk.(teamscores(j)) = 0;
}
}
return s.(scores(scorefield));
}
if(scores_label(scorefield) != "")
- s.SendFlags |= (2 ** (scorefield.m_id % 16));
+ s.SendFlags |= POW(2, (scorefield.m_id % 16));
if(!warmup_stage)
PS_GR_P_ADDVAL(s.owner, strcat(PLAYERSTATS_TOTAL, scores_label(scorefield)), score);
s.(scores(scorefield)) += score;
RandomSelection_Init();
for(spot = firstspot; spot; spot = spot.chain)
- RandomSelection_AddEnt(spot, (bound(lower, spot.spawnpoint_score.y, upper) ** exponent) * spot.cnt, (spot.spawnpoint_score.y >= lower) * 0.5 + spot.spawnpoint_score.x);
+ RandomSelection_AddEnt(spot, POW(bound(lower, spot.spawnpoint_score.y, upper), exponent) * spot.cnt, (spot.spawnpoint_score.y >= lower) * 0.5 + spot.spawnpoint_score.x);
return RandomSelection_chosen_ent;
}
// NOTE: FOR_EACH_REALPLAYER deprecated! Use the following instead: FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), { code; });
#define FOREACH_CLIENTSLOT(cond, body) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
for(int _i = 1; _i <= maxclients; ++_i) \
{ \
const noref int i = _i; \
ITER_CONST noref entity it = ftoe(i); \
- if(cond) { LAMBDA(body) } \
+ if(cond) { LAMBDA(body); } \
} \
- } MACRO_END
+ MACRO_END
#define FOREACH_CLIENT(cond, body) FOREACH_CLIENTSLOT(IS_CLIENT(it) && (cond), LAMBDA(body))
entity _FCR_clients[255];
bool _FCR_entered = false;
#define FOREACH_CLIENT_RANDOM(cond, body) \
- MACRO_BEGIN { \
+ MACRO_BEGIN \
if (_FCR_entered) LOG_FATAL("FOREACH_CLIENT_RANDOM must not be nested"); \
_FCR_entered = true; \
int _cnt = 0; \
{ \
const noref int i = _i; \
ITER_CONST noref entity it = _FCR_clients[i]; \
- if (cond) { LAMBDA(body) } \
+ if (cond) { LAMBDA(body); } \
} \
_FCR_entered = false; \
- } MACRO_END
+ MACRO_END
// NOTE: FOR_EACH_MONSTER deprecated! Use the following instead: IL_EACH(g_monsters, true, { code; });
--- /dev/null
+#!/usr/bin/env python3
+
+# Removes redundant { and } from macros because uncrustify is too dumb to indent them properly (or even not touch them).
+# Actually, after running this, you might wanna put some back, for cases like `MACRO_BEGIN { ++this##_i; } MACRO_END`,
+# otherwise it ends up like MACRO_BEGIN++ ... sigh'
+
+# all those fancy unix utilities like grep, sed and awk are either woefully inadequate for this or just completely
+# unreadable with their arcane syntaxes - and yes, the plural is intentional because why extend existing tools
+# when you can write your own with incompatible flags, commands and regex flavors, pass strings between them
+# and call it the unix "philosophy"
+
+import re
+import glob
+
+all_files = set(glob.glob("**/*.qc", recursive=True) + glob.glob("**/*.qh", recursive=True))
+all_files = {f for f in all_files if not f.startswith('qcsrc/dpdefs')}
+
+for file_name in all_files:
+ with open(file_name, "r+") as f:
+ s = f.read()
+ s = re.sub(r"MACRO_BEGIN *(?:\\\s*)?{((?:.|\n)*?)} *(?:\\\s*)?MACRO_END", r"MACRO_BEGIN\1MACRO_END", s)
+ f.seek(0)
+ f.truncate()
+ f.write(s)
--- /dev/null
+#!/usr/bin/env python3
+
+# Finds files that are not modified on any branch and formats them.
+
+# You should be on master or a branch that just merged master since we want to avoid conflicts when merging other branches into master.
+
+# If you're on Windows, you probably wanna fix path separators and maybe other tihngs, I am not touching that.
+
+from datetime import datetime, timedelta, timezone
+from dateutil import parser
+import glob
+import os.path
+import shlex
+import subprocess
+
+def main():
+ if not os.path.exists("qcsrc"):
+ # otherwise the files reported by different commands would have different prefixes
+ print("Must be run in data repo root (xonotic-data.pk3dir)")
+ return
+
+ # get the latest changes on all branches
+ run('git fetch')
+
+ # get all remote branches - those would potentially get merge conflicts if we formatted everything
+ branches = run('git branch --list --remotes')
+ # strip the leading spaces and ignore branches that are presumably used for debugging uncrustify
+ branches = [b.strip() for b in branches if "uncrustify" not in b]
+ branches.remove('origin/HEAD -> origin/master')
+ branches.remove('origin/master')
+
+ all_files = set(glob.glob("**/*.qc", recursive=True) + glob.glob("**/*.qh", recursive=True))
+ all_files = {f for f in all_files if not f.startswith('qcsrc/dpdefs')}
+ modified_files = set()
+
+ for branch in branches:
+ print(branch)
+
+ # getting this info is a bit slow
+ last_change_str = run(r'git show --pretty=format:"%ci" {}'.format(branch))[0]
+ print("\t last change:", last_change_str)
+
+ last_change = parser.parse(last_change_str)
+ if datetime.now(timezone.utc) - last_change > timedelta(days=365*2): # who cares about leap years
+ print("\t ignoring")
+ continue
+
+ # If some complex branching and merging happens, there can be multiple merge bases.
+ # The diff between each of them and the tip of the branch can contain changes that are not in master
+ # and could cause conflicts.
+ merge_bases = run('git merge-base --all origin/master {}'.format(branch))
+ for base in merge_bases:
+ print("\t", base)
+
+ # with --name-only it shows only the new name when renaming so the order matters
+ # i guess diff from branch to base should be enough but let's be sure
+ files1 = set(run('git diff --name-only {} {}'.format(base, branch)))
+ files2 = set(run('git diff --name-only {} {}'.format(branch, base)))
+ files = {f for f in files1.union(files2) if f.endswith(".qc") or f.endswith(".qh")}
+
+ for f in sorted(files):
+ print("\t\t", f)
+
+ modified_files = modified_files.union(files)
+
+ # modified files contain newly added files so the number of remaining files will be larger than all - modified
+ remaining_files = all_files - modified_files
+ nonexistent_files = modified_files - all_files
+
+ print("all on master ({}):".format(len(all_files)))
+ for f in sorted(all_files):
+ print("\t", f)
+
+ print("modified on branches ({}):".format(len(modified_files)))
+ for f in sorted(modified_files):
+ print("\t", f)
+
+ print("modified files that don't exist on master ({}):".format(len(nonexistent_files)))
+ for f in sorted(nonexistent_files):
+ print("\t", f)
+
+ print("formatting on master ({}):".format(len(remaining_files)))
+ for f in sorted(remaining_files):
+ print("\t", f)
+ run("bash qcsrc/tools/uncrustify.sh {}".format(shlex.quote(f)))
+
+def run(cmd: str) -> [str]:
+ process = subprocess.Popen(shlex.split(cmd), stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+ stdout, stderr = process.communicate()
+ return stdout.decode().splitlines()
+
+main()
# 0=spaces only
# 1=indent with tabs to brace level, align with spaces
# 2=indent and align with tabs, using spaces when not on a tabstop
-indent_with_tabs = 1 # number #force
+indent_with_tabs = 2 # number #force
# Comments that are not a brace level are indented with tabs on a tabstop.
# Requires indent_with_tabs=2. If false, will use spaces.
# 0: Indent to body level
# 1: Align under the open paren
# 2: Indent to the brace level
-indent_paren_close = 1 # number #force
+# note: i think option 2 is still buggy but it results in the fewest changes
+# so presumably it aligns well with what we already use
+indent_paren_close = 2 # number #force
# Controls the indent of a comma when inside a paren.If TRUE, aligns under the open paren
# WARNING: Code doesn't seem to use this feature - delete from the config?
sp_before_tr_emb_cmt = force # ignore/add/remove/force #force
# Number of spaces before a trailing or embedded comment
-sp_num_before_tr_emb_cmt = 2 # number #force
+sp_num_before_tr_emb_cmt = 1 # number #force
# Control space between a Java annotation and the open paren.
# WARNING: Code doesn't seem to use this feature - delete from the config?
# Add or remove newline between 'do' and '{'
# NOTE: is 3 worse than ignore
-nl_do_brace = add # ignore/add/remove/force
+nl_do_brace = remove # ignore/add/remove/force
# Add or remove newline between '}' and 'while' of 'do' statement
-nl_brace_while = add # ignore/add/remove/force #force
+nl_brace_while = remove # ignore/add/remove/force #force
# Add or remove newline between 'switch' and '{'
# NOTE: is 24 worse than ignore
-nl_switch_brace = add # ignore/add/remove/force
+nl_switch_brace = remove # ignore/add/remove/force
# Add a newline between ')' and '{' if the ')' is on a different line than the if/for/etc.
# Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch, and nl_catch_brace.
#
# Try to limit code width to N number of columns
-code_width = 120 # number
+# I think a human makes a better call here than uncrustify, with 120 everything just ends up wrapped randomly and it's harder to read
+# old code that was written by clearly insane people will just have to be fixed manually
+code_width = 1200 # number
# Whether to fully split long 'for' statements at semi-colons
# WARNING: Code doesn't seem to use this feature - delete from the config?
# Control indent of preprocessors inside #if blocks at brace level 0
# WARNING: Indifferent... please decide manually.
-pp_indent = force # ignore/add/remove/force
+pp_indent = ignore # ignore/add/remove/force
# Whether to indent #if/#else/#endif at the brace level (true) or from column 1 (false)
pp_indent_at_level = false # false/true
pp_indent_if = 4 # number
# Control whether to indent the code between #if, #else and #endif when not at file-level
-pp_if_indent_code = true # false/true
+pp_if_indent_code = false # false/true
# Whether to indent '#define' at the brace level (true) or from column 1 (false)
-pp_define_at_level = true # false/true
+pp_define_at_level = false # false/true
# You can force a token to be a type with the 'type' option.
# Example:
macro-open CLASS
macro-close ENDCLASS
+macro-open MACRO_BEGIN
+macro-close MACRO_END
+
# translations
set func_call_user _
projects / xonotic / xonotic-data.pk3dir.git / commitdiff