functions.cpp

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * xoreos is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#include <cassert>
#include <cstdlib>

#include <boost/bind.hpp>

#include "src/common/util.h"

#include "src/aurora/nwscript/functionman.h"
#include "src/aurora/nwscript/util.h"

#include "src/engines/kotor/types.h"
#include "src/engines/kotor/game.h"
#include "src/engines/kotor/module.h"
#include "src/engines/kotor/area.h"
#include "src/engines/kotor/objectcontainer.h"
#include "src/engines/kotor/object.h"

#include "src/engines/kotor/script/functions.h"

#include "src/engines/kotor/script/function_tables.h"

namespace Engines {

namespace KotOR {

Functions::Functions(Game &game)
        : _game(&game),
          _lastEvent(0) {
    registerFunctions();
}

Functions::~Functions() {
    FunctionMan.clear();
}

void Functions::registerFunctions() {
    assert(ARRAYSIZE(kFunctionPointers) == ARRAYSIZE(kFunctionSignatures));
    assert(ARRAYSIZE(kFunctionPointers) == ARRAYSIZE(kFunctionDefaults));

    for (size_t i = 0; i < ARRAYSIZE(kFunctionPointers); i++) {
        const FunctionPointer   &fPtr = kFunctionPointers[i];
        const FunctionSignature &fSig = kFunctionSignatures[i];
        const FunctionDefaults  &fDef = kFunctionDefaults[i];

        const uint32 id = fPtr.id;

        assert((fSig.id == id) && (fDef.id == id));

        Aurora::NWScript::Signature signature;
        signature.push_back(fSig.returnType);
        for (size_t j = 0; j < ARRAYSIZE(fSig.parameters); j++) {
            if (fSig.parameters[j] == kTypeVoid)
                break;

            signature.push_back(fSig.parameters[j]);
        }

        Aurora::NWScript::Parameters defaults;
        for (size_t j = 0; j < ARRAYSIZE(fDef.defaults); j++) {
            if (!fDef.defaults[j])
                break;

            defaults.push_back(Aurora::NWScript::Variable(*fDef.defaults[j]));
        }

        const funcPtr f = fPtr.func ? fPtr.func : &Functions::unimplementedFunction;

        FunctionMan.registerFunction(fPtr.name, id, boost::bind(f, this, _1), signature, defaults);
    }
}

void Functions::unimplementedFunction(Aurora::NWScript::FunctionContext &ctx) {
    warning("TODO: %s %s(%s)", Aurora::NWScript::formatType(ctx.getReturn().getType()).c_str(),
                               ctx.getName().c_str(), Aurora::NWScript::formatParams(ctx).c_str());
}

int32 Functions::getRandom(int min, int max, int32 n) {
    if (n < 1)
        n = 1;

    int32 r = 0;

    while (n-- > 0)
        r += std::rand() % (max - min + 1) + min;

    return r;
}

Common::UString Functions::formatFloat(float f, int width, int decimals) {
    return Common::UString::format("%*.*f", width, decimals, f);
}

Aurora::NWScript::Object *Functions::getParamObject(const Aurora::NWScript::FunctionContext &ctx, size_t n) {
    KotOR::Object *object = KotOR::ObjectContainer::toObject(ctx.getParams()[n].getObject());
    if (!object || (object->getType() == kObjectTypeInvalid))
        return 0;

    if (object->getType() == kObjectTypeSelf)
        return ctx.getCaller();

    return object;
}

void Functions::jumpTo(KotOR::Object *object, float x, float y, float z) {
    object->setPosition(x, y, z);
}

} // End of namespace KotOR

} // End of namespace Engines