Lucas de Vries
484 lines
15 KiB
C++
484 lines
15 KiB
C++
#include "scripts/binds.h"
|
|
#include "obj/object.h"
|
|
#include "empire.h"
|
|
#include "empire_stats.h"
|
|
#include "main/references.h"
|
|
#include "design/design.h"
|
|
#include "vec2.h"
|
|
#include "scripts/script_components.h"
|
|
#include "util/stat_history.h"
|
|
#include "network/network_manager.h"
|
|
|
|
extern Empire* defaultEmpire;
|
|
extern Empire* playerEmpire;
|
|
extern Empire* spectatorEmpire;
|
|
|
|
extern std::unordered_map<std::string,unsigned> statIndices;
|
|
|
|
namespace scripts {
|
|
|
|
static const Design* getDesignByName(Empire* emp, const std::string& name) {
|
|
return emp->getDesign(name, true);
|
|
}
|
|
|
|
static const Design* getDesignById(Empire* emp, int id) {
|
|
return emp->getDesign(id, true);
|
|
}
|
|
|
|
static unsigned getDesignCount(Empire* emp) {
|
|
return emp->designIds.size();
|
|
}
|
|
|
|
static unsigned getDesignClassCount(Empire* emp) {
|
|
return emp->designClassIds.size();
|
|
}
|
|
|
|
static Empire* empFactory() {
|
|
return new Empire();
|
|
}
|
|
|
|
static Empire* empFactory_b(bool unlisted) {
|
|
return new Empire(unlisted ? INVALID_EMPIRE : UNLISTED_EMPIRE);
|
|
}
|
|
|
|
static void writeDelta(Empire* emp, net::Message& msg) {
|
|
emp->writeDelta(msg);
|
|
}
|
|
|
|
static void readDelta(Empire* emp, net::Message& msg) {
|
|
try {
|
|
emp->readDelta(msg);
|
|
}
|
|
catch(net::MessageReadError) {
|
|
scripts::throwException("Error reading from message: end of message.");
|
|
}
|
|
}
|
|
|
|
static bool ssUnlocked(Empire* emp, const SubsystemDef* def) {
|
|
threads::ReadLock lock(emp->subsystemDataMutex);
|
|
Empire::SubsystemData* ssdata = emp->getSubsystemData(def);
|
|
return ssdata ? ssdata->unlocked : false;
|
|
}
|
|
|
|
static bool ssModUnlocked(Empire* emp, const SubsystemDef* def, const SubsystemDef::ModuleDesc* mod) {
|
|
threads::ReadLock lock(emp->subsystemDataMutex);
|
|
Empire::SubsystemData* ssdata = emp->getSubsystemData(def);
|
|
if(!ssdata)
|
|
return false;
|
|
if((int)ssdata->modulesUnlocked.size() <= mod->index)
|
|
return false;
|
|
return ssdata->modulesUnlocked[mod->index];
|
|
}
|
|
|
|
static void ssSetModUnlock(Empire* emp, const SubsystemDef* def, const SubsystemDef::ModuleDesc* mod, bool val) {
|
|
threads::WriteLock lock(emp->subsystemDataMutex);
|
|
Empire::SubsystemData* ssdata = emp->getSubsystemData(def);
|
|
if(ssdata) {
|
|
if((int)ssdata->modulesUnlocked.size() <= mod->index)
|
|
ssdata->modulesUnlocked.resize(mod->index+1, false);
|
|
ssdata->modulesUnlocked[mod->index] = val;
|
|
ssdata->delta = true;
|
|
}
|
|
}
|
|
|
|
static void ssSetUnlock(Empire* emp, const SubsystemDef* def, bool val) {
|
|
threads::WriteLock lock(emp->subsystemDataMutex);
|
|
Empire::SubsystemData* ssdata = emp->getSubsystemData(def);
|
|
if(ssdata) {
|
|
ssdata->unlocked = val;
|
|
ssdata->delta = true;
|
|
}
|
|
}
|
|
|
|
static void removeModifier(Empire* emp, const SubsystemDef* def, unsigned id) {
|
|
threads::WriteLock lock(emp->subsystemDataMutex);
|
|
Empire::SubsystemData* ssdata = emp->getSubsystemData(def);
|
|
if(ssdata) {
|
|
ssdata->stages.erase(id);
|
|
ssdata->delta = true;
|
|
}
|
|
}
|
|
|
|
static void addModifier_d(asIScriptGeneric* f) {
|
|
Empire* emp = (Empire*)f->GetObject();
|
|
threads::WriteLock lock(emp->subsystemDataMutex);
|
|
const SubsystemDef* def = (const SubsystemDef*)f->GetArgAddress(0);
|
|
Empire::SubsystemData* ssdata = emp->getSubsystemData(def);
|
|
|
|
if(!ssdata)
|
|
return;
|
|
|
|
//Find the modifier
|
|
std::string& modname = *(std::string*)f->GetArgAddress(1);
|
|
auto it = def->modifierIds.find(modname);
|
|
if(it == def->modifierIds.end()) {
|
|
scripts::throwException(
|
|
format("Error: Could not find subsystem modifier '$1.$2'.\n",
|
|
def->id, modname).c_str());
|
|
return;
|
|
}
|
|
|
|
const SubsystemDef::ModifyStage* stage = it->second;
|
|
|
|
//Check arguments
|
|
if((int)stage->argumentNames.size() != f->GetArgCount() - 2) {
|
|
scripts::throwException(
|
|
format("Error: Subsystem modifier '$1.$2'"
|
|
" expects $3 arguments, got $4.\n",
|
|
def->id, modname,
|
|
(unsigned)stage->argumentNames.size(),
|
|
f->GetArgCount() - 1).c_str());
|
|
return;
|
|
}
|
|
|
|
//Create applied stage
|
|
SubsystemDef::AppliedStage as;
|
|
as.stage = stage;
|
|
|
|
for(unsigned i = 0, cnt = stage->argumentNames.size(); i < cnt; ++i)
|
|
as.arguments[i] = f->GetArgFloat(i+2);
|
|
|
|
//Add stage to data
|
|
unsigned id = ssdata->nextStageId++;
|
|
ssdata->stages[id] = as;
|
|
ssdata->delta = true;
|
|
f->SetReturnDWord(id);
|
|
}
|
|
|
|
struct StatReader {
|
|
const StatHistory* history;
|
|
const StatEntry* entry;
|
|
const StatEvent* evt;
|
|
|
|
Empire* emp;
|
|
unsigned id;
|
|
|
|
StatReader(const StatHistory* History, Empire* Emp, unsigned ID) : history(History), entry(0), evt(0), emp(Emp), id(ID) {}
|
|
~StatReader() {
|
|
if(emp)
|
|
emp->unlockStatHistory(id);
|
|
}
|
|
|
|
int get_int() const {
|
|
if(entry)
|
|
return entry->asInt;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
float get_float() const {
|
|
if(entry)
|
|
return entry->asFloat;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
unsigned get_time() const {
|
|
if(entry)
|
|
return entry->time;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
unsigned get_evt_type() const {
|
|
if(evt)
|
|
return evt->type;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
std::string get_evt_name() const {
|
|
if(evt)
|
|
return evt->name;
|
|
else
|
|
return "";
|
|
}
|
|
|
|
bool toHead() {
|
|
if(!history)
|
|
return false;
|
|
|
|
if(const StatEntry* head = history->getHead()) {
|
|
entry = head;
|
|
evt = 0;
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool toTail() {
|
|
if(!history)
|
|
return false;
|
|
|
|
if(const StatEntry* tail = history->getTail()) {
|
|
entry = tail;
|
|
evt = 0;
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool advance(int amount) {
|
|
if(!history)
|
|
return false;
|
|
|
|
if(amount > 0) {
|
|
evt = 0;
|
|
|
|
if(entry == 0) {
|
|
entry = history->getHead();
|
|
|
|
if(entry)
|
|
return advance(amount-1);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
do {
|
|
entry = entry->next;
|
|
if(entry == 0)
|
|
return false;
|
|
} while(--amount != 0);
|
|
|
|
return entry != 0;
|
|
}
|
|
else if(amount < 0) {
|
|
evt = 0;
|
|
|
|
if(entry == 0) {
|
|
entry = history->getTail();
|
|
|
|
if(entry)
|
|
return advance(amount+1);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
do {
|
|
entry = entry->prev;
|
|
if(entry == 0)
|
|
return false;
|
|
} while(--amount != 0);
|
|
|
|
return entry != 0;
|
|
}
|
|
else {
|
|
evt = 0;
|
|
return entry != 0;
|
|
}
|
|
}
|
|
|
|
bool advanceEvent() {
|
|
if(!history)
|
|
return false;
|
|
|
|
if(entry) {
|
|
if(evt == 0) {
|
|
evt = entry->evt;
|
|
return evt != 0;
|
|
}
|
|
else if(evt->next) {
|
|
evt = evt->next;
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void destroy(StatReader* reader) {
|
|
delete reader;
|
|
}
|
|
};
|
|
|
|
StatReader* getStatHistory(Empire* emp, unsigned id) {
|
|
const StatHistory* history = emp->lockStatHistory(id);
|
|
if(!history) {
|
|
return new StatReader(0, 0, 0);
|
|
}
|
|
else {
|
|
return new StatReader(history, emp, id);
|
|
}
|
|
}
|
|
|
|
bool empIsHostile(Empire& from, Empire* to) {
|
|
if(to == nullptr)
|
|
return false;
|
|
return from.hostileMask & to->mask;
|
|
}
|
|
|
|
bool empIsHostile_restricted(Empire& from, Empire* to) {
|
|
if(to == nullptr)
|
|
return false;
|
|
//if(&from != playerEmpire && to != playerEmpire)
|
|
// return false;
|
|
return from.hostileMask & to->mask;
|
|
}
|
|
|
|
void empSetHostile(Empire& from, Empire& to, bool value) {
|
|
threads::Lock lock(from.maskMutex);
|
|
if(value)
|
|
from.hostileMask |= to.mask;
|
|
else
|
|
from.hostileMask &= ~to.mask;
|
|
}
|
|
|
|
static bool empControlled(Empire& emp) {
|
|
return devices.network->getCurrentPlayer().controls(&emp);
|
|
}
|
|
|
|
static bool empViewed(Empire& emp) {
|
|
return devices.network->getCurrentPlayer().views(&emp);
|
|
}
|
|
|
|
void RegisterEmpireBinds(bool declarations, bool server) {
|
|
if(declarations) {
|
|
ClassBind emp("Empire", asOBJ_REF | asOBJ_NOCOUNT);
|
|
return;
|
|
}
|
|
|
|
ClassBind emp("Empire");
|
|
emp.addFactory("Empire@ f()", asFUNCTION(empFactory));
|
|
emp.addFactory("Empire@ f(bool unlisted)", asFUNCTION(empFactory_b));
|
|
emp.addMember("string name", offsetof(Empire,name));
|
|
emp.addMember("Player@ player", offsetof(Empire,player));
|
|
emp.addMember("uint8 id", offsetof(Empire,id));
|
|
emp.addMember("int index", offsetof(Empire,index));
|
|
emp.addMember("uint mask", offsetof(Empire,mask));
|
|
emp.addMember("uint visionMask", offsetof(Empire,visionMask));
|
|
emp.addMember("Color color", offsetof(Empire,color));
|
|
emp.addMember("const Material@ background", offsetof(Empire,background));
|
|
emp.addMember("const Material@ portrait", offsetof(Empire,portrait));
|
|
emp.addMember("const Material@ flag", offsetof(Empire,flag));
|
|
emp.addMember("string backgroundDef", offsetof(Empire,backgroundDef));
|
|
emp.addMember("string portraitDef", offsetof(Empire,portraitDef));
|
|
emp.addMember("string flagDef", offsetof(Empire,flagDef));
|
|
emp.addMember("uint flagID", offsetof(Empire,flagID));
|
|
emp.addMember("const Shipset@ shipset", offsetof(Empire, shipset));
|
|
emp.addMember("string effectorSkin", offsetof(Empire, effectorSkin));
|
|
|
|
if(server) {
|
|
emp.addMember("uint hostileMask", offsetof(Empire,hostileMask));
|
|
emp.addExternMethod("bool isHostile(Empire@ emp)", asFUNCTION(empIsHostile));
|
|
emp.addExternMethod("void setHostile(Empire& emp, bool value)", asFUNCTION(empSetHostile));
|
|
emp.addMethod("void cacheVision()", asMETHOD(Empire,cacheVision));
|
|
}
|
|
else {
|
|
emp.addExternMethod("bool isHostile(Empire@ emp)", asFUNCTION(empIsHostile_restricted));
|
|
emp.addExternMethod("bool get_controlled() const", asFUNCTION(empControlled));
|
|
emp.addExternMethod("bool get_viewable() const", asFUNCTION(empViewed));
|
|
}
|
|
|
|
emp.addMethod("uint get_objectCount()", asMETHOD(Empire, objectCount));
|
|
emp.addMethod("Object@+ get_objects(uint i)", asMETHOD(Empire, findObject));
|
|
|
|
//Stats
|
|
{
|
|
Namespace ns("stat");
|
|
EnumBind statTypes("EmpireStat");
|
|
for(auto i = statIndices.begin(), end = statIndices.end(); i != end; ++i)
|
|
statTypes[i->first] = i->second;
|
|
}
|
|
|
|
bind("string get_statName(stat::EmpireStat)", asFUNCTION(getEmpireStatName));
|
|
|
|
ClassBind stats("StatHistory", asOBJ_REF | asOBJ_SCOPED);
|
|
classdoc(stats, "Accesses the history of an empire's stat. Locks the stat, so limit access to these histories.");
|
|
|
|
stats.addFactory("StatHistory@ f(Empire&, stat::EmpireStat)", asFUNCTION(getStatHistory));
|
|
stats.addExternBehaviour(asBEHAVE_RELEASE, "void f()", asFUNCTION(StatReader::destroy));
|
|
|
|
stats.addMethod("bool toTail()", asMETHOD(StatReader,toTail))
|
|
doc("Advances to the most recent stat entry.", "True if there was a tail to move to.");
|
|
stats.addMethod("bool toHead()", asMETHOD(StatReader,toHead))
|
|
doc("Advances to the earliest stat entry.", "True if there was a head to move to.");
|
|
|
|
stats.addMethod("bool advance(int offset = 1)", asMETHOD(StatReader,advance))
|
|
doc("Advances to another stat entry.", "Number of entries to move. Positive is later in time, negative is earlier. Advancing 0 resets the event reader. If not on a valid entry, advances to a valid entry at the correspending head or tail. ", "Returns true if an entry existed at the offset.");
|
|
stats.addMethod("int get_intVal() const", asMETHOD(StatReader,get_int))
|
|
doc("Returns the stat's value as an integer.", "");
|
|
stats.addMethod("float get_floatVal() const", asMETHOD(StatReader,get_float))
|
|
doc("Returns the stat's value as a float.", "");
|
|
stats.addMethod("uint get_time() const", asMETHOD(StatReader,get_time))
|
|
doc("Returns the stat's timestamp in seconds from the start of the game.", "");
|
|
|
|
stats.addMethod("bool advanceEvent()", asMETHOD(StatReader,advanceEvent))
|
|
doc("Advances to the next event for the current stat.", "True if there was an event to advance to.");
|
|
stats.addMethod("uint get_eventType() const", asMETHOD(StatReader,get_evt_type))
|
|
doc("Returns the current event's type identifier.", "");
|
|
stats.addMethod("string get_eventName() const", asMETHOD(StatReader,get_evt_name))
|
|
doc("Returns the current event's name.", "");
|
|
|
|
if(server) {
|
|
emp.addMethod("void recordStat(stat::EmpireStat, int)", asMETHODPR(Empire,recordStat,(unsigned,int),void))
|
|
doc("Records an int value for the specified empire stat at the current game time", "Stat index.", "Stat value.");
|
|
emp.addMethod("void recordStat(stat::EmpireStat, float)", asMETHODPR(Empire,recordStat,(unsigned,float),void))
|
|
doc("Records a float value for the specified empire stat at the current game time", "Stat index.", "Stat value.");
|
|
emp.addMethod("void recordStatDelta(stat::EmpireStat, int)", asMETHODPR(Empire,recordStatDelta,(unsigned,int),void))
|
|
doc("Records an int delta for the specified empire stat at the current game time", "Stat index.", "Stat delta.");
|
|
emp.addMethod("void recordStatDelta(stat::EmpireStat, float)", asMETHODPR(Empire,recordStatDelta,(unsigned,float),void))
|
|
doc("Records a float delta for the specified empire stat at the current game time", "Stat index.", "Stat delta.");
|
|
emp.addMethod("void recordEvent(stat::EmpireStat, uint16, const string &in)", asMETHOD(Empire,recordEvent))
|
|
doc("Records an event for the specified empire stat at the current game time", "Stat index.", "Event type.", "Event name.");
|
|
}
|
|
|
|
|
|
//Designs
|
|
emp.addMember("ReadWriteMutex designMutex", offsetof(Empire, designMutex));
|
|
emp.addExternMethod("uint get_designCount() const", asFUNCTION(getDesignCount));
|
|
emp.addExternMethod("const Design@ getDesign(const string &in)", asFUNCTION(getDesignByName));
|
|
emp.addExternMethod("const Design@ getDesign(int id)", asFUNCTION(getDesignById));
|
|
emp.addExternMethod("const Design@ get_designs(int)", asFUNCTION(getDesignById));
|
|
|
|
emp.addExternMethod("uint get_designClassCount() const", asFUNCTION(getDesignClassCount));
|
|
emp.addMethod("const DesignClass@ getDesignClass(int id)", asMETHODPR(Empire, getDesignClass, (int), DesignClass*));
|
|
emp.addMethod("const DesignClass@ getDesignClass(const string &in, bool add = true)", asMETHODPR(Empire, getDesignClass, (const std::string&, bool), DesignClass*));
|
|
emp.addMethod("bool addDesign(const DesignClass& cls, const Design&)", asMETHOD(Empire, addDesign));
|
|
emp.addMethod("bool changeDesign(const Design&, const Design&, const DesignClass@ cls = null)", asMETHODPR(Empire, changeDesign, (const Design*, const Design*, DesignClass*), bool));
|
|
emp.addMethod("const Design@+ updateDesign(const Design&, bool onlyOutdated = false)", asMETHODPR(Empire, updateDesign, (const Design*, bool), const Design*));
|
|
emp.addMethod("void flagDesignOld(const Design&)", asMETHODPR(Empire, flagDesignOld, (const Design*), void))
|
|
doc("Marks a design as out of date, to be updated whenever it is requested for construction.", "");
|
|
|
|
emp.addMethod("bool get_valid()", asMETHOD(Empire, valid));
|
|
|
|
//Subsystem modifiers
|
|
emp.addMember("ReadWriteMutex subsystemDataMutex", offsetof(Empire, subsystemDataMutex));
|
|
emp.addExternMethod("bool isUnlocked(const SubsystemDef& sys, const ModuleDef& mod)", asFUNCTION(ssModUnlocked));
|
|
emp.addExternMethod("bool isUnlocked(const SubsystemDef& sys)", asFUNCTION(ssUnlocked));
|
|
emp.addExternMethod("void setUnlocked(const SubsystemDef& sys, const ModuleDef& mod, bool unlocked)", asFUNCTION(ssSetModUnlock));
|
|
emp.addExternMethod("void setUnlocked(const SubsystemDef& sys, bool unlocked)", asFUNCTION(ssSetUnlock));
|
|
emp.addExternMethod("void removeModifier(const SubsystemDef& sys, uint id)", asFUNCTION(removeModifier));
|
|
|
|
emp.addExternMethod("void writeDelta(Message& msg)", asFUNCTION(writeDelta));
|
|
emp.addExternMethod("void readDelta(Message& msg)", asFUNCTION(readDelta));
|
|
|
|
std::string dargs;
|
|
for(unsigned i = 0; i <= MODIFY_STAGE_MAXARGS; ++i) {
|
|
emp.addGenericMethod(
|
|
format("uint addModifier(const SubsystemDef& def, const string&in$1)", dargs).c_str(),
|
|
asFUNCTION(addModifier_d));
|
|
dargs += ", float";
|
|
}
|
|
|
|
//Global empire lists
|
|
bindGlobal("Empire@ playerEmpire", &playerEmpire)
|
|
doc("The player's current empire.");
|
|
|
|
bindGlobal("Empire@ spectatorEmpire", &spectatorEmpire);
|
|
bindGlobal("Empire@ defaultEmpire", &defaultEmpire);
|
|
|
|
bind("uint getEmpireCount()", asFUNCTION(Empire::getEmpireCount));
|
|
bind("Empire@ getEmpire(uint index)", asFUNCTION(Empire::getEmpireByIndex));
|
|
bind("Empire@ getEmpireByID(uint8 id)", asFUNCTION(Empire::getEmpireByID));
|
|
|
|
RegisterEmpireComponentWrappers(emp, server);
|
|
}
|
|
|
|
};
|