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);
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)
{
}
#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)
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
* @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"
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 \
#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);
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)
#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
*/
#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; \
_next = it.(il_next); \
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) } \
} \
- } 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)) \
{ \
_next = _it.next; \
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 string it = _it; \
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 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) } \
} \
- } 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) \
{ \
ITER_CONST noref entity it = _it; \
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) \
{ \
ITER_CONST noref entity it = _it; \
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 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
// 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
/** @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;
#define SUCCEED() (TEST_ok = true)
/** Add a failure, but continue */
-#define ADD_FAILURE(msg) MACRO_BEGIN { ++TEST_failed; LOG_WARN(msg); } MACRO_END
+#define ADD_FAILURE(msg) MACRO_BEGIN ++TEST_failed; LOG_WARN(msg); MACRO_END
/** Add a failure and return */
#define FAIL(msg) _TEST_ASSERT(ADD_FAILURE(msg))
// 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
.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"));
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
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
// 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) } \
} \
- } 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; \
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; });
projects / xonotic / xonotic-data.pk3dir.git / commitdiff