C4Script.cpp

Go to the documentation of this file.

/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 1998-2000, Matthes Bender
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2009-2019, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
 
/* Functions mapped by C4Script */
 
#include "C4Include.h"
 
#include "C4Version.h"
#include "lib/C4Random.h"
#include "script/C4AulExec.h"
#include "script/C4AulDefFunc.h"
#include "script/C4ScriptLibraries.h"
 
//========================== Some Support Functions =======================================
 
StdStrBuf FnStringFormat(C4PropList * _this, C4String *szFormatPar, C4Value * Pars, int ParCount)
{
    int cPar=0;
 
    StdStrBuf StringBuf("", false);
    const char * cpFormat = FnStringPar(szFormatPar);
    const char * cpType;
    char szField[20];
    while (*cpFormat)
    {
        // Copy normal stuff
        while (*cpFormat && (*cpFormat!='%'))
            StringBuf.AppendChar(*cpFormat++);
        // Field
        if (*cpFormat=='%')
        {
            // Scan field type
            for (cpType=cpFormat+1; *cpType && (*cpType == '+' || *cpType == '-' || *cpType == '.' || *cpType == '#' || *cpType == ' ' || Inside(*cpType,'0','9')); cpType++) {}
            // Copy field
            SCopy(cpFormat,szField,std::min<unsigned int>(sizeof szField - 1, cpType - cpFormat + 1));
            // Insert field by type
            switch (*cpType)
            {
                // number
            case 'd': case 'x': case 'X':
            {
                if (cPar >= ParCount) throw C4AulExecError("format placeholder without parameter");
                StringBuf.AppendFormat(szField, Pars[cPar++].getInt());
                cpFormat+=SLen(szField);
                break;
            }
            // character
            case 'c':
            {
                if (cPar >= ParCount) throw C4AulExecError("format placeholder without parameter");
                StringBuf.AppendCharacter(Pars[cPar++].getInt());
                cpFormat+=SLen(szField);
                break;
            }
            // C4ID
            case 'i':
            // C4Value
            case 'v':
            {
                if (cPar >= ParCount) throw C4AulExecError("format placeholder without parameter");
                StringBuf.Append(static_cast<const StdStrBuf&>(Pars[cPar++].GetDataString(10)));
                cpFormat+=SLen(szField);
                break;
            }
            // String
            case 's':
            {
                // get string
                if (cPar >= ParCount) throw C4AulExecError("format placeholder without parameter");
                const char *szStr = "(null)";
                if (Pars[cPar].GetData())
                {
                    C4String * pStr = Pars[cPar].getStr();
                    if (!pStr) throw C4AulExecError("string format placeholder without string");
                    szStr = pStr->GetCStr();
                }
                ++cPar;
                StringBuf.AppendFormat(szField, szStr);
                cpFormat+=SLen(szField);
                break;
            }
            case '%':
                StringBuf.AppendChar('%');
                cpFormat+=SLen(szField);
                break;
                // Undefined / Empty
            default:
                StringBuf.AppendChar('%');
                cpFormat++;
                break;
            }
        }
    }
    return StringBuf;
}
 
C4AulDefFunc::C4AulDefFunc(C4PropListStatic * Parent, C4ScriptFnDef* pDef):
        C4AulFunc(Parent, pDef->Identifier), Def(pDef)
{
    Parent->SetPropertyByS(Name, C4VFunction(this));
}
 
C4AulDefFunc::~C4AulDefFunc() = default;
 
C4Value C4AulDefFunc::Exec(C4PropList * p, C4Value pPars[], bool fPassErrors)
{
    assert(Def->FunctionC4V);
    return Def->FunctionC4V(p, pPars);
}
 
//=============================== C4Script Functions ====================================
 
#define MAKE_AND_RETURN_ARRAY(values) do { \
    C4ValueArray *matrix = new C4ValueArray(sizeof(values) / sizeof(*values)); \
    for (size_t i = 0; i < sizeof(values) / sizeof(*values); ++i) \
        (*matrix)[i] = C4VInt(values[i]); \
    return matrix; \
} while (0)
 
static C4ValueArray *FnTrans_Identity(C4PropList * _this)
{
    long values[] = 
    {
        1000, 0, 0, 0,
        0, 1000, 0, 0,
        0, 0, 1000, 0
    };
    MAKE_AND_RETURN_ARRAY(values);
}
 
static C4ValueArray *FnTrans_Translate(C4PropList * _this, long dx, long dy, long dz)
{
    long values[] = 
    {
        1000, 0, 0, dx,
        0, 1000, 0, dy,
        0, 0, 1000, dz
    };
    MAKE_AND_RETURN_ARRAY(values);
}
 
static C4ValueArray *FnTrans_Scale(C4PropList * _this, long sx, long sy, long sz)
{
    if (sy == 0 && sz == 0)
        sy = sz = sx;
    long values[] = 
    {
        sx, 0, 0, 0,
        0, sy, 0, 0,
        0, 0, sz, 0
    };
    MAKE_AND_RETURN_ARRAY(values);
}
 
static C4ValueArray *FnTrans_Rotate(C4PropList * _this, long angle, long rx, long ry, long rz)
{
    long c = fixtoi(Cos(itofix(angle, 1)), 1000);
    long s = fixtoi(Sin(itofix(angle, 1)), 1000);
 
    long sqrt_val = rx * rx + ry * ry + rz * rz;
    long n = long(sqrt(double(sqrt_val)));
    if (n * n < sqrt_val) n++;
    else if (n * n > sqrt_val) n--;
    
    if (n == 0)
    {
        throw C4AulExecError("cannot rotate around a null vector");
    }
 
    rx = (1000 * rx) / n;
    ry = (1000 * ry) / n;
    rz = (1000 * rz) / n;
 
    long values[] = 
    {
        rx*rx*(1000-c)/1000000+c, rx*ry*(1000-c)/1000000-rz*s/1000, rx*rz*(1000-c)/1000000+ry*s/1000, 0,
        ry*rx*(1000-c)/1000000+rz*s/1000, ry*ry*(1000-c)/1000000+c, ry*rz*(1000-c)/1000000-rx*s/1000, 0,
        rz*rx*(1000-c)/1000000-ry*s/1000, ry*rz*(1000-c)/1000000+rx*s/1000, rz*rz*(1000-c)/1000000+c, 0
    };
    MAKE_AND_RETURN_ARRAY(values);
}
 
