-Wno-field-redeclared \
-flno -futf8 -fno-bail-on-werror \
-frelaxed-switch -freturn-assignments \
+ -fdefault-eraseable \
${@:2}
;;
esac
$(QCCFLAGS_WTFS) \
-flno -futf8 -fno-bail-on-werror \
-frelaxed-switch -freturn-assignments \
+ -fdefault-eraseable \
$(QCCFLAGS_EXTRA)
// =========================================
// If this function exists, client code handles gamecommand instead of the engine code.
-void GameCommand(string command)
+EXPORT void GameCommand(string command)
{
int argc = tokenize_console(command);
else // Expiring soon, so fade it out.
a = (centerprint_expire_time[j] - time) / max(0.0001, autocvar_hud_panel_centerprint_fade_out);
- if(centerprint_msgID[j] == CPID_TIMEIN)
+ if(centerprint_msgID[j] == ORDINAL(CPID_TIMEIN))
a = 1;
// while counting down show it anyway in order to hold the current message position
}
}
// CSQC_Parse_StuffCmd : Provides the stuffcmd string in the first parameter that the server provided. To execute standard behavior, simply execute localcmd with the string.
-void CSQC_Parse_StuffCmd(string strMessage)
+EXPORT void CSQC_Parse_StuffCmd(string strMessage)
{
if (autocvar_developer_csqcentities) LOG_INFOF("CSQC_Parse_StuffCmd(\"%s\")", strMessage);
localcmd(strMessage);
}
// CSQC_Parse_Print : Provides the print string in the first parameter that the server provided. To execute standard behavior, simply execute print with the string.
-void CSQC_Parse_Print(string strMessage)
+EXPORT void CSQC_Parse_Print(string strMessage)
{
if (autocvar_developer_csqcentities) LOG_INFOF("CSQC_Parse_Print(\"%s\")", strMessage);
print(ColorTranslateRGB(strMessage));
}
// CSQC_Parse_CenterPrint : Provides the centerprint_hud string in the first parameter that the server provided.
-void CSQC_Parse_CenterPrint(string strMessage)
+EXPORT void CSQC_Parse_CenterPrint(string strMessage)
{
if (autocvar_developer_csqcentities) LOG_INFOF("CSQC_Parse_CenterPrint(\"%s\")", strMessage);
centerprint_hud(strMessage);
// CSQC_Parse_TempEntity : Handles all temporary entity network data in the CSQC layer.
// You must ALWAYS first acquire the temporary ID, which is sent as a byte.
// Return value should be 1 if CSQC handled the temporary entity, otherwise return 0 to have the engine process the event.
-bool CSQC_Parse_TempEntity()
+EXPORT bool CSQC_Parse_TempEntity()
{
// Acquire TE ID
int nTEID = ReadByte();
}
/** engine callback */
-void URI_Get_Callback(int id, int status, string data)
+EXPORT void URI_Get_Callback(int id, int status, string data)
{
TC(int, id); TC(int, status);
if(url_URI_Get_Callback(id, status, data))
#define debug_text_3d_4(pos, msg, align, dur) debug_text_3d_5(pos, msg, align, dur, stov(cvar_string("debug_text_3d_default_velocity")))
#define debug_text_3d_5(pos, msg, align, dur, vel) debug_text_3d_fn(pos, msg, align, dur, vel)
-ERASEABLE
void debug_text_3d_fn(vector pos, string msg, float align, float duration, vector vel) {
WriteHeader(MSG_BROADCAST, debug_text_3d);
WriteVector(MSG_BROADCAST, pos);
METHOD(BallStealer, wr_reload, void(entity thiswep, entity actor, .entity weaponentity))
{
- TC(BallStealer, this);
+ TC(BallStealer, thiswep);
}
METHOD(BallStealer, wr_checkammo1, bool(BallStealer this, entity actor, .entity weaponentity))
int slot = weaponslot(weaponentity);
ATTACK_FINISHED(actor, slot) = time + WEP_CVAR_PRI(hagar, refire) * W_WeaponRateFactor(actor);
- int theframe = WFRAME_FIRE1;
+ WFRAME theframe = WFRAME_FIRE1;
entity this = actor.(weaponentity);
if(this)
{
#define ACCUMULATE [[accumulate]]
#endif
-#ifndef QCC_SUPPORT_ERASEABLE
- #define ERASEABLE
+#ifndef QCC_SUPPORT_NOERASE
+ #define EXPORT
#else
- #define ERASEABLE [[eraseable]]
+ #define EXPORT [[noerase]]
#endif
#ifndef QCC_SUPPORT_ALIAS
#ifdef MENUQC
void _m_init();
- void m_init() { if (_m_init) _m_init(); }
+ EXPORT void m_init() { if (_m_init) _m_init(); }
#define m_init _m_init
void _m_shutdown();
- void m_shutdown() { if (_m_shutdown) _m_shutdown(); }
+ EXPORT void m_shutdown() { if (_m_shutdown) _m_shutdown(); }
#define m_shutdown _m_shutdown
void _m_draw(float width, float height);
- void m_draw(float width, float height) { if (_m_draw) _m_draw(width, height); }
+ EXPORT void m_draw(float width, float height) { if (_m_draw) _m_draw(width, height); }
#define m_draw _m_draw
void _m_keydown(int keynr, int ascii);
- void m_keydown(int keynr, int ascii) { if (_m_keydown) _m_keydown(keynr, ascii); }
+ EXPORT void m_keydown(int keynr, int ascii) { if (_m_keydown) _m_keydown(keynr, ascii); }
#define m_keydown _m_keydown
void _m_toggle(int mode);
- void m_toggle(int mode) { if (_m_toggle) _m_toggle(mode); }
+ EXPORT void m_toggle(int mode) { if (_m_toggle) _m_toggle(mode); }
#define m_toggle _m_toggle
#endif
#ifdef SVQC
void _main();
- void main() { if (_main) _main(); }
+ EXPORT void main() { if (_main) _main(); }
#define main _main
void _SV_Shutdown();
- void SV_Shutdown() { if (_SV_Shutdown) _SV_Shutdown(); }
+ EXPORT void SV_Shutdown() { if (_SV_Shutdown) _SV_Shutdown(); }
#define SV_Shutdown _SV_Shutdown
void _StartFrame();
bool _StartFrame_init;
void spawnfunc_worldspawn(entity);
- void StartFrame() {
+ EXPORT void StartFrame() {
if (!_StartFrame_init) {
_StartFrame_init = true;
float oldtime = time; time = 1;
#define StartFrame _StartFrame
void _SetNewParms();
- void SetNewParms() { if (_SetNewParms) _SetNewParms(); }
+ EXPORT void SetNewParms() { if (_SetNewParms) _SetNewParms(); }
#define SetNewParms _SetNewParms
void _SetChangeParms(entity this);
- void SetChangeParms() { ENGINE_EVENT(); if (_SetChangeParms) _SetChangeParms(this); }
+ EXPORT void SetChangeParms() { ENGINE_EVENT(); if (_SetChangeParms) _SetChangeParms(this); }
#define SetChangeParms _SetChangeParms
#ifdef DP_EXT_PRECONNECT
void _ClientPreConnect(entity this);
- void ClientPreConnect() { ENGINE_EVENT(); if (_ClientPreConnect) _ClientPreConnect(this); }
+ EXPORT void ClientPreConnect() { ENGINE_EVENT(); if (_ClientPreConnect) _ClientPreConnect(this); }
#define ClientPreConnect _ClientPreConnect
#endif
void _ClientConnect(entity this);
- void ClientConnect() { ENGINE_EVENT(); if (_ClientConnect) _ClientConnect(this); }
+ EXPORT void ClientConnect() { ENGINE_EVENT(); if (_ClientConnect) _ClientConnect(this); }
#define ClientConnect _ClientConnect
void _ClientDisconnect(entity this);
- void ClientDisconnect() { ENGINE_EVENT(); if (_ClientDisconnect) _ClientDisconnect(this); }
+ EXPORT void ClientDisconnect() { ENGINE_EVENT(); if (_ClientDisconnect) _ClientDisconnect(this); }
#define ClientDisconnect _ClientDisconnect
void _PutClientInServer(entity this);
- void PutClientInServer() { ENGINE_EVENT(); if (_PutClientInServer) _PutClientInServer(this); }
+ EXPORT void PutClientInServer() { ENGINE_EVENT(); if (_PutClientInServer) _PutClientInServer(this); }
#define PutClientInServer _PutClientInServer
void _ClientKill(entity this);
- void ClientKill() { ENGINE_EVENT(); if (_ClientKill) _ClientKill(this); }
+ EXPORT void ClientKill() { ENGINE_EVENT(); if (_ClientKill) _ClientKill(this); }
#define ClientKill _ClientKill
void _PlayerPreThink(entity this);
- void PlayerPreThink() { ENGINE_EVENT(); if (_PlayerPreThink) _PlayerPreThink(this); }
+ EXPORT void PlayerPreThink() { ENGINE_EVENT(); if (_PlayerPreThink) _PlayerPreThink(this); }
#define PlayerPreThink _PlayerPreThink
void _PlayerPostThink(entity this);
- void PlayerPostThink() { ENGINE_EVENT(); if (_PlayerPostThink) _PlayerPostThink(this); }
+ EXPORT void PlayerPostThink() { ENGINE_EVENT(); if (_PlayerPostThink) _PlayerPostThink(this); }
#define PlayerPostThink _PlayerPostThink
void _SV_PlayerPhysics(entity this);
- void SV_PlayerPhysics() { ENGINE_EVENT(); if (_SV_PlayerPhysics) _SV_PlayerPhysics(this); }
+ EXPORT void SV_PlayerPhysics() { ENGINE_EVENT(); if (_SV_PlayerPhysics) _SV_PlayerPhysics(this); }
#define SV_PlayerPhysics _SV_PlayerPhysics
void _SV_OnEntityPreSpawnFunction(entity this);
- void SV_OnEntityPreSpawnFunction()
+ EXPORT void SV_OnEntityPreSpawnFunction()
{
ENGINE_EVENT();
__spawnfunc_expecting = true;
#define SV_OnEntityPreSpawnFunction _SV_OnEntityPreSpawnFunction
void _SV_ChangeTeam(entity this, int _color);
- void SV_ChangeTeam(int _color) { ENGINE_EVENT(); if (_SV_ChangeTeam) _SV_ChangeTeam(this, _color); }
+ EXPORT void SV_ChangeTeam(int _color) { ENGINE_EVENT(); if (_SV_ChangeTeam) _SV_ChangeTeam(this, _color); }
#define SV_ChangeTeam _SV_ChangeTeam
void _SV_ParseClientCommand(entity this, string command);
- void SV_ParseClientCommand(string command)
+ EXPORT void SV_ParseClientCommand(string command)
{
ENGINE_EVENT();
if (_SV_ParseClientCommand) _SV_ParseClientCommand(this, command);
#ifdef CSQC
void _CSQC_Init();
- void CSQC_Init() { if (_CSQC_Init) _CSQC_Init(); }
+ EXPORT void CSQC_Init() { if (_CSQC_Init) _CSQC_Init(); }
#define CSQC_Init _CSQC_Init
void _CSQC_Shutdown();
- void CSQC_Shutdown() { if (_CSQC_Shutdown) _CSQC_Shutdown(); }
+ EXPORT void CSQC_Shutdown() { if (_CSQC_Shutdown) _CSQC_Shutdown(); }
#define CSQC_Shutdown _CSQC_Shutdown
void _CSQC_UpdateView(entity this, float w, float h);
- void CSQC_UpdateView(float w, float h) { ENGINE_EVENT(); if (_CSQC_UpdateView) _CSQC_UpdateView(this, w, h); }
+ EXPORT void CSQC_UpdateView(float w, float h) { ENGINE_EVENT(); if (_CSQC_UpdateView) _CSQC_UpdateView(this, w, h); }
#define CSQC_UpdateView _CSQC_UpdateView
bool _CSQC_InputEvent(int inputType, float nPrimary, float nSecondary);
- bool CSQC_InputEvent(int inputType, float nPrimary, float nSecondary)
+ EXPORT bool CSQC_InputEvent(int inputType, float nPrimary, float nSecondary)
{
return _CSQC_InputEvent ? _CSQC_InputEvent(inputType, nPrimary, nSecondary) : false;
}
#define CSQC_InputEvent _CSQC_InputEvent
bool _CSQC_ConsoleCommand(string s);
- bool CSQC_ConsoleCommand(string s) { return _CSQC_ConsoleCommand ? _CSQC_ConsoleCommand(s) : false; }
+ EXPORT bool CSQC_ConsoleCommand(string s) { return _CSQC_ConsoleCommand ? _CSQC_ConsoleCommand(s) : false; }
#define CSQC_ConsoleCommand _CSQC_ConsoleCommand
void _CSQC_Ent_Update(entity this, bool isNew);
- void CSQC_Ent_Update(bool isNew) { ENGINE_EVENT(); if (_CSQC_Ent_Update) _CSQC_Ent_Update(this, isNew); }
+ EXPORT void CSQC_Ent_Update(bool isNew) { ENGINE_EVENT(); if (_CSQC_Ent_Update) _CSQC_Ent_Update(this, isNew); }
#define CSQC_Ent_Update _CSQC_Ent_Update
void _CSQC_Ent_Remove(entity this);
- void CSQC_Ent_Remove() { ENGINE_EVENT(); if (_CSQC_Ent_Remove) _CSQC_Ent_Remove(this); }
+ EXPORT void CSQC_Ent_Remove() { ENGINE_EVENT(); if (_CSQC_Ent_Remove) _CSQC_Ent_Remove(this); }
#define CSQC_Ent_Remove _CSQC_Ent_Remove
#endif
#undef ENGINE_EVENT
/*
* Return a angle within +/- 360.
*/
-ERASEABLE
float anglemods(float v)
{
v = v - 360 * floor(v / 360);
/*
* Return the short angle
*/
-ERASEABLE
float shortangle_f(float ang1, float ang2)
{
if(ang1 > ang2)
return ang1;
}
-ERASEABLE
vector shortangle_v(vector ang1, vector ang2)
{
vector vtmp;
return vtmp;
}
-ERASEABLE
vector shortangle_vxy(vector ang1, vector ang2)
{
vector vtmp = '0 0 0';
* Return the angle offset between angle ang and angle of the vector from->to
*/
-ERASEABLE
vector angleofs3(vector from, vector ang, vector to)
{
vector v_res;
#define BITSET(var, mask, flag) ((var) ^ (-(flag) ^ (var)) & (mask))
#endif
-ERASEABLE
int lowestbit(int f)
{
f &= ~(f << 1);
return f;
}
-ERASEABLE
int randombit(int bits)
{
if (!(bits & (bits - 1))) // this ONLY holds for powers of two!
return b;
}
-ERASEABLE
int randombits(int bits, int k, bool error_return)
{
int r = 0;
OP_MINUS
};
-ERASEABLE
bool GiveBit(entity e, .int fld, int bit, int op, int val)
{
int v0 = (e.(fld) & bit);
return v0 != v1;
}
-ERASEABLE
bool GiveValue(entity e, .int fld, int op, int val)
{
int v0 = e.(fld);
#define boolean(value) ((value) != 0)
// get true/false value of a string with multiple different inputs
-ERASEABLE
float InterpretBoolean(string input)
{
switch (strtolower(input))
#include "string.qh"
#define colormapPaletteColor(c, isPants) colormapPaletteColor_(c, isPants, time)
-ERASEABLE
vector colormapPaletteColor_(int c, bool isPants, float t)
{
switch (c)
}
}
-ERASEABLE
float rgb_mi_ma_to_hue(vector rgb, float mi, float ma)
{
if (mi == ma)
}
}
-ERASEABLE
vector hue_mi_ma_to_rgb(float hue, float mi, float ma)
{
vector rgb;
return rgb;
}
-ERASEABLE
vector rgb_to_hsv(vector rgb)
{
float mi, ma;
return hsv;
}
-ERASEABLE
vector hsv_to_rgb(vector hsv)
{
return hue_mi_ma_to_rgb(hsv.x, hsv.z * (1 - hsv.y), hsv.z);
}
-ERASEABLE
vector rgb_to_hsl(vector rgb)
{
float mi, ma;
return hsl;
}
-ERASEABLE
vector hsl_to_rgb(vector hsl)
{
float mi, ma, maminusmi;
return hue_mi_ma_to_rgb(hsl.x, mi, ma);
}
-ERASEABLE
string rgb_to_hexcolor(vector rgb)
{
return strcat(
#endif
#endif
-#ifndef QCC_SUPPORT_ERASEABLE
+#ifndef QCC_SUPPORT_NOERASE
#ifdef GMQCC
- #define QCC_SUPPORT_ERASEABLE
+ #define QCC_SUPPORT_NOERASE
#endif
#endif
_("CI_THI^%d seconds"), /* third */ \
_("CI_MUL^%d seconds")) /* multi */
-ERASEABLE
string count_ordinal(int interval)
{
// This function is designed primarily for the English language, it's impossible
return "";
}
-ERASEABLE
string count_fill(float interval, string zeroth, string first, string second, string third, string multi)
{
// This function is designed primarily for the English language, it's impossible
return "";
}
-ERASEABLE
string process_time(float outputtype, float seconds)
{
float tmp_hours = 0, tmp_minutes = 0, tmp_seconds = 0;
#include "progname.qh"
#include "static.qh"
-ERASEABLE
void RegisterCvars(void(string name, string def, string desc, bool archive, string file) f) {}
-ERASEABLE
bool cvar_value_issafe(string s)
{
if (strstrofs(s, "\"", 0) >= 0) return false;
}
/** escape the string to make it safe for consoles */
-ERASEABLE
string MakeConsoleSafe(string input)
{
input = strreplace("\n", "", input);
return input;
}
-ERASEABLE
void cvar_describe(string name, string desc)
{
localcmd(sprintf("\nset %1$s \"$%1$s\" \"%2$s\"\n", name, MakeConsoleSafe(desc)));
}
-ERASEABLE
void cvar_archive(string name)
{
localcmd(sprintf("\nseta %1$s \"$%1$s\"\n", name));
}
-ERASEABLE
void RegisterCvars_Set(string name, string def, string desc, bool archive, string file)
{
cvar_describe(name, desc);
}
int RegisterCvars_Save_fd;
-ERASEABLE
void RegisterCvars_Save(string name, string def, string desc, bool archive, string file)
{
if (!archive) return;
}
}
- ERASEABLE
void drawstringright(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
{
position.x -= 2 / 3 * strlen(text) * theScale.x;
drawstring_builtin(position, text, theScale, rgb, theAlpha, flag);
}
- ERASEABLE
void drawstringcenter(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
{
position.x = 0.5 * (vid_conwidth - 0.6025 * strlen(text) * theScale.x);
#pragma once
-ERASEABLE
bool fexists(string f)
{
int fh = fopen(f, FILE_READ);
/**
* @deprecated prefer _("translated")
*/
-ERASEABLE
string language_filename(string s)
{
string fn = prvm_language;
}
#endif
-ERASEABLE
string CTX(string s)
{
#if CTX_CACHE
const int IL_MAX = 128;
-ERASEABLE
void IL_INIT(entity this);
-ERASEABLE
void IL_DTOR(entity this);
-ERASEABLE
void IL_ENDFRAME();
/**
#define IL_LAST(this) (this.il_tail)
#define IL_PEEK(this) (this.il_tail)
-ERASEABLE
bool IL_CONTAINS(IntrusiveList this, entity it)
{
assert(this, return false);
/**
* Push to tail
*/
-ERASEABLE
entity IL_PUSH(IntrusiveList this, entity it)
{
assert(this, return NULL);
/**
* Push to head
*/
-ERASEABLE
entity IL_UNSHIFT(IntrusiveList this, entity it)
{
assert(this, return NULL);
/**
* Pop from tail
*/
-ERASEABLE
entity IL_POP(IntrusiveList this)
{
assert(this, return NULL);
/**
* Pop from head
*/
-ERASEABLE
entity IL_SHIFT(IntrusiveList this)
{
assert(this, return NULL);
/**
* Remove any element, anywhere in the list
*/
-ERASEABLE
void IL_REMOVE(IntrusiveList this, entity it)
{
assert(this, return);
#define IL_LISTS_PER_BIT IL_CEIL(IL_MAX / (3 * 24))
-ERASEABLE
void IL_INIT(IntrusiveList this)
{
.entity nextfld, prevfld;
LOG_WARNF("IntrusiveList overflow");
}
-ERASEABLE
void IL_DTOR(IntrusiveList this)
{
IL_CLEAR(this);
il_links[this.il_id] = NULL;
}
-ERASEABLE
void IL_ENDFRAME()
{
#if 0
#endif
}
-ERASEABLE
void ONREMOVE(entity this)
{
if (this.il_lists) {
// Current keys
int _json_keys;
-ERASEABLE
bool _json_parse_object() {
JSON_BEGIN();
if (STRING_ITERATOR_GET(_json) != '{') JSON_FAIL("expected '{'");
JSON_END();
}
- ERASEABLE
bool _json_parse_members() {
JSON_BEGIN();
for (;;) {
JSON_END();
}
- ERASEABLE
bool _json_parse_pair() {
JSON_BEGIN();
if (!_json_parse_string(false)) JSON_FAIL("expected string");
JSON_END();
}
-ERASEABLE
bool _json_parse_array() {
JSON_BEGIN();
if (STRING_ITERATOR_GET(_json) != '[') JSON_FAIL("expected '['");
JSON_END();
}
-ERASEABLE
bool _json_parse_value() {
JSON_BEGIN();
if (!(_json_parse_string(true)
JSON_END();
}
- ERASEABLE
bool _json_parse_true() {
JSON_BEGIN();
if (!(STRING_ITERATOR_GET(_json) == 't'
JSON_END();
}
- ERASEABLE
bool _json_parse_false() {
JSON_BEGIN();
if (!(STRING_ITERATOR_GET(_json) == 'f'
JSON_END();
}
- ERASEABLE
bool _json_parse_null() {
JSON_BEGIN();
if (!(STRING_ITERATOR_GET(_json) == 'n'
JSON_END();
}
-ERASEABLE
bool _json_parse_string(bool add) {
JSON_BEGIN();
if (STRING_ITERATOR_GET(_json) != '"') JSON_FAIL("expected opening '\"'");
JSON_END();
}
-ERASEABLE
bool _json_parse_number() {
JSON_BEGIN();
if (!(_json_parse_float() || _json_parse_int())) JSON_FAIL("expected number");
JSON_END();
}
- ERASEABLE
bool _json_parse_float() {
JSON_BEGIN();
string s = "";
JSON_END();
}
- ERASEABLE
bool _json_parse_int() {
JSON_BEGIN();
string s = "";
JSON_END();
}
-ERASEABLE
int json_parse(string in, bool() func) {
string trimmed = "";
LABEL(trim) {
return _json_buffer;
}
-ERASEABLE
string json_get(int buf, string key)
{
for (int i = 1, n = buf_getsize(buf); i < n; i += 2) {
return string_null;
}
-ERASEABLE
void json_del(int buf)
{
buf_del(buf);
}
-ERASEABLE
void json_dump(int buf)
{
for (int i = 0, n = buf_getsize(buf); i < n; ++i) {
// Databases (hash tables)
const int DB_BUCKETS = 8192;
-ERASEABLE
void db_save(int db, string filename)
{
int fh = fopen(filename, FILE_WRITE);
USING(HashMap, int);
-ERASEABLE
int db_create()
{
return buf_create();
}
#define HM_NEW(this) (this = db_create())
-ERASEABLE
void db_put(int db, string key, string value);
-ERASEABLE
int db_load(string filename)
{
int db = buf_create();
return db;
}
-ERASEABLE
void db_dump(int db, string filename)
{
int fh = fopen(filename, FILE_WRITE);
fclose(fh);
}
-ERASEABLE
void db_close(int db)
{
buf_del(db);
}
#define HM_DELETE(this) db_close(this)
-ERASEABLE
string db_get(int db, string key)
{
int h = crc16(false, key) % DB_BUCKETS;
#define db_remove(db, key) db_put(db, key, "")
-ERASEABLE
void db_put(int db, string key, string value)
{
int h = crc16(false, key) % DB_BUCKETS;
* - two spaces escape a linebreak (otherwise text wraps)
* - two linebreaks become a paragraph (remain unchanged)
*/
-ERASEABLE
string markdown(string s)
{
string buf = "";
#include "lib/float.qh"
-ERASEABLE
void mean_accumulate(entity e, .float a, .float c, float mean, float value, float weight)
{
if (weight == 0) return;
e.(c) += weight;
}
-ERASEABLE
float mean_evaluate(entity e, .float a, .float c, float mean)
{
if (e.(c) == 0) return 0;
*/
-ERASEABLE
float angc(float a1, float a2)
{
while (a1 > 180)
return a;
}
-ERASEABLE
float fsnap(float val, float fsize)
{
return rint(val / fsize) * fsize;
}
-ERASEABLE
vector vsnap(vector point, float fsize)
{
vector vret;
return vret;
}
-ERASEABLE
vector lerpv(float t0, vector v0, float t1, vector v1, float t)
{
return v0 + (v1 - v0) * ((t - t0) / (t1 - t0));
}
-ERASEABLE
vector bezier_quadratic_getpoint(vector a, vector b, vector c, float t)
{
return (c - 2 * b + a) * (t * t)
+ a;
}
-ERASEABLE
vector bezier_quadratic_getderivative(vector a, vector b, vector c, float t)
{
return (c - 2 * b + a) * (2 * t)
+ (b - a) * 2;
}
-ERASEABLE
float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float spd)
{
return (((startspeedfactor + endspeedfactor - 2
) * spd;
}
-ERASEABLE
bool cubic_speedfunc_is_sane(float startspeedfactor, float endspeedfactor)
{
if (startspeedfactor < 0 || endspeedfactor < 0) return false;
}
/** continuous function mapping all reals into -1..1 */
-ERASEABLE
float float2range11(float f)
{
return f / (fabs(f) + 1);
}
/** continuous function mapping all reals into 0..1 */
-ERASEABLE
float float2range01(float f)
{
return 0.5 + 0.5 * float2range11(f);
}
-ERASEABLE
float median(float a, float b, float c)
{
return (a < c) ? bound(a, b, c) : bound(c, b, a);
}
-ERASEABLE
float almost_equals(float a, float b)
{
float eps = (max(a, -a) + max(b, -b)) * 0.001;
return a - b < eps && b - a < eps;
}
-ERASEABLE
float almost_equals_eps(float a, float b, float times_eps)
{
float eps = max(fabs(a), fabs(b)) * FLOAT_EPSILON * times_eps;
return a - b < eps && b - a < eps;
}
-ERASEABLE
float almost_in_bounds(float a, float b, float c)
{
float eps = (max(a, -a) + max(c, -c)) * 0.001;
return b == median(a - eps, b, c + eps);
}
-ERASEABLE
float ExponentialFalloff(float mindist, float maxdist, float halflifedist, float d)
{
if (halflifedist > 0) return (0.5 ** ((bound(mindist, d, maxdist) - mindist) / halflifedist));
#define power2of(e) (2 ** e)
-ERASEABLE
float log2of(float e)
{
// NOTE: generated code
}
/** ax^2 + bx + c = 0 */
-ERASEABLE
vector solve_quadratic(float a, float b, float c)
{
vector v;
/// src_min and src_max must not be the same or division by zero occurs.
///
/// dest_max can be smaller than dest_min if you want the resulting range to be inverted, all values can be negative.
-ERASEABLE
float map_ranges(float value, float src_min, float src_max, float dest_min, float dest_max) {
float src_diff = src_max - src_min;
float dest_diff = dest_max - dest_min;
}
/// Same as `map_ranges` except that values outside the source range are clamped to min or max.
-ERASEABLE
float map_bound_ranges(float value, float src_min, float src_max, float dest_min, float dest_max) {
if (value <= src_min) return dest_min;
if (value >= src_max) return dest_max;
classfield(Noise).float noise_paccum3;
classfield(Noise).float noise_bstate;
-ERASEABLE
float Noise_Brown(entity e, float dt)
{
e.noise_baccum += random() * sqrt(dt); // same stddev for all dt
return e.noise_baccum;
}
-ERASEABLE
float Noise_Pink(entity e, float dt)
{
float f;
if (random() > (0.9613 ** f)) e.noise_paccum3 = 0.43488 * (2 * random() - 1);
return e.noise_paccum + e.noise_paccum2 + e.noise_paccum3;
}
-ERASEABLE
float Noise_White(entity e, float dt)
{
return random() * 2 - 1;
}
/** +1 or -1 */
-ERASEABLE
float Noise_Burst(entity e, float dt, float p)
{
if (random() > (p ** dt)) e.noise_bstate = !e.noise_bstate;
#define DEBUG_STUFF(cname)
#else
#define DEBUG_STUFF(cname) \
- ERASEABLE bool is_##cname(entity e) { return e.instanceOf##cname; } \
- ERASEABLE void isnt_##cname(entity e) { eprint(e); }
+ bool is_##cname(entity e) { return e.instanceOf##cname; } \
+ void isnt_##cname(entity e) { eprint(e); }
#endif
#define METHOD_REFERENCE(cname, name) \
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-ERASEABLE
vector vec_bias(vector v, float f)
{
vector c;
c.z = v.z + f;
return c;
}
-ERASEABLE
vector vec_to_min(vector a, vector b)
{
vector c;
return c;
}
-ERASEABLE
vector vec_to_max(vector a, vector b)
{
vector c;
}
// there may already be a function for bounding a vector in this manner, however my very quick search did not reveal one -- Player_2
-ERASEABLE
vector vec_bounds_in(vector point, vector a, vector b)
{
vector d = vec_to_min(a, b);
return c;
}
-ERASEABLE
vector vec_bounds_out(vector point, vector a, vector b)
{
vector d = vec_to_max(a, b);
return c;
}
-ERASEABLE
float angle_snap_f(float f, float increment)
{
for (int j = 0; j <= 360; )
return 0;
}
-ERASEABLE
vector angle_snap_vec(vector v, float increment)
{
vector c;
return c;
}
-ERASEABLE
vector aim_vec(vector org, vector targ)
{
vector v;
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-ERASEABLE
vector vec_bias(vector v, float f);
-ERASEABLE
vector vec_to_min(vector a, vector b);
-ERASEABLE
vector vec_to_max(vector a, vector b);
// there may already be a function for bounding a vector in this manner, however my very quick search did not reveal one -- Player_2
-ERASEABLE
vector vec_bounds_in(vector point, vector a, vector b);
-ERASEABLE
vector vec_bounds_out(vector point, vector a, vector b);
-ERASEABLE
float angle_snap_f(float f, float increment);
-ERASEABLE
vector angle_snap_vec(vector v, float increment);
-ERASEABLE
vector aim_vec(vector org, vector targ);
#include "random.qh"
-ERASEABLE
void RandomSelection_Init()
{
RandomSelection_totalweight = 0;
RandomSelection_best_priority = -1;
}
-ERASEABLE
void RandomSelection_Add(entity e, float f, string s, vector v, float weight, float priority)
{
if (priority > RandomSelection_best_priority)
float DistributeEvenly_amount;
float DistributeEvenly_totalweight;
-ERASEABLE
void DistributeEvenly_Init(float amount, float totalweight)
{
if (DistributeEvenly_amount)
DistributeEvenly_totalweight = totalweight;
}
-ERASEABLE
float DistributeEvenly_Get(float weight)
{
float f;
return f;
}
-ERASEABLE
float DistributeEvenly_GetRandomized(float weight)
{
float f;
// from the GNU Scientific Library
float gsl_ran_gaussian_lastvalue;
float gsl_ran_gaussian_lastvalue_set;
-ERASEABLE
float gsl_ran_gaussian(float sigma)
{
if (gsl_ran_gaussian_lastvalue_set)
string RandomSelection_chosen_string;
vector RandomSelection_chosen_vec;
-ERASEABLE
void RandomSelection_Init();
-ERASEABLE
void RandomSelection_Add(entity e, float f, string s, vector v, float weight, float priority);
#define RandomSelection_AddEnt(e, weight, priority) RandomSelection_Add(e, 0, string_null, '0 0 0', weight, priority)
#define RandomSelection_AddFloat(f, weight, priority) RandomSelection_Add(NULL, f, string_null, '0 0 0', weight, priority)
#define REGISTRY_HASH(id) Registry_hash_##id
-ERASEABLE
ACCUMULATE void Registry_check(string r, string server) { }
-ERASEABLE
ACCUMULATE void Registry_send_all() { }
#ifdef SVQC
/** <0 for <, ==0 for ==, >0 for > (like strcmp) */
USING(comparefunc_t, int (int i1, int i2, entity pass));
-ERASEABLE
void heapsort(int n, swapfunc_t swap, comparefunc_t cmp, entity pass)
{
#define heapify(_count) \
}
}
-ERASEABLE
void shuffle(float n, swapfunc_t swap, entity pass)
{
for (int i = 1; i < n; ++i)
#include "sortlist.qh"
-ERASEABLE
entity Sort_Spawn()
{
entity sort = new_pure(sortlist);
#pragma once
/** If this global exists, only functions with spawnfunc_ name prefix qualify as spawn functions */
-noref bool require_spawnfunc_prefix;
+EXPORT noref bool require_spawnfunc_prefix;
.bool spawnfunc_checked;
// Optional type checking; increases compile time too much to be enabled by default
#define spawnfunc_1(id) spawnfunc_2(id, FIELDS_UNION)
#define spawnfunc_2(id, whitelist) \
void __spawnfunc_##id(entity this); \
- ACCUMULATE void spawnfunc_##id(entity this) \
+ EXPORT ACCUMULATE void spawnfunc_##id(entity this) \
{ \
if (!__spawnfunc_first) { \
__spawnfunc_first = true; \
float(int tmr) _gettime = #519;
#endif
-ERASEABLE
void profile(string s)
{
static float g_starttime;
this = string_null; \
MACRO_END
-ERASEABLE
string seconds_tostring(float sec)
{
float minutes = floor(sec / 60);
return sprintf("%d:%02d", minutes, sec);
}
-ERASEABLE
string format_time(float seconds)
{
seconds = floor(seconds + 0.5);
else return sprintf(_("%02d:%02d:%02d"), hours, minutes, seconds);
}
-ERASEABLE
string mmsss(float tenths)
{
tenths = floor(tenths + 0.5);
return strcat(ftos(minutes), ":", substring(s, 1, 2), ".", substring(s, 3, 1));
}
-ERASEABLE
string mmssss(float hundredths)
{
hundredths = floor(hundredths + 0.5);
int ColorTranslateMode;
-ERASEABLE
string ColorTranslateRGB(string s)
{
return (ColorTranslateMode & 1) ? strdecolorize(s) : s;
#define startsWith(haystack, needle) (strstrofs(haystack, needle, 0) == 0)
-ERASEABLE
bool startsWithNocase(string haystack, string needle)
{
return strcasecmp(substring(haystack, 0, strlen(needle)), needle) == 0;
#define endsWith(this, suffix) (_endsWith_suffix = suffix, substring(this, -strlen(_endsWith_suffix), -1) == _endsWith_suffix)
/** unzone the string, and return it as tempstring. Safe to be called on string_null */
-ERASEABLE
string fstrunzone(string s)
{
if (!s) return s;
}
/** returns first word */
-ERASEABLE
string car(string s)
{
int o = strstrofs(s, " ", 0);
}
/** returns all but first word */
-ERASEABLE
string cdr(string s)
{
int o = strstrofs(s, " ", 0);
return substring(s, o + 1, strlen(s) - (o + 1));
}
-ERASEABLE
string cons(string a, string b)
{
if (a == "") return b;
return strcat(a, " ", b);
}
-ERASEABLE
string cons_mid(string a, string mid, string b)
{
if (a == "") return b;
return strcat(a, mid, b);
}
-ERASEABLE
string substring_range(string s, float b, float e)
{
return substring(s, b, e - b);
}
-ERASEABLE
string swapwords(string str, float i, float j)
{
float n;
}
string _shufflewords_str;
-ERASEABLE
void _shufflewords_swapfunc(float i, float j, entity pass)
{
_shufflewords_str = swapwords(_shufflewords_str, i, j);
}
-ERASEABLE
string shufflewords(string str)
{
_shufflewords_str = str;
return str;
}
-ERASEABLE
string unescape(string in)
{
in = strzone(in); // but it doesn't seem to be necessary in my tests at least
return str;
}
-ERASEABLE
string strwords(string s, int w)
{
int endpos = 0;
#define strhasword(s, w) (strstrofs(strcat(" ", s, " "), strcat(" ", w, " "), 0) >= 0)
-ERASEABLE
int u8_strsize(string s)
{
int l = 0;
}
//List of Unicode spaces: https://www.cs.tut.fi/~jkorpela/chars/spaces.html
-ERASEABLE
bool isInvisibleString(string s)
{
s = strdecolorize(s);
// Multiline text file buffers
-ERASEABLE
int buf_load(string pFilename)
{
int buf = buf_create();
return buf;
}
-ERASEABLE
void buf_save(float buf, string pFilename)
{
int fh = fopen(pFilename, FILE_WRITE);
/**
* converts a number to a string with the indicated number of decimals
*/
-ERASEABLE
string ftos_decimals(float number, int decimals)
{
// inhibit stupid negative zero
/**
* converts a number to a string with the minimum number of decimals
*/
-ERASEABLE
string ftos_mindecimals(float number)
{
// inhibit stupid negative zero
return sprintf("%.7g", number);
}
-ERASEABLE
int vercmp_recursive(string v1, string v2)
{
int dot1 = strstrofs(v1, ".", 0);
else return (dot2 == -1) ? 1 : vercmp_recursive(substring(v1, dot1 + 1, 999), substring(v2, dot2 + 1, 999));
}
-ERASEABLE
int vercmp(string v1, string v2)
{
if (strcasecmp(v1, v2) == 0) return 0; // early out check
entity url_fromid[NUM_URL_ID];
int autocvar__urllib_nextslot;
-ERASEABLE
float url_URI_Get_Callback(int id, float status, string data)
{
if (id < MIN_URL_ID) return 0;
}
}
-ERASEABLE
void url_single_fopen(string url, int mode, url_ready_func rdy, entity pass)
{
entity e;
}
// close a file
-ERASEABLE
void url_fclose(entity e)
{
int i;
}
// with \n (blame FRIK_FILE)
-ERASEABLE
string url_fgets(entity e)
{
if (e.url_fh == URL_FH_CURL)
}
// without \n (blame FRIK_FILE)
-ERASEABLE
void url_fputs(entity e, string s)
{
if (e.url_fh == URL_FH_CURL)
}
// multi URL object, tries URLs separated by space in sequence
-ERASEABLE
void url_multi_ready(entity fh, entity me, float status)
{
float n;
me.url_ready(fh, me.url_ready_pass, status);
}
-ERASEABLE
void url_multi_fopen(string url, int mode, url_ready_func rdy, entity pass)
{
float n;
// errors: -1, or negative HTTP status code
USING(url_ready_func, void (entity handle, entity pass, float status));
-ERASEABLE
void url_single_fopen(string url, float mode, url_ready_func rdy, entity pass);
-ERASEABLE
void url_fclose(entity e);
-ERASEABLE
string url_fgets(entity e);
-ERASEABLE
void url_fputs(entity e, string s);
// returns true if handled
-ERASEABLE
float url_URI_Get_Callback(int id, float status, string data);
#define MIN_URL_ID URI_GET_URLLIB
#define NUM_URL_ID (URI_GET_URLLIB_END - URI_GET_URLLIB + 1)
-ERASEABLE
void url_multi_fopen(string url, float mode, url_ready_func rdy, entity pass);
#if 1
#define cross(a, b) ((a) >< (b))
#else
-ERASEABLE
vector cross(vector a, vector b)
{
return
const vector eY = '0 1 0';
const vector eZ = '0 0 1';
-ERASEABLE
vector randompos(vector m1, vector m2)
{
vector v;
return v;
}
-ERASEABLE
float vlen_maxnorm2d(vector v)
{
return max(v.x, v.y, -v.x, -v.y);
}
-ERASEABLE
float vlen_minnorm2d(vector v)
{
return min(max(v.x, -v.x), max(v.y, -v.y));
}
-ERASEABLE
float dist_point_line(vector p, vector l0, vector ldir)
{
ldir = normalize(ldir);
}
/** requires that m2>m1 in all coordinates, and that m4>m3 */
-ERASEABLE
float boxesoverlap(vector m1, vector m2, vector m3, vector m4) { return m2_x >= m3_x && m1_x <= m4_x && m2_y >= m3_y && m1_y <= m4_y && m2_z >= m3_z && m1_z <= m4_z; }
/** requires the same as boxesoverlap, but is a stronger condition */
-ERASEABLE
float boxinsidebox(vector smins, vector smaxs, vector bmins, vector bmaxs) { return smins.x >= bmins.x && smaxs.x <= bmaxs.x && smins.y >= bmins.y && smaxs.y <= bmaxs.y && smins.z >= bmins.z && smaxs.z <= bmaxs.z; }
#define PITCH(v) ((v).x)
noref vector _vec3;
#define vec3(_x, _y, _z) (_vec3.x = (_x), _vec3.y = (_y), _vec3.z = (_z), _vec3)
-ERASEABLE
vector Rotate(vector v, float a)
{
float a_sin = sin(a), a_cos = cos(a);
* @param norm the normalized normal
* @returns dir reflected by norm
*/
-ERASEABLE
vector reflect(vector dir, vector norm)
{
return dir - 2 * (dir * norm) * norm;
/**
* clip vel along the plane defined by norm (assuming 0 distance away), bounciness determined by bounce 0..1
*/
-ERASEABLE
vector vec_reflect(vector vel, vector norm, float bounce)
{
return vel - (1 + bounce) * (vel * norm) * norm;
}
-ERASEABLE
vector vec_epsilon(vector this, float eps)
{
if (this.x > -eps && this.x < eps) this.x = 0;
(out = vec_epsilon(vec_reflect(in, normal, (overbounce) - 1), 0.1))
#ifdef GAMEQC
- ERASEABLE
vector get_corner_position(entity box, int corner)
{
switch (corner)
}
}
- ERASEABLE
vector NearestPointOnBox(entity box, vector org)
{
vector m1 = box.mins + box.origin;
float updateConwidths(float width, float height, float pixelheight);
-void GameCommand(string theCommand)
+EXPORT void GameCommand(string theCommand)
{
int argc = tokenize_console(theCommand);
string ss = strtolower(argv(0));
#pragma once
-void GameCommand(string command);
+EXPORT void GameCommand(string command);
if (Menu_Active) m_display(); // delayed menu display
}
-void m_keyup(float key, float ascii)
+EXPORT void m_keyup(float key, float ascii)
{
if (!menuInitialized) return;
if (!Menu_Active) return;
entity RetrieveCategoryEnt(float catnum);
float CheckCategoryOverride(float cat);
-float m_gethostcachecategory(float entry) { return CheckCategoryOverride(CheckCategoryForEntry(entry)); }
+EXPORT float m_gethostcachecategory(float entry) { return CheckCategoryOverride(CheckCategoryForEntry(entry)); }
// fields for category entities
float _Nex_ExtResponseSystem_PacksStep;
/** engine callback */
-void URI_Get_Callback(float id, float status, string data)
+EXPORT void URI_Get_Callback(float id, float status, string data)
{
if(url_URI_Get_Callback(id, status, data))
{
}
void systems_update();
-void EndFrame()
+EXPORT void EndFrame()
{
anticheat_endframe();
}
void TargetMusic_RestoreGame();
-void RestoreGame()
+EXPORT void RestoreGame()
{
// Loaded from a save game
// some things then break, so let's work around them...
}
/** engine callback */
-void URI_Get_Callback(float id, float status, string data)
+EXPORT void URI_Get_Callback(float id, float status, string data)
{
if(url_URI_Get_Callback(id, status, data))
{
setpause(ispaused);
}
-void SV_PausedTic(float elapsedtime)
+EXPORT void SV_PausedTic(float elapsedtime)
{
if (!server_is_dedicated) Pause_TryPause(false);
}
#define IS_SPEC(v) ((v).classname == STR_SPECTATOR)
#define IS_OBSERVER(v) ((v).classname == STR_OBSERVER)
-#define IS_CLIENT(v) (v.flags & FL_CLIENT)
+#define IS_CLIENT(v) ((v).flags & FL_CLIENT)
/** want: (IS_CLIENT(v) && !IS_REAL_CLIENT(v)) */
#define IS_BOT_CLIENT(v) (clienttype(v) == CLIENTTYPE_BOT)
#define IS_FAKE_CLIENT(v) (clienttype(v) == CLIENTTYPE_NOTACLIENT)
declare -a QCCFLAGS=(
-std=gmqcc
- -Wall -Werror
+ -Ooverlap-locals
+ -Werror
+ -Wall
-futf8
- -freturn-assignments
-frelaxed-switch
- -Ooverlap-locals
+ -freturn-assignments
+ -fdefault-eraseable
)
declare -a NOWARN=(
-Wno-field-redeclared
projects / xonotic / xonotic-data.pk3dir.git / commitdiff