static C4Value FnTrans_Mul(C4PropList * _this, C4Value *pars)
{
    const int32_t matrixSize = 12;
    long values[] = 
    {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
    };
 
    // Read all parameters
    bool first = true;
    for (int32_t i = 0; i < C4AUL_MAX_Par; i++)
    {
        C4Value Data = *(pars++);
        // No data given?
        if (!Data) break;
        C4ValueArray *factorArray = Data.getArray();
        if (!factorArray || factorArray->GetSize() != matrixSize) continue;
 
        if (first)
        {
            first = false;
            
            for (int32_t c = 0; c < matrixSize; ++c)
                values[c] = (*factorArray)[c].getInt();
            continue;
        }
 
        // multiply current matrix with new one
        long values_rhs[matrixSize], values_result[matrixSize];
        for (int32_t c = 0; c < matrixSize; ++c)
            values_rhs[c] = (*factorArray)[c].getInt();
 
        // matrix multiplication
        values_result[ 0] = values[0]*values_rhs[0]/1000 + values[1]*values_rhs[4]/1000 + values[ 2]*values_rhs[ 8]/1000;
        values_result[ 1] = values[0]*values_rhs[1]/1000 + values[1]*values_rhs[5]/1000 + values[ 2]*values_rhs[ 9]/1000;
        values_result[ 2] = values[0]*values_rhs[2]/1000 + values[1]*values_rhs[6]/1000 + values[ 2]*values_rhs[10]/1000;
        values_result[ 3] = values[0]*values_rhs[3]/1000 + values[1]*values_rhs[7]/1000 + values[ 2]*values_rhs[11]/1000 + values[3];
        values_result[ 4] = values[4]*values_rhs[0]/1000 + values[5]*values_rhs[4]/1000 + values[ 6]*values_rhs[ 8]/1000;
        values_result[ 5] = values[4]*values_rhs[1]/1000 + values[5]*values_rhs[5]/1000 + values[ 6]*values_rhs[ 9]/1000;
        values_result[ 6] = values[4]*values_rhs[2]/1000 + values[5]*values_rhs[6]/1000 + values[ 6]*values_rhs[10]/1000;
        values_result[ 7] = values[4]*values_rhs[3]/1000 + values[5]*values_rhs[7]/1000 + values[ 6]*values_rhs[11]/1000 + values[7];
        values_result[ 8] = values[8]*values_rhs[0]/1000 + values[9]*values_rhs[4]/1000 + values[10]*values_rhs[ 8]/1000;
        values_result[ 9] = values[8]*values_rhs[1]/1000 + values[9]*values_rhs[5]/1000 + values[10]*values_rhs[ 9]/1000;
        values_result[10] = values[8]*values_rhs[2]/1000 + values[9]*values_rhs[6]/1000 + values[10]*values_rhs[10]/1000;
        values_result[11] = values[8]*values_rhs[3]/1000 + values[9]*values_rhs[7]/1000 + values[10]*values_rhs[11]/1000 + values[11];
 
        for (int32_t c = 0; c < matrixSize; ++c)
            values[c] = values_result[c];
    }
 
    // unlike in the other Trans_*-functions, we have to put the array into a C4Value manually here
    C4ValueArray *matrix = new C4ValueArray(sizeof(values) / sizeof(*values));
    for (size_t i = 0; i < sizeof(values) / sizeof(*values); ++i)
        (*matrix)[i] = C4VInt(values[i]);
    return C4VArray(matrix);
}
 
#undef MAKE_AND_RETURN_ARRAY
 
/* PropLists */
 
static C4PropList * FnCreatePropList(C4PropList * _this, C4PropList * prototype)
{
    return C4PropList::New(prototype);
}
 
static C4Value FnGetProperty(C4PropList * _this, C4String * key, C4PropList * pObj)
{
    if (!pObj) pObj = _this;
    if (!pObj) return C4VNull;
    if (!key) return C4VNull;
    C4Value r;
    pObj->GetPropertyByS(key, &r);
    return r;
}
 
static bool FnSetProperty(C4PropList * _this, C4String * key, const C4Value & to, C4PropList * pObj)
{
    if (!pObj) pObj = _this;
    if (!pObj) return false;
    if (!key) return false;
    if (pObj->IsFrozen())
        throw C4AulExecError("proplist write: proplist is readonly");
    pObj->SetPropertyByS(key, to);
    return true;
}
 
static bool FnResetProperty(C4PropList * _this, C4String * key, C4PropList * pObj)
{
    if (!pObj) pObj = _this;
    if (!pObj) return false;
    if (!key) return false;
    if (!pObj->HasProperty(key)) return false;
    if (pObj->IsFrozen())
        throw C4AulExecError("proplist write: proplist is readonly");
    pObj->ResetProperty(key);
    return true;
}
 
static C4ValueArray * FnGetProperties(C4PropList * _this, C4PropList * p)
{
    if (!p) p = _this;
    if (!p) throw NeedNonGlobalContext("GetProperties");
    C4ValueArray * r = p->GetProperties();
    r->SortStrings();
    return r;
}
 
static C4PropList * FnGetPrototype(C4PropList * _this, C4PropList * p)
{
    if (!p) p = _this;
    if (!p) throw NeedNonGlobalContext("GetPrototype");
    return p->GetPrototype();
}
 
static void FnSetPrototype(C4PropList * _this, C4PropList * prototype, C4PropList * p)
{
    if (!p) p = _this;
    if (!p) throw NeedNonGlobalContext("GetPrototype");
    p->SetProperty(P_Prototype, C4Value(prototype));
}
 
static C4Value FnCall(C4PropList * _this, C4Value * Pars)
{
    if (!_this) _this = ::ScriptEngine.GetPropList();
    C4AulParSet ParSet;
    ParSet.Copy(&Pars[1], C4AUL_MAX_Par - 1);
    C4AulFunc * fn = Pars[0].getFunction();
    C4String * name;
    if (!fn)
    {
        name = Pars[0].getStr();
        if (name) fn = _this->GetFunc(name);
    }
    if (!fn)
    {
        const char * s = FnStringPar(name);
        if (s[0] == '~')
        {
            fn = _this->GetFunc(&s[1]);
            if (!fn)
                return C4Value();
        }
    }
    if (!fn)
        throw C4AulExecError(FormatString("Call: no function %s", Pars[0].GetDataString().getData()).getData());
    return fn->Exec(_this, &ParSet, true);
}
 
static C4String *FnGetName(C4PropList * _this, bool truename)
{
    if (!_this)
        throw NeedNonGlobalContext("GetName");
    else if(truename)
        return _this->IsStatic() ? _this->IsStatic()->GetParentKeyName() : nullptr;
    else
        return String(_this->GetName());
}
 
/* Effects */
 
static C4Value FnAddEffect(C4PropList * _this, C4String * szEffect, C4PropList * pTarget,
                           int iPrio, int iTimerInterval, C4PropList * pCmdTarget, C4Def * idCmdTarget,
                           const C4Value & Val1, const C4Value & Val2, const C4Value & Val3, const C4Value & Val4)
{
    // safety
    if (pTarget && !pTarget->Status) return C4Value();
    if (!szEffect || !*szEffect->GetCStr() || !iPrio) return C4Value();
    // create effect
    C4PropList * p = pCmdTarget;
    if (!p) p = idCmdTarget;
    if (!p) p = ::ScriptEngine.GetPropList();
    C4Effect * pEffect = C4Effect::New(pTarget, FnGetEffectsFor(pTarget),
            szEffect, iPrio, iTimerInterval, p, Val1, Val2, Val3, Val4);
    // return effect - may be 0 if the effect has been denied by another effect
    if (!pEffect) return C4Value();
    return C4VPropList(pEffect);
}
 
static C4Effect * FnCreateEffect(C4PropList * _this, C4PropList * prototype, int iPrio, int iTimerInterval,
                              const C4Value & Val1, const C4Value & Val2, const C4Value & Val3, const C4Value & Val4)
{
    if (!prototype || !(prototype->GetName()[0])) throw C4AulExecError("CreateEffect needs a prototype with a name");
    if (!iPrio) throw C4AulExecError("CreateEffect needs a nonzero priority");
    // create effect
    C4Effect * pEffect = C4Effect::New(_this, FnGetEffectsFor(_this), prototype, iPrio, iTimerInterval,
                                       Val1, Val2, Val3, Val4);
    // return effect - may be 0 if the effect has been denied by another effect
    return pEffect;
}
 
static C4Effect * FnGetEffect(C4PropList * _this, C4String *psEffectName, C4PropList *pTarget, int index, int iMaxPriority)
{
    const char *szEffect = FnStringPar(psEffectName);
    // get effects
    C4Effect *pEffect = *FnGetEffectsFor(pTarget);
    if (!pEffect) return nullptr;
    // name/wildcard given: find effect by name and index
    if (szEffect && *szEffect)
        return pEffect->Get(szEffect, index, iMaxPriority);
    return nullptr;
}
 
static bool FnRemoveEffect(C4PropList * _this, C4String *psEffectName, C4PropList *pTarget, C4Effect * pEffect2, bool fDoNoCalls)
{
    // evaluate parameters
    const char *szEffect = FnStringPar(psEffectName);
    // if the user passed an effect, it can be used straight-away
    C4Effect *pEffect = pEffect2;
    // otherwise, the correct effect will be searched in the target's effects or in the global ones
    if (!pEffect)
    {
        pEffect = *FnGetEffectsFor(pTarget);
        // the object has no effects attached, nothing to look for
        if (!pEffect) return false;
        // name/wildcard given: find effect by name
        if (szEffect && *szEffect)
            pEffect = pEffect->Get(szEffect, 0);
    }
 
    // neither passed nor found - nothing to remove!
    if (!pEffect) return false;
 
    // kill it
    if (fDoNoCalls)
        pEffect->SetDead();
    else
        pEffect->Kill();
    // done, success
    return true;
}
 
static C4Value FnCheckEffect(C4PropList * _this, C4String * psEffectName, C4PropList * pTarget,
                             int iPrio, int iTimerInterval,
                             const C4Value & Val1, const C4Value & Val2, const C4Value & Val3, const C4Value & Val4)
{
    const char *szEffect = FnStringPar(psEffectName);
    // safety
    if (pTarget && !pTarget->Status) return C4Value();
    if (!szEffect || !*szEffect) return C4Value();
    // get effects
    C4Effect *pEffect = *FnGetEffectsFor(pTarget);
    if (!pEffect) return C4Value();
    // let them check
    C4Effect * r = pEffect->Check(szEffect, iPrio, iTimerInterval, Val1, Val2, Val3, Val4);
    if (r == (C4Effect *)C4Fx_Effect_Deny) return C4VInt(C4Fx_Effect_Deny);
    if (r == (C4Effect *)C4Fx_Effect_Annul) return C4VInt(C4Fx_Effect_Annul);
    return C4VPropList(r);
}
 
static long FnGetEffectCount(C4PropList * _this, C4String *psEffectName, C4PropList *pTarget, long iMaxPriority)
{
    // evaluate parameters
    const char *szEffect = FnStringPar(psEffectName);
    // get effects
    C4Effect *pEffect = *FnGetEffectsFor(pTarget);
    if (!pEffect) return false;
    // count effects
    if (!*szEffect) szEffect = nullptr;
    return pEffect->GetCount(szEffect, iMaxPriority);
}
 
static C4Value FnEffectCall(C4PropList * _this, C4Value * Pars)
{
    // evaluate parameters
    C4PropList *pTarget = Pars[0].getPropList();
    C4Effect * pEffect = Pars[1].getPropList() ? Pars[1].getPropList()->GetEffect() : nullptr;
    const char *szCallFn = FnStringPar(Pars[2].getStr());
    // safety
    if (pTarget && !pTarget->Status) return C4Value();
    if (!szCallFn || !*szCallFn) return C4Value();
    if (!pEffect) return C4Value();
    // do call
    return pEffect->DoCall(pTarget, szCallFn, Pars[3], Pars[4], Pars[5], Pars[6], Pars[7], Pars[8], Pars[9]);
}
 
/* Regex */
 
static const long
    Regex_CaseInsensitive = (1 << 0),
    Regex_FirstOnly       = (1 << 1);
 
static std::regex_constants::syntax_option_type C4IntToSyntaxOption(long flags)
{
    std::regex_constants::syntax_option_type out = std::regex::ECMAScript;
    if (flags & Regex_CaseInsensitive)
        out |= std::regex::icase;
    return out;
}
 
static std::regex_constants::match_flag_type C4IntToMatchFlag(long flags)
{
    std::regex_constants::match_flag_type out = std::regex_constants::match_default;
    if (flags & Regex_FirstOnly)
        out |= std::regex_constants::format_first_only;
    return out;
}
 
static Nillable<C4String *> FnRegexReplace(C4PropList * _this, C4String *source, C4String *regex, C4String *replacement, long flags)
{
    if (!source || !regex || !replacement) return C4Void();
    try
    {
        std::regex re(regex->GetCStr(), C4IntToSyntaxOption(flags));
        std::string out = std::regex_replace(source->GetCStr(), re, replacement->GetCStr(), C4IntToMatchFlag(flags));
        return ::Strings.RegString(out.c_str());
    }
    catch (const std::regex_error& e)
    {
        throw C4AulExecError(FormatString("RegexReplace: %s", e.what()).getData());
    }
}
 
 
static Nillable<C4ValueArray *> FnRegexSearch(C4PropList * _this, C4String *source, C4String *regex, long flags)
{
    if (!source || !regex) return C4Void();
    try
    {
        std::regex re(regex->GetCStr(), C4IntToSyntaxOption(flags));
        C4ValueArray *out = new C4ValueArray();
        const auto &data = source->GetData();
        size_t pos = 0;
        std::cmatch m;
        long i = 0;
        // std::regex_iterator would be the better way to do this, but is is broken in libc++ (see LLVM bug #21597).
        while (pos <= data.getLength() && std::regex_search(data.getData() + pos, data.getData() + data.getLength(), m, re))
        {
            int char_pos = GetCharacterCount(std::string(data.getData(), pos + m.position()).c_str());
            (*out)[i++] = C4VInt(char_pos);
            if (flags & Regex_FirstOnly) break;
            pos += m.position() + std::max<size_t>(m.length(), 1);
        }
        return out;
    }
    catch (const std::regex_error& e)
    {
        throw C4AulExecError(FormatString("RegexSearch: %s", e.what()).getData());
    }
}
 
static Nillable<C4ValueArray *> FnRegexMatch(C4PropList * _this, C4String *source, C4String *regex, long flags)
{
    if (!source || !regex) return C4Void();
    try
    {
        std::regex re(regex->GetCStr(), C4IntToSyntaxOption(flags));
        C4ValueArray *out = new C4ValueArray();
        const auto &data = source->GetData();
        size_t pos = 0;
        std::cmatch m;
        long i = 0;
        while (pos <= data.getLength() && std::regex_search(data.getData() + pos, data.getData() + data.getLength(), m, re))
        {
            C4ValueArray *match = new C4ValueArray(m.size());
            long j = 0;
            for (auto sm : m)
            {
                (*match)[j++] = C4VString(String(sm.str().c_str()));
            }
            (*out)[i++] = C4VArray(match);
            if (flags & Regex_FirstOnly) break;
            pos += m.position() + std::max<size_t>(m.length(), 1);
        }
        return out;
    }
    catch (const std::regex_error& e)
    {
        throw C4AulExecError(FormatString("RegexMatch: %s", e.what()).getData());
    }
}
 
static Nillable<C4ValueArray *> FnRegexSplit(C4PropList * _this, C4String *source, C4String *regex, long flags)
{
    if (!source || !regex) return C4Void();
    try
    {
        std::regex re(regex->GetCStr(), C4IntToSyntaxOption(flags));
        C4ValueArray *out = new C4ValueArray();
        const auto &data = source->GetData();
        size_t pos = 0;
        std::cmatch m;
        long i = 0;
        while (pos <= data.getLength() && std::regex_search(data.getData() + pos, data.getData() + data.getLength(), m, re))
        {
            // As we're advancing by one character for zero-length matches, always
            // include at least one character here.
            std::string substr(data.getData() + pos, std::max<size_t>(m.position(), 1));
            (*out)[i++] = C4VString(String(substr.c_str()));
            if (flags & Regex_FirstOnly) break;
            pos += m.position() + std::max<size_t>(m.length(), 1);
        }
        if (pos <= data.getLength())
        {
            std::string substr(data.getData() + pos, data.getLength() - pos);
            (*out)[i++] = C4VString(String(substr.c_str()));
        }
        return out;
    }
    catch (const std::regex_error& e)
    {
        throw C4AulExecError(FormatString("RegexSplit: %s", e.what()).getData());
    }
}
 
 
static C4Value FnLog(C4PropList * _this, C4Value * Pars)
{
    Log(FnStringFormat(_this, Pars[0].getStr(), &Pars[1], 9).getData());
    return C4VBool(true);
}
 
static C4Value FnDebugLog(C4PropList * _this, C4Value * Pars)
{
    DebugLog(FnStringFormat(_this, Pars[0].getStr(), &Pars[1], 9).getData());
    return C4VBool(true);
}
 
static C4Value FnFormat(C4PropList * _this, C4Value * Pars)
{
    return C4VString(FnStringFormat(_this, Pars[0].getStr(), &Pars[1], 9));
}
 
// Parse a string into an integer. Returns nil if the conversion fails.
static Nillable<int32_t> FnParseInt(C4PropList *_this, C4String *str)
{
    const char *cstr = str->GetCStr();
    const char *end = nullptr;
    int32_t result = StrToI32(cstr, 10, &end);
    if (end == cstr || *end != '\0') return C4Void();
    return result;
}
 
static long FnAbs(C4PropList * _this, long iVal)
{
    return Abs(iVal);
}
 
static long FnSin(C4PropList * _this, long iAngle, long iRadius, long iPrec)
{
    if (!iPrec) iPrec = 1;
    // Precalculate the modulo operation so the C4Fixed argument to Sin does not overflow
    iAngle %= 360 * iPrec;
    // Let itofix and fixtoi handle the division and multiplication because that can handle higher ranges
    return fixtoi(Sin(itofix(iAngle, iPrec)), iRadius);
}
 
static long FnCos(C4PropList * _this, long iAngle, long iRadius, long iPrec)
{
    if (!iPrec) iPrec = 1;
    iAngle %= 360 * iPrec;
    return fixtoi(Cos(itofix(iAngle, iPrec)), iRadius);
}
 
static long FnSqrt(C4PropList * _this, long iValue)
{
    if (iValue<0) return 0;
    long iSqrt = long(sqrt(double(iValue)));
    if (iSqrt * iSqrt < iValue) iSqrt++;
    if (iSqrt * iSqrt > iValue) iSqrt--;
    return iSqrt;
}
 
static long FnAngle(C4PropList * _this, long iX1, long iY1, long iX2, long iY2, long iPrec)
{
    // Standard prec
    if (!iPrec) iPrec = 1;
    return Angle(iX1, iY1, iX2, iY2, iPrec);
}
 
static long FnArcSin(C4PropList * _this, long iVal, long iRadius)
{
    // safety
    if (!iRadius) return 0;
    if (iVal > iRadius) return 0;
    // calc arcsin
    double f1 = iVal;
    f1 = asin(f1/iRadius)*180.0/M_PI;
    // return rounded angle
    return (long) floor(f1+0.5);
}
 
static long FnArcCos(C4PropList * _this, long iVal, long iRadius)
{
    // safety
    if (!iRadius) return 0;
    if (iVal > iRadius) return 0;
    // calc arccos
    double f1 = iVal;
    f1 = acos(f1/iRadius)*180.0/M_PI;
    // return rounded angle
    return (long) floor(f1+0.5);
}
 
static std::pair<Nillable<int32_t>, Nillable<int32_t>> minmax(const char *func, const C4Value &a_val, const Nillable<int32_t> &b_opt)
{
    if (a_val.CheckConversion(C4V_Int))
    {
        int32_t a = a_val.getInt();
        int32_t b = b_opt;
        if (a > b)
            std::swap(a, b);
        return std::make_pair(a, b);
    }
    else if (a_val.CheckConversion(C4V_Array))
    {
        const C4ValueArray *a = a_val.getArray();
        if (a->GetSize() == 0)
            return std::make_pair(nullptr, nullptr);
        
        if (!a->GetItem(0).CheckConversion(C4V_Int))
        {
            throw C4AulExecError(FormatString("%s: argument 1 must be int or array-of-int, but element %d of array is of type %s", func, 0, a->GetItem(0).GetTypeName()).getData());
        }
        int32_t min, max;
        min = max = a->GetItem(0).getInt();
 
        for (int32_t i = 1; i < a->GetSize(); ++i)
        {
            if (!a->GetItem(i).CheckConversion(C4V_Int))
            {
                throw C4AulExecError(FormatString("%s: argument 1 must be int or array-of-int, but element %d of array is of type %s", func, i, a->GetItem(i).GetTypeName()).getData());
            }
            int32_t value = a->GetItem(i).getInt();
            min = std::min(min, value);
            max = std::max(max, value);
        }
 
        return std::make_pair(min, max);
    }
    else
    {
        throw C4AulExecError(FormatString("%s: argument 1 must be int or array-of-int, but is of type %s", func, a_val.GetTypeName()).getData());
    }
}
 
static Nillable<int32_t> FnMin(C4PropList * _this, const C4Value &a, Nillable<int32_t> b)
{
    return minmax("Min", a, b).first;
}
 
static Nillable<int32_t> FnMax(C4PropList * _this, const C4Value &a, Nillable<int32_t> b)
{
    return minmax("Max", a, b).second;
}
 
static long FnDistance(C4PropList * _this, long iX1, long iY1, long iX2, long iY2)
{
    return Distance(iX1,iY1,iX2,iY2);
}
 
static long FnBoundBy(C4PropList * _this, long iVal, long iRange1, long iRange2)
{
    return Clamp(iVal,iRange1,iRange2);
}
 
static bool FnInside(C4PropList * _this, long iVal, long iRange1, long iRange2)
{
    return Inside(iVal,iRange1,iRange2);
}
 
static long FnRandom(C4PropList * _this, long iRange)
{
    return Random(iRange);
}
 
static int FnGetType(C4PropList * _this, const C4Value & Value)
{
    // dynamic types
    if (Value.CheckConversion(C4V_Object)) return C4V_Object;
    if (Value.CheckConversion(C4V_Def)) return C4V_Def;
    if (Value.CheckConversion(C4V_Effect)) return C4V_Effect;
    // static types
    return Value.GetType();
}
 
static C4ValueArray * FnCreateArray(C4PropList * _this, int iSize)
{
    return new C4ValueArray(iSize);
}
 
static int FnGetLength(C4PropList * _this, const C4Value & Par)
{
    // support GetLength() etc.
    C4ValueArray * pArray = Par.getArray();
    if (pArray)
        return pArray->GetSize();
    C4String * pStr = Par.getStr();
    if (pStr)
        return GetCharacterCount(pStr->GetData().getData());
    throw C4AulExecError("GetLength: parameter 0 cannot be converted to string or array");
}
 
static int FnGetIndexOf(C4PropList * _this, C4ValueArray * pArray, const C4Value & Needle)
{
    // find first occurance of first parameter in array
    // support GetIndexOf(0, x)
    if (!pArray) return -1;
    int32_t iSize = pArray->GetSize();
    for (int32_t i = 0; i < iSize; ++i)
        if (Needle.IsIdenticalTo(pArray->GetItem(i)))
            // element found
            return i;
    // element not found
    return -1;
}
 
static bool FnDeepEqual(C4PropList * _this, const C4Value & v1, const C4Value & v2)
{
    // return if v1==v2 with deep comparison on arrays and proplists
    return v1 == v2;
}
 
static void FnSetLength(C4PropList * _this, C4ValueArray *pArray, int iNewSize)
{
    if (!pArray)
    {
        throw C4AulExecError(strprintf(R"(call to "%s" parameter %d: passed %s, but expected %s)",
            "SetLength", 1, GetC4VName(C4V_Nil), GetC4VName(C4V_Array))
            .c_str()
        );
    }
 
    if (iNewSize < 0 || iNewSize > C4ValueArray::MaxSize)
    {
        throw C4AulExecError(strprintf(R"(call to "SetLength": parameter 2: invalid array size (expected value between 0 and %d, but got %d)",
            C4ValueArray::MaxSize, iNewSize)
            .c_str()
        );
    }
 
    // set new size
    pArray->SetSize(iNewSize);
}
 
static Nillable<long> FnGetChar(C4PropList * _this, C4String *pString, long iIndex)
{
    const char *szText = FnStringPar(pString);
    if (!szText) return C4Void();
    // C4Strings are UTF-8 encoded, so decode to get the indicated character
    uint32_t c = GetNextCharacter(&szText);
    for (int i = 0; i < iIndex; ++i)
    {
        c = GetNextCharacter(&szText);
        if (!c) return C4Void();
    }
    return c;
}
 
static C4String *FnStringToIdentifier(C4PropList * _this, C4String *pString)
{
    // Change an arbitrary string so that it becomes an identifier
    const char *text = FnStringPar(pString);
    if (!text) return nullptr;
    StdStrBuf result;
    bool had_valid = false, had_invalid = false;
    const char *ptext = text, *t0 = text;
    uint32_t c = GetNextCharacter(&text);
    while (c)
    {
        if (isalnum(c) || c == '_')
        {
            // Starting with a digit? Needs to prepend a character
            if (isdigit(c) && !had_valid)
            {
                result.Append("_");
                had_invalid = true;
            }
            // Valid character: Append to result string if a modification had to be done
            if (had_invalid) result.Append(ptext, text - ptext);
            had_valid = true;
        }
        else
        {
            // Invalid character. Make sure result is created from previous valid characters
            if (!had_invalid)
            {
                result.Copy(t0, ptext - t0);
                had_invalid = true;
            }
        }
        ptext = text;
        c = GetNextCharacter(&text);
    }
    // Make sure no empty string is returned
    if (!had_valid) return ::Strings.RegString("_");
    // Return either modified string or the original if no modifications were needed
    return had_invalid ? ::Strings.RegString(result) : pString;
}
 
static C4Value Fneval(C4PropList * _this, C4String *strScript, bool dont_pass_errors)
{
    return ::AulExec.DirectExec(_this, FnStringPar(strScript), "eval", !dont_pass_errors);
}
 
static bool FnLocateFunc(C4PropList * _this, C4String *funcname, C4PropList * p)
{
    // safety
    if (!funcname || !funcname->GetCStr())
    {
        Log("No func name");
        return false;
    }
    if (!p) p = _this;
    // get function by name
    C4AulFunc *pFunc = p->GetFunc(funcname);
    if (!pFunc)
    {
        LogF("Func %s not found", funcname->GetCStr());
    }
    else
    {
        const char *szPrefix = "";
        while (pFunc)
        {
            C4AulScriptFunc *pSFunc = pFunc->SFunc();
            if (!pSFunc)
            {
                LogF("%s%s (engine)", szPrefix, pFunc->GetName());
            }
            else if (!pSFunc->pOrgScript)
            {
                LogF("%s%s (no owner)", szPrefix, pSFunc->GetName());
            }
            else
            {
                int32_t iLine = SGetLine(pSFunc->pOrgScript->GetScript(), pSFunc->Script);
                LogF("%s%s (%s:%d)", szPrefix, pFunc->GetName(), pSFunc->pOrgScript->ScriptName.getData(), (int)iLine);
            }
            // next func in overload chain
            pFunc = pSFunc ? pSFunc->OwnerOverloaded : nullptr;
            szPrefix = "overloads ";
        }
    }
    return true;
}
 
static long FnModulateColor(C4PropList * _this, long iClr1, long iClr2)
{
    DWORD dwClr1 = iClr1;
    DWORD dwClr2 = iClr2;
    // default color
    if (!dwClr1) dwClr1 = 0xffffff;
    // get alpha
    long iA1=dwClr1>>24, iA2=dwClr2>>24;
    // modulate color values; mod alpha upwards
    DWORD r = (((dwClr1     & 0xff) * (dwClr2    &   0xff))    >>  8)   | // blue
              (((dwClr1>> 8 & 0xff) * (dwClr2>>8 &   0xff)) &   0xff00) | // green
              (((dwClr1>>16 & 0xff) * (dwClr2>>8 & 0xff00)) & 0xff0000) | // red
              (std::min<long>(iA1+iA2 - ((iA1*iA2)>>8), 255)           << 24); // alpha
    return r;
}
 
static long FnWildcardMatch(C4PropList * _this, C4String *psString, C4String *psWildcard)
{
    return SWildcardMatchEx(FnStringPar(psString), FnStringPar(psWildcard));
}
 
static C4Value FnFatalError(C4PropList * _this, C4Value * Pars)
{
    throw C4AulExecError(FormatString("script: %s", FnStringFormat(_this, Pars[0].getStr(), &Pars[1], 9).getData()).getData());
}
 
static bool FnStartCallTrace(C4PropList * _this)
{
    AulExec.StartTrace();
    return true;
}
 
static bool FnStartScriptProfiler(C4PropList * _this, C4Def * pDef)
{
    // get script to profile
    C4ScriptHost *pScript;
    if (pDef)
        pScript = &pDef->Script;
    else
        pScript = nullptr;
    // profile it
    C4AulProfiler::StartProfiling(pScript);
    return true;
}
 
static bool FnStopScriptProfiler(C4PropList * _this)
{
    C4AulProfiler::StopProfiling();
    return true;
}
 
static Nillable<C4String *> FnGetConstantNameByValue(C4PropList * _this, int value, Nillable<C4String *> name_prefix, int idx)
{
    C4String *name_prefix_s = name_prefix;
    // find a constant that has the specified value and prefix
    for (int32_t i = 0; i < ::ScriptEngine.GlobalConsts.GetAnzItems(); ++i)
    {
        if (::ScriptEngine.GlobalConsts[i].getInt() == value)
        {
            const char *const_name = ::ScriptEngine.GlobalConstNames.GetItemUnsafe(i);
            if (!name_prefix_s || SEqual2(const_name, name_prefix_s->GetCStr()))
                if (!idx--)
                    // indexed constant found. return name minus prefix
                    return String(const_name + (name_prefix_s ? name_prefix_s->GetData().getLength() : 0));
        }
    }
    // nothing found (at index)
    return C4Void();
}
 
static Nillable<C4String *> FnReplaceString(C4PropList * _this, C4String *source, C4String *from, C4String *to)
{
    if (!from) return source;
    if (!source) return C4Void();
    const char *szto = to ? to->GetCStr() : "";
    const char *szfrom = from->GetCStr();
    StdStrBuf s(source->GetData(), true);
    if (s.Replace(szfrom, szto))
    {
        return ::Strings.RegString(s.getData());
    }
    else
    {
        return source;
    }
}
 
static bool FnSortArray(C4PropList * _this, C4ValueArray *pArray, bool descending)
{
    if (!pArray) throw C4AulExecError("SortArray: no array given");
    if (pArray->IsFrozen()) throw C4AulExecError("array sort: array is readonly");
    // sort array by its members
    pArray->Sort(descending);
    return true;
}
 
static bool FnSortArrayByProperty(C4PropList * _this, C4ValueArray *pArray, C4String *prop_name, bool descending)
{
    if (!pArray) throw C4AulExecError("SortArrayByProperty: no array given");
    if (!prop_name) throw C4AulExecError("SortArrayByProperty: no property name given");
    if (pArray->IsFrozen()) throw C4AulExecError("array sort: array is readonly");
    // sort array by property
    if (!pArray->SortByProperty(prop_name, descending)) throw C4AulExecError("SortArrayByProperty: not all array elements are proplists");
    return true;
}
 
static bool FnSortArrayByArrayElement(C4PropList * _this, C4ValueArray *pArray, int32_t element_index, bool descending)
{
    if (!pArray) throw C4AulExecError("SortArrayByArrayElement: no array given");
    if (element_index<0) throw C4AulExecError("SortArrayByArrayElement: element index must be >=0");
    if (pArray->IsFrozen()) throw C4AulExecError("array sort: array is readonly");
    // sort array by array element
    if (!pArray->SortByArrayElement(element_index, descending)) throw C4AulExecError("SortArrayByArrayElement: not all array elements are arrays of sufficient length");
    return true;
}
 
static bool FnFileWrite(C4PropList * _this, int32_t file_handle, C4String *data)
{
    // resolve file handle to user file
    C4AulUserFile *file = ::ScriptEngine.GetUserFile(file_handle);
    if (!file) throw C4AulExecError("FileWrite: invalid file handle");
    // prepare string to write
    if (!data) return false; // write nullptr? No.
    // write it
    file->Write(data->GetCStr(), data->GetData().getLength());
    return true;
}
 
//=========================== C4Script Function Map ===================================
 
C4ScriptConstDef C4ScriptConstMap[]=
{
    { "FX_OK"                     ,C4V_Int,      C4Fx_OK                    }, // generic standard behaviour for all effect callbacks
    { "FX_Effect_Deny"            ,C4V_Int,      C4Fx_Effect_Deny           }, // delete effect
    { "FX_Effect_Annul"           ,C4V_Int,      C4Fx_Effect_Annul          }, // delete effect, because it has annulled a countereffect
    { "FX_Effect_AnnulDoCalls"    ,C4V_Int,      C4Fx_Effect_AnnulCalls     }, // delete effect, because it has annulled a countereffect; temp readd countereffect
    { "FX_Execute_Kill"           ,C4V_Int,      C4Fx_Execute_Kill          }, // execute callback: Remove effect now
    { "FX_Stop_Deny"              ,C4V_Int,      C4Fx_Stop_Deny             }, // deny effect removal
    { "FX_Start_Deny"             ,C4V_Int,      C4Fx_Start_Deny            }, // deny effect start
 
    { "FX_Call_Normal"            ,C4V_Int,      C4FxCall_Normal            }, // normal call; effect is being added or removed
    { "FX_Call_Temp"              ,C4V_Int,      C4FxCall_Temp              }, // temp call; effect is being added or removed in responce to a lower-level effect change
    { "FX_Call_TempAddForRemoval" ,C4V_Int,      C4FxCall_TempAddForRemoval }, // temp call; effect is being added because it had been temp removed and is now removed forever
    { "FX_Call_RemoveClear"       ,C4V_Int,      C4FxCall_RemoveClear       }, // effect is being removed because object is being removed
    { "FX_Call_RemoveDeath"       ,C4V_Int,      C4FxCall_RemoveDeath       }, // effect is being removed because object died - return -1 to avoid removal
    { "FX_Call_DmgScript"         ,C4V_Int,      C4FxCall_DmgScript         }, // damage through script call
    { "FX_Call_DmgBlast"          ,C4V_Int,      C4FxCall_DmgBlast          }, // damage through blast
    { "FX_Call_DmgFire"           ,C4V_Int,      C4FxCall_DmgFire           }, // damage through fire
    { "FX_Call_DmgChop"           ,C4V_Int,      C4FxCall_DmgChop           }, // damage through chopping
    { "FX_Call_Energy"            ,C4V_Int,      32                         }, // bitmask for generic energy loss
    { "FX_Call_EngScript"         ,C4V_Int,      C4FxCall_EngScript         }, // energy loss through script call
    { "FX_Call_EngBlast"          ,C4V_Int,      C4FxCall_EngBlast          }, // energy loss through blast
    { "FX_Call_EngObjHit"         ,C4V_Int,      C4FxCall_EngObjHit         }, // energy loss through object hitting the living
    { "FX_Call_EngFire"           ,C4V_Int,      C4FxCall_EngFire           }, // energy loss through fire
    { "FX_Call_EngBaseRefresh"    ,C4V_Int,      C4FxCall_EngBaseRefresh    }, // energy reload in base (also by base object, but that's normally not called)
    { "FX_Call_EngAsphyxiation"   ,C4V_Int,      C4FxCall_EngAsphyxiation   }, // energy loss through asphyxiaction
    { "FX_Call_EngCorrosion"      ,C4V_Int,      C4FxCall_EngCorrosion      }, // energy loss through corrosion (acid)
    { "FX_Call_EngGetPunched"     ,C4V_Int,      C4FxCall_EngGetPunched     }, // energy loss from punch
 
    { "Regex_CaseInsensitive"     ,C4V_Int,      Regex_CaseInsensitive      },
    { "Regex_FirstOnly"           ,C4V_Int,      Regex_FirstOnly            },
 
    { "C4V_Nil",         C4V_Int, C4V_Nil},
    { "C4V_Int",         C4V_Int, C4V_Int},
    { "C4V_Bool",        C4V_Int, C4V_Bool},
    { "C4V_C4Object",    C4V_Int, C4V_Object},
    { "C4V_Effect",      C4V_Int, C4V_Effect},
    { "C4V_Def",         C4V_Int, C4V_Def},
    { "C4V_String",      C4V_Int, C4V_String},
    { "C4V_Array",       C4V_Int, C4V_Array},
    { "C4V_Function",    C4V_Int, C4V_Function},
    { "C4V_PropList",    C4V_Int, C4V_PropList},
 
    { "C4X_Ver1",        C4V_Int, C4XVER1},
    { "C4X_Ver2",        C4V_Int, C4XVER2},
 
    { nullptr, C4V_Nil, 0}
};
 
C4ScriptFnDef C4ScriptFnMap[]=
{
    { "Call",          true, C4V_Any,    { C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any    ,C4V_Any    ,C4V_Any    ,C4V_Any}, FnCall     },
    { "EffectCall",    true, C4V_Any,    { C4V_Object  ,C4V_PropList,C4V_String  ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any    ,C4V_Any    ,C4V_Any    ,C4V_Any}, FnEffectCall    },
    { "Log",           true, C4V_Bool,   { C4V_String  ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any    ,C4V_Any    ,C4V_Any    ,C4V_Any}, FnLog      },
    { "DebugLog",      true, C4V_Bool,   { C4V_String  ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any    ,C4V_Any    ,C4V_Any    ,C4V_Any}, FnDebugLog },
    { "FatalError",    true, C4V_Nil,    { C4V_String  ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any    ,C4V_Any    ,C4V_Any    ,C4V_Any}, FnFatalError },
    { "Format",        true, C4V_String, { C4V_String  ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any    ,C4V_Any    ,C4V_Any    ,C4V_Any}, FnFormat   },
    { "Trans_Mul",     true, C4V_Array,  { C4V_Array   ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any     ,C4V_Any    ,C4V_Any    ,C4V_Any    ,C4V_Any}, FnTrans_Mul},
 
    { nullptr,            false, C4V_Nil,    { C4V_Nil     ,C4V_Nil     ,C4V_Nil     ,C4V_Nil     ,C4V_Nil     ,C4V_Nil     ,C4V_Nil    ,C4V_Nil    ,C4V_Nil    ,C4V_Nil}, nullptr          }
};
 
void InitCoreFunctionMap(C4AulScriptEngine *pEngine)
{
    C4ScriptLibrary::InstantiateAllLibraries(pEngine);
    // add all def constants (all Int)
    for (C4ScriptConstDef *pCDef = &C4ScriptConstMap[0]; pCDef->Identifier; pCDef++)
    {
        assert(pCDef->ValType == C4V_Int); // only int supported currently
        pEngine->RegisterGlobalConstant(pCDef->Identifier, C4VInt(pCDef->Data));
    }
 
    C4PropListStatic * p = pEngine->GetPropList();
    // add all def script funcs
    for (C4ScriptFnDef *pDef = &C4ScriptFnMap[0]; pDef->Identifier; pDef++)
        new C4AulDefFunc(p, pDef);
#define F(f) ::AddFunc(p, #f, Fn##f)
    F(ParseInt);
    F(Abs);
    F(Min);
    F(Max);
    F(Sin);
    F(Cos);
    F(Sqrt);
    F(ArcSin);
    F(ArcCos);
    F(BoundBy);
    F(Inside);
    F(Random);
 
    F(CreateArray);
    F(CreatePropList);
    F(GetProperties);
    F(GetProperty);
    F(SetProperty);
    F(GetPrototype);
    F(SetPrototype);
    F(ResetProperty);
    F(GetName);
    F(AddEffect);
    F(CreateEffect);
    F(CheckEffect);
    F(RemoveEffect);
    F(GetEffect);
    F(GetEffectCount);
    F(RegexReplace);
    F(RegexSearch);
    F(RegexMatch);
    F(RegexSplit);
    F(Distance);
    F(Angle);
    F(GetChar);
    F(GetType);
    F(ModulateColor);
    F(WildcardMatch);
    F(GetLength);
    F(SetLength);
    F(GetIndexOf);
    F(DeepEqual);
    F(StartCallTrace);
    F(StartScriptProfiler);
    F(StopScriptProfiler);
    F(SortArray);
    F(SortArrayByProperty);
    F(SortArrayByArrayElement);
    F(Trans_Identity);
    F(Trans_Translate);
    F(Trans_Scale);
    F(Trans_Rotate);
    F(LocateFunc);
    F(FileWrite);
    F(eval);
    F(StringToIdentifier);
    F(GetConstantNameByValue);
    F(ReplaceString);
 
    ::AddFunc(p, "Translate", C4AulExec::FnTranslate);
    ::AddFunc(p, "LogCallStack", C4AulExec::FnLogCallStack);
#undef F
}