Page MenuHomePhabricator (Chris)
Files F86467

No OneTemporary
Actions

Size
158 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/source/game/design/design.cpp b/source/game/design/design.cpp
index 0fd1260..d295ec6 100644
--- a/source/game/design/design.cpp
+++ b/source/game/design/design.cpp
@@ -1,1266 +1,1266 @@
#include "design/design.h"
#include "empire.h"
#include "network/message.h"
#include "util/save_file.h"
#include "main/references.h"
#include "main/logging.h"
#include "util/format.h"
#include "network/message.h"
#include <unordered_map>
#include <algorithm>
#include <queue>
#include <assert.h>
Design::Design(const Design::Descriptor& desc)
: hull(0), stateCount(0), effectorStateCount(0), dataCount(0), effectorCount(0),
initialized(false), id(-1), owner(0), used(false), obsolete(false), outdated(false), revision(0), cls(0), totalHP(0), forceHull(false), data(nullptr), clientData(nullptr), serverData(nullptr) {
init(desc);
}
Design::Design(net::Message& msg)
: hull(0), stateCount(0), effectorStateCount(0), dataCount(0), effectorCount(0),
initialized(false), id(-1), owner(0), used(false), obsolete(false), outdated(false), revision(0), cls(0), totalHP(0), forceHull(false), data(nullptr), clientData(nullptr), serverData(nullptr) {
init(msg);
}
Design::Design()
: hull(0), stateCount(0), effectorStateCount(0), dataCount(0), effectorCount(0),
initialized(false), id(-1), owner(0), used(false), obsolete(false), outdated(false), revision(0), cls(0), totalHP(0), forceHull(false), data(nullptr), clientData(nullptr), serverData(nullptr) {
}
void Design::init(const Design::Descriptor& desc) {
if(desc.hull == nullptr)
throw "Null Hull@ when creating design";
//Make an appropriate hull
HullDef* dynHull = nullptr;
if(!desc.staticHull) {
vec2i gridSize = desc.gridSize;
dynHull = new HullDef(*desc.hull);
dynHull->baseHull = desc.hull->baseHull;
hull = dynHull;
dynHull->activeCount = 0;
dynHull->exteriorCount = 0;
dynHull->gridSize = gridSize;
dynHull->gridOffset = recti();
dynHull->active.resize(gridSize.x, gridSize.y);
dynHull->active.clear(false);
dynHull->exterior.resize(gridSize.x, gridSize.y);
dynHull->exterior.clear(0);
dynHull->exteriorCount = 0;
//Add all used hexes to the dynamic hull
foreach(it, desc.systems) {
for(size_t i = 0, cnt = it->hexes.size(); i < cnt; ++i) {
vec2u v = it->hexes[i];
if(dynHull->active.valid(v)) {
dynHull->active[v] = true;
dynHull->activeCount += 1;
if(it->type->passExterior)
dynHull->exterior[v] |= HullDef::flagExteriorPass;
if(it->type->fauxExterior)
dynHull->exterior[v] |= HullDef::flagExteriorFaux;
}
}
}
dynHull->calculateExterior();
//Check for connectedness
if(!dynHull->checkConnected()) {
std::string errMsg = devices.locale.localize("ERROR_NOT_CONNECTED");
errors.push_back(DesignError(true, errMsg));
}
}
else {
hull = desc.hull;
hull->grab();
}
//Take over simple data
size = desc.size;
name = desc.name;
owner = desc.owner;
forceHull = desc.forceHull;
initialized = true;
numTags.insert(hull->numTags.begin(), hull->numTags.end());
if(owner && owner->shipset && !owner->shipset->hasHull(hull->baseHull)) {
std::string errMsg = devices.locale.localize("ERROR_HULL_NOT_IN_SHIPSET");
errors.push_back(DesignError(true, errMsg));
}
if(size < hull->minSize) {
std::string errMsg = format(devices.locale.localize("ERROR_MINIMUM_SIZE").c_str(),
hull->name, hull->minSize);
errors.push_back(DesignError(true, errMsg));
}
else if(hull->maxSize > 0 && size > hull->maxSize) {
std::string errMsg = format(devices.locale.localize("ERROR_MAXIMUM_SIZE").c_str(),
hull->name, hull->maxSize);
errors.push_back(DesignError(true, errMsg));
}
//Lock the things we need
if(owner)
owner->subsystemDataMutex.readLock();
grid.resize(hull->gridSize);
grid.clear(-1);
hexIndex.resize(hull->gridSize);
hexIndex.clear(-1);
hexStatusIndex.resize(hull->gridSize);
hexStatusIndex.clear(-1);
if(hull->activeCount != 0)
hexSize = size / (double)hull->activeCount;
else
hexSize = 0.0;
interiorHexes = 0;
exteriorHexes = 0;
usedHexCount = 0;
totalHP = 0.0;
for(unsigned i = 0; i < 4; ++i)
quadrantTotalHP[i] = 0.0;
//Add subsystems from the hull
std::vector<Descriptor::System> systems = desc.systems;
foreach(it, hull->subsystems) {
auto* type = getSubsystemDef(*it);
if(type) {
Descriptor::System sys;
sys.type = type;
sys.hexes.push_back(vec2u(-1, -1));
sys.modules.push_back(type->defaultModule);
systems.push_back(sys);
}
}
//Add applied subsystems
int appliedTag = desc.appliedSystems.empty() ? -1 : getSysTagIndex("Applied");
for(size_t i = 0, cnt = desc.appliedSystems.size(); i < cnt; ++i) {
auto* type = desc.appliedSystems[i];
if(type) {
Descriptor::System sys;
sys.type = type;
sys.hexes.push_back(vec2u(-1, -1));
sys.modules.push_back(type->defaultModule);
systems.push_back(sys);
if(!type->hasTag(appliedTag)) {
std::string errMsg = format(devices.locale.localize("ERROR_CANNOT_APPLY").c_str(), type->name);
errors.push_back(DesignError(true, errMsg));
}
else {
for(unsigned n = 0, ncnt = type->getTagValueCount(appliedTag); n < ncnt; ++n) {
std::string tag = type->getTagValue(appliedTag, n);
for(size_t j = 0; j < i; ++j) {
if(desc.appliedSystems[j] && desc.appliedSystems[j]->hasTagValue(appliedTag, tag)) {
std::string errMsg = format(devices.locale.localize("ERROR_ONE_APPLIED").c_str(), devices.locale.localize(format("APPLIED_$1", tag)));
errors.push_back(DesignError(true, errMsg));
}
}
}
}
}
}
//Initialize subsystems
HexGrid<bool> connected(grid.width, grid.height);
subsystems.resize(systems.size());
cropMin = vec2u(grid.width, grid.height);
cropMax = vec2u(0, 0);
for(unsigned index = 0; index < systems.size(); ++index) {
const Design::Descriptor::System& sd = systems[index];
if(!sd.type)
break;
numTags.insert(sd.type->numTags.begin(), sd.type->numTags.end());
Subsystem* sys = &subsystems[index];
sys->init(*sd.type);
sys->inDesign = this;
sys->index = index;
sys->direction = sd.direction;
sys->hexes.reserve(sd.hexes.size());
sys->stateOffset = stateCount;
sys->effectorOffset = effectorCount;
auto modCnt = sys->type->modules.size();
sys->moduleCounts.resize(modCnt);
for(size_t i = 0; i < modCnt; ++i)
sys->moduleCounts[i] = 0;
//Set up effector states
int effStates = 0;
for(size_t i = 0, cnt = sd.type->effectors.size(); i < cnt; ++i) {
sys->effectors[i].stateOffset = effectorStateCount;
effStates += sd.type->effectors[i].type->stateCount;
}
//Copy hexes
int hexInd = 0;
for(size_t i = 0, cnt = sd.hexes.size(); i < cnt; ++i) {
vec2u v = sd.hexes[i];
auto* mod = sd.modules[i];
if(!mod)
mod = sys->type->defaultModule;
if(!sd.type->isHull && !sd.type->isApplied) {
if(v.x >= grid.width || v.y >= grid.height)
continue;
if(!hull->active[v])
continue;
if(grid[v] != -1)
continue;
if(hull->isExterior(v)) {
++sys->exteriorHexes;
++exteriorHexes;
}
else {
++interiorHexes;
}
grid[v] = index;
hexIndex[v] = hexInd++;
hexStatusIndex[v] = usedHexCount++;
cropMin.x = std::min(cropMin.x, v.x);
cropMin.y = std::min(cropMin.y, v.y);
cropMax.x = std::max(cropMax.x, v.x);
cropMax.y = std::max(cropMax.y, v.y);
}
sys->hexes.push_back(v);
sys->modules.push_back(mod);
hexes.push_back(v);
++sys->moduleCounts[mod->index];
}
unsigned efftrCount = (unsigned)sd.type->effectors.size();
for(unsigned i = 0; i < efftrCount; ++i) {
sys->effectors[i].inDesign = this;
sys->effectors[i].subsysIndex = sys->index;
}
stateCount += (unsigned)sd.type->states.size();
effectorCount += efftrCount;
effectorStateCount += effStates;
if(sys->type->isContiguous && !sys->type->isHull && !sys->type->isApplied && !sys->hexes.empty()) {
connected.zero();
sys->markConnected(connected, sys->hexes[0]);
for(size_t i = 1, cnt = sys->hexes.size(); i < cnt; ++i) {
if(!connected[sys->hexes[i]]) {
std::string errMsg = format(devices.locale.localize("ERROR_NOT_CONTIGUOUS").c_str(), sys->type->name);
errors.push_back(DesignError(true, errMsg, sys));
sys->hasErrors = true;
break;
}
}
}
}
//Prepare ship variables
unsigned shipVarCnt = getShipVariableCount();
shipVariables = new float[shipVarCnt];
memset(shipVariables, 0, shipVarCnt * sizeof(float));
//Store calculated hex size
if((unsigned)ShV_HexSize < shipVarCnt)
shipVariables[ShV_HexSize] = hexSize;
//Evaluate subsystem variables
std::priority_queue<std::pair<int,Subsystem*>> sysQueue;
foreach(it, subsystems)
sysQueue.push(std::pair<int,Subsystem*>(-it->type->ordering, &*it));
Colorf colf(0.f, 0.f, 0.f, 0.f);
while(!sysQueue.empty()) {
auto* sys = sysQueue.top().second;
sys->initVariables(this);
sysQueue.pop();
float* sysSize = sys->variable(SV_Size);
if(sysSize) {
float relSize = *sysSize / (float)size;
Colorf sysColor(sys->type->typeColor);
sysColor *= sysColor.a;
sysColor.a = 1.f;
colf += sysColor * (relSize * relSize);
}
}
colf.a = 1.f;
float hue = colf.getHue();
colf.fromHSV(hue, 1.f, 1.f);
color = Color(colf);
colf.fromHSV(hue, 0.6f, 0.6f);
dullColor = Color(colf);
//Evaluate adjacency mods
foreach(it, subsystems)
it->applyAdjacencies(this);
//Evaluate subsystem asserts
foreach(it, subsystems)
it->evaluateAsserts(this);
//Evaluate subsystem posts
foreach(it, subsystems)
it->evaluatePost(this);
//Evaluate subsystem effects
foreach(it, subsystems) {
it->initEffects(this);
if(owner)
it->skinEffectors(*owner);
it->dataOffset = dataCount;
dataCount += it->hookClasses.size();
}
//Calculate total HP
foreach(it, subsystems) {
auto& sys = *it;
unsigned hexCnt = (unsigned)sys.hexes.size();
for(unsigned j = 0; j < hexCnt; ++j) {
float* hexVal = sys.hexVariable(HV_HP, j);
if(hexVal) {
totalHP += *hexVal;
quadrantTotalHP[getQuadrant(sys.hexes[j])] += *hexVal;
}
}
}
//Record possibly altered hex size
if((unsigned)ShV_HexSize < shipVarCnt)
hexSize = shipVariables[ShV_HexSize];
//Unlock the things we locked
if(owner)
owner->subsystemDataMutex.release();
//Create a secondary damage order list for globalDamage events
buildDamageOrder();
}
void Design::buildDamageOrder() {
damageOrder.clear();
foreach(it, subsystems) {
auto* sys = &*it;
if(sys->hasGlobalDamage())
damageOrder.push_back(sys);
}
std::sort(damageOrder.begin(), damageOrder.end(), [](Subsystem* first, Subsystem* second) -> bool {
return first->type->damageOrder < second->type->damageOrder;
});
}
bool Design::hasFatalErrors() const {
foreach(it, errors)
if(it->fatal)
return true;
return false;
}
bool Design::hasTag(const std::string& tag) const {
foreach(it, subsystems)
if(it->type->hasTag(tag))
return true;
return false;
}
bool Design::hasTag(int index) const {
auto it = numTags.find(index);
return it != numTags.end();
}
const Design* Design::newest() const {
const Design* cur = this;
if(original)
cur = original;
while(cur->newer)
cur = cur->newer;
while(cur->updated)
cur = cur->updated;
return cur;
}
const Design* Design::next() const {
if(original)
return original->newer;
return newer;
}
const Design* Design::mostUpdated() const {
const Design* cur = this;
while(cur->updated)
cur = cur->updated;
return cur;
}
const Design* Design::base() const {
return original ? original.ptr : this;
}
Design::~Design() {
delete[] shipVariables;
hull->drop();
if(original == nullptr || original == this) {
if(data) {
delete data;
data = nullptr;
}
if(clientData) {
clientData->Release();
clientData = nullptr;
}
if(serverData) {
serverData->Release();
serverData = nullptr;
}
}
}
unsigned Design::getQuadrant(const vec2u& pos) const {
unsigned quad = 0;
int dist = pos.y - cropMin.y;
int d = cropMax.x - pos.x;
if(d < dist) {
quad = 1;
dist = d;
}
d = cropMax.y - pos.y;
if(d < dist) {
quad = 2;
dist = d;
}
d = pos.x - cropMin.x;
if(d < dist) {
quad = 3;
dist = d;
}
return quad;
}
void Design::makeDistanceMap(Image& img, vec2i pos, vec2i size) const {
int xspac = 1;
int yspac = 1 + ceil(double(size.y) * 0.1);
double xrat = double(size.x-xspac-xspac) / double(hull->active.width) / 0.75;
double yrat = double(size.y-yspac-yspac) / double(hull->active.height);
double distFact = 40.0 / yrat;
for(int y = yspac; y < size.y-yspac; ++y) {
for(int x = xspac; x < size.x-xspac; ++x) {
vec2d pctPos(double(x-xspac) / double(size.x-xspac-xspac), double(y-yspac) / double(size.y-yspac-yspac));
vec2d grid(double(x-xspac) / xrat, double(y-yspac) / yrat);
vec2i gridPos = hull->active.getGridPosition(grid);
double dist = 100.0;
if(hull->active.valid(gridPos) && hull->active[gridPos]) {
vec2d gridPct = hull->active.getEffectivePosition(gridPos);
gridPct.x += 0.75 * 0.5;
gridPct.y += 0.5;
gridPct.x /= 0.75 * double(hull->active.width);
gridPct.y /= double(hull->active.height);
dist = std::min(pctPos.distanceTo(gridPct), dist);
}
for(unsigned i = 0; i < 6; ++i) {
vec2u pos = vec2u(gridPos);
if(hull->active.advance(pos.x, pos.y, (HexGridAdjacency)i)) {
if(hull->active.valid(pos) && hull->active[pos]) {
vec2d gridPct = hull->active.getEffectivePosition(pos);
gridPct.x += 0.75 * 0.5;
gridPct.y += 0.5;
gridPct.x /= 0.75 * double(hull->active.width);
gridPct.y /= double(hull->active.height);
dist = std::min(pctPos.distanceTo(gridPct), dist);
}
}
}
Color& col = img.get_rgba(x+pos.x, pos.y+y);
col.color = 0xff0000ff;
dist *= distFact;
if(dist < 0.8)
col.a = 0xff;
else
col.a = 0x00;
if(dist > 0.6 && dist < 1.5)
col.b = 0xff;
else
col.b = 0x00;
if(dist < 0.5)
col.g = 0xff;
else
col.g = 255.0 * std::max(1.0 - (dist-0.5)*2.0, 0.0);
}
}
}
void Design::toDescriptor(Design::Descriptor& desc) const {
desc.owner = owner;
desc.hull = hull;
if(hull)
hull->grab();
desc.name = name;
desc.size = size;
desc.forceHull = forceHull;
desc.gridSize = hull->gridSize;
if(cls)
desc.className = cls->name;
else
desc.className = "";
unsigned short sysCnt = (unsigned short)subsystems.size();
desc.systems.reserve(sysCnt);
for(unsigned short i = 0; i < sysCnt; ++i) {
auto& sys = subsystems[i];
if(sys.type->isHull)
continue;
if(sys.type->isApplied) {
desc.appliedSystems.push_back(sys.type);
continue;
}
desc.systems.push_back(Design::Descriptor::System());
Design::Descriptor::System& sdesc = desc.systems.back();
sdesc.direction = sys.direction;
sdesc.type = sys.type;
unsigned short hexCnt = (unsigned short)sys.hexes.size();
sdesc.hexes.resize(hexCnt);
sdesc.modules.resize(hexCnt);
for(unsigned short j = 0; j < hexCnt; ++j) {
sdesc.hexes[j] = sys.hexes[j];
sdesc.modules[j] = sys.modules[j];
}
}
}
void Design::write(net::Message& msg) const {
if(owner)
msg << owner->id;
else
msg << INVALID_EMPIRE;
msg.writeSmall(hull->baseHull->id);
msg << name;
msg << size;
msg << forceHull;
msg << obsolete;
msg << revision;
msg.writeSmall(hull->gridSize.width);
msg.writeSmall(hull->gridSize.height);
msg.writeSmall((unsigned)subsystems.size());
for(unsigned i = 0, sysCnt = (unsigned)subsystems.size(); i < sysCnt; ++i) {
auto& sys = subsystems[i];
if(sys.type->isHull) {
msg.writeSignedSmall(-1);
continue;
}
msg.writeSignedSmall(sys.type->index);
if(sys.type->isApplied)
continue;
msg.writeDirection(sys.direction.x, sys.direction.y, sys.direction.z);
msg.writeSmall((unsigned)sys.hexes.size());
vec2u gridSize = vec2u(hull->gridSize);
for(unsigned short j = 0, hexCnt = (unsigned)sys.hexes.size(); j < hexCnt; ++j) {
vec2u pos = sys.hexes[j];
msg.writeLimited(pos.x, gridSize.width);
msg.writeLimited(pos.y, gridSize.height);
msg.writeSignedSmall(sys.modules[j]->index);
}
}
//Script data
if(data != nullptr) {
msg.write1();
char* pData; net::msize_t size;
data->getAsPacket(pData, size);
msg.writeSmall(size);
msg.write(pData, size);
}
else {
msg.write0();
}
}
void Design::init(net::Message& msg) {
Descriptor desc;
//Read empire
unsigned char empID;
msg >> empID;
desc.owner = Empire::getEmpireByID(empID);
//Read hull
desc.hull = getHullDefinition(msg.readSmall());
if(desc.hull)
desc.hull->grab();
//Get other blueprint data
msg >> desc.name;
msg >> desc.size;
msg >> desc.forceHull;
msg >> obsolete;
msg >> revision;
desc.gridSize.x = msg.readSmall();
desc.gridSize.y = msg.readSmall();
//Read subsystems
unsigned sysCnt = msg.readSmall();
desc.systems.reserve(sysCnt);
for(unsigned i = 0; i < sysCnt; ++i) {
int sysIndex = msg.readSignedSmall();
if(sysIndex == -1)
continue;
auto* type = getSubsystemDef(sysIndex);
if(type->isApplied) {
desc.appliedSystems.push_back(type);
continue;
}
desc.systems.push_back(Design::Descriptor::System());
Design::Descriptor::System& sys = desc.systems.back();
sys.type = type;
msg.readDirection(sys.direction.x, sys.direction.y, sys.direction.z);
unsigned hexCnt = msg.readSmall();
sys.hexes.resize(hexCnt);
sys.modules.resize(hexCnt);
for(unsigned j = 0; j < hexCnt; ++j) {
unsigned x = msg.readLimited(desc.gridSize.width);
unsigned y = msg.readLimited(desc.gridSize.height);
sys.hexes[j] = vec2u(x, y);
int modIndex = msg.readSignedSmall();
if(sys.type == 0 || modIndex < 0 || modIndex >= (int)sys.type->modules.size())
sys.modules[j] = 0;
else
sys.modules[j] = sys.type->modules[modIndex];
}
}
//Initialize design
init(desc);
//Script data
if(msg.readBit()) {
net::msize_t size = msg.readSmall();
data = new net::Message();
if(size > 0) {
char* buffer = (char*)malloc(size);
msg.read(buffer, size);
data->setPacket(buffer, size);
free(buffer);
}
bindData();
}
}
static asIScriptObject* buildDataForEngine(scripts::Manager* man, void* msg, unsigned call) {
//Create the object
asITypeInfo* cls = man->getClass("design_settings", "DesignSettings");
if(cls == nullptr)
return nullptr;
asIScriptFunction* func = cls->GetFactoryByIndex(0);
if(!func)
return nullptr;
asIScriptObject* ptr = 0;
{
scripts::Call cl = man->call(func);
cl.call(ptr);
if(ptr)
ptr->AddRef();
}
//Read the mesasge
auto* readFunc = (asIScriptFunction*)man->engine->GetUserData(call);
if(ptr && readFunc) {
scripts::Call cl = man->call(readFunc);
cl.setObject(ptr);
cl.push(msg);
cl.call();
}
return ptr;
}
void Design::bindData() {
if(data) {
data->rewind();
clientData = buildDataForEngine(devices.scripts.client, data, scripts::EDID_SerializableRead);
data->rewind();
serverData = buildDataForEngine(devices.scripts.server, data, scripts::EDID_SerializableRead);
data->rewind();
}
}
Design::Design(SaveFile& file) : initialized(true), data(nullptr), clientData(nullptr), serverData(nullptr) {
file >> name >> size >> hexSize >> interiorHexes >> exteriorHexes
>> stateCount >> effectorStateCount >> effectorCount >> usedHexCount
>> used >> obsolete >> id >> revision >> totalHP >> color >> dullColor;
if(file >= SFV_0002)
file >> outdated;
else
outdated = false;
built.set_basic(file);
active.set_basic(file);
if(file >= SFV_0008)
file >> dataCount;
else
dataCount = 0;
if(file >= SFV_0016)
file >> forceHull;
else
forceHull = false;
unsigned hullID;
if(file >= SFV_0004) {
hullID = file.readIdentifier(SI_Hull);
}
else {
unsigned oldID = file;
auto* set = getShipset("Original_r3000");
hullID = set->hulls[oldID]->id;
}
hull = getHullDefinition(hullID);
if(hull == 0)
throw SaveFileError("Design lacks hull");
numTags.insert(hull->numTags.begin(), hull->numTags.end());
owner = Empire::getEmpireByID(file);
if(owner == 0)
throw SaveFileError("Design lacks owner");
//if(owner->shipset && !owner->shipset->hasHull(hull))
// throw SaveFileError("Hull is not present in the owner's shipset");
if(file >= SFV_0013) {
bool dynamic = file;
if(dynamic) {
auto* dynHull = new HullDef(*hull);
file >> dynHull->gridSize;
file >> dynHull->activeCount;
file >> dynHull->exteriorCount;
dynHull->gridOffset = recti();
dynHull->active.resize(dynHull->gridSize.x, dynHull->gridSize.y);
dynHull->active.clear(false);
dynHull->exterior.resize(dynHull->gridSize.x, dynHull->gridSize.y);
dynHull->exterior.clear(0);
for(size_t i = 0, cnt = dynHull->active.length(); i < cnt; ++i) {
file >> dynHull->active[i];
file >> dynHull->exterior[i];
}
dynHull->baseHull = hull;
hull = dynHull;
}
else {
hull->grab();
}
}
else {
hull->grab();
}
//Hex grids
grid.resize(hull->gridSize);
hexIndex.resize(hull->gridSize);
hexStatusIndex.resize(hull->gridSize);
file.read(grid.data, sizeof(int) * grid.width * grid.height);
file.read(hexIndex.data, sizeof(int) * hexIndex.width * hexIndex.height);
file.read(hexStatusIndex.data, sizeof(int) * hexStatusIndex.width * hexStatusIndex.height);
unsigned hexesCount = file;
hexes.resize(hexesCount);
- file.read(&hexes.front(), sizeof(vec2u) * hexesCount);
+ file.read(hexes.data(), sizeof(vec2u) * hexesCount);
cropMin = vec2u(grid.width, grid.height);
cropMax = vec2u(0, 0);
foreach(h, hexes) {
if(hull->active.valid(*h)) {
cropMin.x = std::min(cropMin.x, h->x);
cropMin.y = std::min(cropMin.y, h->y);
cropMax.x = std::max(cropMax.x, h->x);
cropMax.y = std::max(cropMax.y, h->y);
}
}
unsigned shipVarCount = getShipVariableCount();
shipVariables = new float[shipVarCount]();
unsigned cnt = file;
for(unsigned i = 0; i < cnt; ++i) {
int index = file.readIdentifier(SI_ShipVar);
if(index != -1)
file >> shipVariables[index];
else
file.read<float>();
}
//Subsystems
unsigned subsysCount = file;
subsystems.resize(subsysCount);
for(unsigned i = 0; i < subsysCount; ++i) {
auto& sys = subsystems[i];
sys.init(file);
sys.inDesign = this;
sys.index = i;
auto efftrcnt = sys.type->effectors.size();
for(size_t j = 0; j < efftrcnt; ++j) {
sys.effectors[j].inDesign = this;
sys.effectors[j].subsysIndex = i;
}
numTags.insert(sys.type->numTags.begin(), sys.type->numTags.end());
}
if(file >= SFV_0020) {
for(unsigned i = 0; i < 4; ++i)
file >> quadrantTotalHP[i];
}
else {
for(unsigned i = 0; i < 4; ++i)
quadrantTotalHP[i] = 0.0;
foreach(it, subsystems) {
auto& sys = *it;
unsigned hexCnt = (unsigned)sys.hexes.size();
for(unsigned j = 0; j < hexCnt; ++j) {
float* hexVal = sys.hexVariable(HV_HP, j);
if(hexVal)
quadrantTotalHP[getQuadrant(sys.hexes[j])] += *hexVal;
}
}
}
for(unsigned i = 0; i < subsysCount; ++i)
subsystems[i].postLoad(this);
//Script data
if(file >= SFV_0018) {
if(file.read<bool>()) {
unsigned size = file;
SaveMessage msg(file);
if(size > 0) {
char* buffer = (char*)malloc(size);
file.read(buffer, size);
msg.setPacket(buffer, size);
free(buffer);
}
serverData = buildDataForEngine(devices.scripts.server, &msg, scripts::EDID_SavableRead);
data = new net::Message();
auto* writeFunc = (asIScriptFunction*)devices.scripts.server->engine->GetUserData(scripts::EDID_SerializableWrite);
if(writeFunc) {
scripts::Call cl = devices.scripts.server->call(writeFunc);
cl.setObject(serverData);
cl.push(data);
cl.call();
}
clientData = buildDataForEngine(devices.scripts.client, data, scripts::EDID_SerializableRead);
}
}
buildDamageOrder();
}
void Design::save(SaveFile& file) const {
file << name << size << hexSize << interiorHexes << exteriorHexes
<< stateCount << effectorStateCount << effectorCount << usedHexCount
<< used << obsolete << id << revision << totalHP << color << dullColor;
file << outdated;
file << built.get() << active.get();
file << dataCount;
file << forceHull;
file.writeIdentifier(SI_Hull, hull->baseHull->id);
file << owner->id;
if(hull != hull->baseHull) {
file << true;
file << hull->gridSize;
file << hull->activeCount << hull->exteriorCount;
for(size_t i = 0, cnt = hull->active.length(); i < cnt; ++i) {
file << hull->active[i];
file << hull->exterior[i];
}
}
else
file << false;
//Hex grids
file.write(grid.data, sizeof(int) * grid.width * grid.height);
file.write(hexIndex.data, sizeof(int) * hexIndex.width * hexIndex.height);
file.write(hexStatusIndex.data, sizeof(int) * hexStatusIndex.width * hexStatusIndex.height);
file << (unsigned)hexes.size();
- file.write(&hexes.front(), sizeof(vec2u) * (unsigned)hexes.size());
+ file.write(hexes.data(), sizeof(vec2u) * (unsigned)hexes.size());
unsigned cnt = getShipVariableCount();
file << cnt;
for(unsigned i = 0; i < cnt; ++i) {
file.writeIdentifier(SI_ShipVar, i);
file << shipVariables[i];
}
//Subsystems
file << unsigned(subsystems.size());
for(unsigned i = 0; i < subsystems.size(); ++i)
subsystems[i].save(file);
for(unsigned i = 0; i < 4; ++i)
file << quadrantTotalHP[i];
//Script data
if(serverData != nullptr && (original == nullptr || original == this)) {
SaveMessage msg(file);
auto* writeFunc = (asIScriptFunction*)devices.scripts.server->engine->GetUserData(scripts::EDID_SavableWrite);
if(writeFunc) {
file << true;
{
scripts::Call cl = devices.scripts.server->call(writeFunc);
cl.setObject(serverData);
cl.push(&msg);
cl.call();
}
char* pData; net::msize_t size;
msg.getAsPacket(pData, size);
file << size;
file.write(pData, size);
}
else {
file << false;
}
}
else {
file << false;
}
}
void Design::writeData(net::Message& msg) const {
msg.writeSmall(hull->baseHull->id);
msg << name;
msg << size;
msg << hexSize;
msg.writeSmall(interiorHexes);
msg.writeSmall(exteriorHexes);
msg.writeSmall(usedHexCount);
msg.writeSmall(stateCount);
msg.writeSmall(effectorStateCount);
msg.writeSmall(effectorCount);
msg << initialized;
msg << totalHP;
for(unsigned i = 0; i < 4; ++i)
msg << quadrantTotalHP[i];
msg << color;
msg << dullColor;
msg << forceHull;
if(hull != hull->baseHull) {
msg.write1();
msg.writeSmall(hull->gridSize.x);
msg.writeSmall(hull->gridSize.y);
}
else {
msg.write0();
}
msg.writeSmall((unsigned)numTags.size());
foreach(it, numTags)
msg.writeSmall(*it);
msg.writeSmall((unsigned)subsystems.size());
foreach(it, subsystems)
it->writeData(msg);
for(unsigned i = 0, cnt = (unsigned)grid.length(); i < cnt; ++i) {
if(grid[i] == -1) {
msg.write0();
}
else {
msg.write1();
msg.writeSmall(grid[i]);
}
if(hexIndex[i] == -1) {
msg.write0();
}
else {
msg.write1();
msg.writeSmall(hexIndex[i]);
}
if(hexStatusIndex[i] == -1) {
msg.write0();
}
else {
msg.write1();
msg.writeSmall(hexStatusIndex[i]);
}
}
msg.writeSmall((unsigned)hexes.size());
foreach(it, hexes) {
msg.writeSmall(it->x);
msg.writeSmall(it->y);
}
for(size_t i = 0, cnt = getShipVariableCount(); i < cnt; ++i)
msg << shipVariables[i];
msg << id;
msg.writeSmall(owner->id);
msg << used;
msg << obsolete;
msg << revision;
msg.writeSmall(built.get());
msg.writeSmall(active.get());
if(newer) {
msg.write1();
msg.writeSmall(newer->id);
}
else {
msg.write0();
}
if(original) {
msg.write1();
msg.writeSmall(original->id);
}
else {
msg.write0();
}
if(updated) {
msg.write1();
msg.writeSmall(updated->id);
}
else {
msg.write0();
}
msg << cls->name;
//Script data
if(data != nullptr) {
msg.write1();
char* pData; net::msize_t size;
data->getAsPacket(pData, size);
msg.writeSmall(size);
msg.write(pData, size);
}
else {
msg.write0();
}
}
void Design::initData(net::Message& msg) {
hull = getHullDefinition(msg.readSmall());
msg >> name;
msg >> size;
msg >> hexSize;
interiorHexes = msg.readSmall();
exteriorHexes = msg.readSmall();
usedHexCount = msg.readSmall();
stateCount = msg.readSmall();
effectorStateCount = msg.readSmall();
effectorCount = msg.readSmall();
dataCount = 0;
msg >> initialized;
msg >> totalHP;
for(unsigned i = 0; i < 4; ++i)
msg >> quadrantTotalHP[i];
msg >> color;
msg >> dullColor;
msg >> forceHull;
HullDef* dynHull = nullptr;
if(msg.readBit()) {
dynHull = new HullDef(*hull);
dynHull->baseHull = hull;
hull = dynHull;
dynHull->gridSize.x = msg.readSmall();
dynHull->gridSize.y = msg.readSmall();
dynHull->activeCount = 0;
dynHull->exteriorCount = 0;
dynHull->gridOffset = recti();
dynHull->active.resize(dynHull->gridSize.x, dynHull->gridSize.y);
dynHull->active.clear(false);
dynHull->exterior.resize(dynHull->gridSize.x, dynHull->gridSize.y);
dynHull->exterior.clear(0);
}
unsigned cnt = msg.readSmall();
for(unsigned i = 0; i < cnt; ++i)
numTags.insert(msg.readSmall());
subsystems.resize(msg.readSmall());
for(size_t i = 0, cnt = subsystems.size(); i < cnt; ++i) {
auto* sys = &subsystems[i];
sys->~Subsystem();
new(sys) Subsystem(msg);
sys->inDesign = this;
sys->index = (unsigned)i;
unsigned efftrCount = (unsigned)sys->type->effectors.size();
for(unsigned n = 0; n < efftrCount; ++n) {
sys->effectors[n].inDesign = this;
sys->effectors[n].subsysIndex = (unsigned)i;
sys->effectors[n].effectorIndex = n;
}
}
grid.resize(hull->gridSize);
hexIndex.resize(hull->gridSize);
hexStatusIndex.resize(hull->gridSize);
for(unsigned i = 0, cnt = (unsigned)grid.length(); i < cnt; ++i) {
if(msg.readBit()) {
grid[i] = msg.readSmall();
assert(grid[i] < 0 || grid[i] < (int)subsystems.size());
}
else
grid[i] = -1;
if(msg.readBit())
hexIndex[i] = msg.readSmall();
else
hexIndex[i] = -1;
if(msg.readBit())
hexStatusIndex[i] = msg.readSmall();
else
hexStatusIndex[i] = -1;
}
cropMin = vec2u(grid.width, grid.height);
cropMax = vec2u(0, 0);
hexes.resize(msg.readSmall());
for(size_t i = 0, cnt = hexes.size(); i < cnt; ++i) {
hexes[i].x = msg.readSmall();
hexes[i].y = msg.readSmall();
if(dynHull) {
if(dynHull->active.valid(hexes[i]))
dynHull->active[hexes[i]] = true;
}
if(hull->active.valid(hexes[i])) {
cropMin.x = std::min(cropMin.x, hexes[i].x);
cropMin.y = std::min(cropMin.y, hexes[i].y);
cropMax.x = std::max(cropMax.x, hexes[i].x);
cropMax.y = std::max(cropMax.y, hexes[i].y);
}
}
shipVariables = new float[getShipVariableCount()];
for(size_t i = 0, cnt = getShipVariableCount(); i < cnt; ++i)
msg >> shipVariables[i];
msg >> id;
unsigned ownerId = msg.readSmall();
owner = Empire::getEmpireByID(ownerId);
msg >> used;
msg >> obsolete;
msg >> revision;
built = msg.readSmall();
active = msg.readSmall();
if(msg.readBit())
newer = owner->getDesignMake(msg.readSmall());
if(msg.readBit())
original = owner->getDesignMake(msg.readSmall());
if(msg.readBit())
updated = owner->getDesignMake(msg.readSmall());
std::string clsname;
msg >> clsname;
cls = owner->getDesignClass(clsname);
if(dynHull)
dynHull->calculateExterior();
//Script data
if(msg.readBit()) {
net::msize_t size = msg.readSmall();
data = new net::Message();
if(size > 0) {
char* buffer = (char*)malloc(size);
msg.read(buffer, size);
data->setPacket(buffer, size);
free(buffer);
}
bindData();
}
buildDamageOrder();
}
diff --git a/source/game/design/subsystem.cpp b/source/game/design/subsystem.cpp
index d1d13c2..fa03a91 100644
--- a/source/game/design/subsystem.cpp
+++ b/source/game/design/subsystem.cpp
@@ -1,3970 +1,3970 @@
#include "design/subsystem.h"
#include "design/design.h"
#include "design/hull.h"
#include "main/initialization.h"
#include "main/references.h"
#include "network/network_manager.h"
#include "main/logging.h"
#include "scripts/manager.h"
#include "str_util.h"
#include "util/format.h"
#include "util/save_file.h"
#include "threads.h"
#include "compat/misc.h"
#include "empire.h"
#include "obj/blueprint.h"
#include <algorithm>
#include <unordered_map>
#include <queue>
std::vector<SubsystemDef*> subsystems;
umap<std::string, int> subsystemIndices;
umap<std::string, int> variableIndices;
umap<std::string, int> hexVariableIndices;
umap<std::string, int> shipVariableIndices;
umap<std::string, int> numericTags;
asIScriptFunction* Subsystem::ScriptInitFunction;
asIScriptFunction* Subsystem::ScriptHookFunctions[EH_COUNT];
std::vector<SubsystemDef::ModuleDesc*> ModulesByID;
std::vector<SubsystemDef::ModifyStage*> ModifiersByID;
int getSubsystemDefCount() {
return (int)subsystems.size();
}
void enumerateVariables(std::function<void(const std::string&,int)> cb) {
foreach(it, variableIndices)
cb(it->first, it->second);
}
void enumerateHexVariables(std::function<void(const std::string&,int)> cb) {
foreach(it, hexVariableIndices)
cb(it->first, it->second);
}
void enumerateShipVariables(std::function<void(const std::string&,int)> cb) {
foreach(it, shipVariableIndices)
cb(it->first, it->second);
}
void enumerateSysTags(std::function<void(const std::string&,int)> cb) {
foreach(it, numericTags)
cb(it->first, it->second);
}
const SubsystemDef* getSubsystemDef(const std::string& name) {
auto it = subsystemIndices.find(name);
if(it == subsystemIndices.end())
return 0;
return subsystems[it->second];
}
const SubsystemDef* getSubsystemDef(int id) {
if(id < 0 || id >= (int)subsystems.size())
return 0;
return subsystems[id];
}
int getVariableIndex(const std::string& name) {
auto it = variableIndices.find(name);
if(it == variableIndices.end())
return -1;
return it->second;
}
int getHexVariableIndex(const std::string& name) {
auto it = hexVariableIndices.find(name);
if(it == hexVariableIndices.end())
return -1;
return it->second;
}
unsigned getShipVariableCount() {
return (unsigned)shipVariableIndices.size();
}
int getShipVariableIndex(const std::string& name) {
auto it = shipVariableIndices.find(name);
if(it == shipVariableIndices.end())
return -1;
return it->second;
}
int getSysTagIndex(const std::string& name, bool create) {
auto it = numericTags.find(name);
if(it == numericTags.end()) {
if(create) {
unsigned index = numericTags.size();
numericTags[name] = index;
return index;
}
return -1;
}
return it->second;
}
const std::string errStr = "N/A";
const std::string& getVariableId(int index) {
//TODO: Make not slow
foreach(it, variableIndices) {
if(it->second == index)
return it->first;
}
return errStr;
}
const std::string& getHexVariableId(int index) {
//TODO: Make not slow
foreach(it, hexVariableIndices) {
if(it->second == index)
return it->first;
}
return errStr;
}
const std::string& getShipVariableId(int index) {
//TODO: Make not slow
foreach(it, shipVariableIndices) {
if(it->second == index)
return it->first;
}
return errStr;
}
enum VariableType {
VTF_BaseVariable = 1 << 31,
VT_ConstantVariable = 0 << 24,
VT_SubsystemVariable = 1 << 24,
VT_HexVariable = 2 << 24,
VT_ModuleCount = 3 << 24,
VT_ModuleExists = 4 << 24,
VT_Argument = 5 << 24,
VT_ShipVariable = 6 << 24,
VT_GameConfig = 7 << 24,
VT_SumVariable = 8 << 24,
VT_HexSumVariable = 9 << 24,
VT_TagCountVariable = 10 << 24,
VT_AdjacentTag = 11 << 24,
VT_AdjacentSubsystem = 12 << 24,
};
enum ConstantVariable { //:P
CV_Hexes,
CV_InteriorHexes,
CV_ExteriorHexes,
CV_HexSize,
CV_HexExterior,
CV_ShipSize,
CV_ShipTotalHexes,
CV_ShipUsedHexes,
CV_ShipEmptyHexes,
CV_AdjacentActive,
CV_AdjacentThis,
CV_IsCore,
};
Threaded(const SubsystemDef*) formulaSubsystem = 0;
Threaded(const SubsystemDef::ModifyStage*) formulaModifier = 0;
Threaded(bool) formulaQuiet = false;
static int formulaVarIndex(const std::string* nameptr) {
std::string name = *nameptr;
//Arguments
if(formulaModifier) {
auto it = formulaModifier->argumentNames.find(name);
if(it != formulaModifier->argumentNames.end())
return VT_Argument | it->second;
}
//Constant variables
if(name == "Hexes")
return VT_ConstantVariable | CV_Hexes;
else if(name == "InteriorHexes")
return VT_ConstantVariable | CV_InteriorHexes;
else if(name == "ExteriorHexes")
return VT_ConstantVariable | CV_ExteriorHexes;
else if(name == "HexSize")
return VT_ShipVariable | ShV_HexSize;
else if(name == "ShipSize")
return VT_ConstantVariable | CV_ShipSize;
else if(name == "ShipUsedHexes")
return VT_ConstantVariable | CV_ShipUsedHexes;
else if(name == "ShipTotalHexes")
return VT_ConstantVariable | CV_ShipTotalHexes;
else if(name == "ShipEmptyHexes")
return VT_ConstantVariable | CV_ShipEmptyHexes;
else if(name == "IsCore")
return VT_ConstantVariable | CV_IsCore;
//Game configuration
if(name[0] == '$') {
auto it = gameConfig.indices.find(name.substr(1));
if(it != gameConfig.indices.end())
return VT_GameConfig | (int)it->second;
}
unsigned flags = 0;
if(name.compare(0, 6, "Base::") == 0) {
flags |= VTF_BaseVariable;
name = name.substr(6);
}
if(name.find('.') != std::string::npos) {
//Hex variables
if(name.compare(0, 4, "Hex.") == 0) {
//Constant hex variables
std::string varname = name.substr(4, name.size() - 4);
if(varname == "Exterior")
return VT_ConstantVariable | CV_HexExterior;
//Hex formula variables
int i = getHexVariableIndex(varname);
if(i < 0) {
if(!formulaQuiet)
error("Error: Formula: Invalid variable '%s'.", name.c_str());
return -1;
}
if(formulaSubsystem) {
if(i >= (int)formulaSubsystem->hexVariableIndices.size() ||
formulaSubsystem->hexVariableIndices[i] < 0) {
if(!formulaQuiet)
error("Error: Formula: Subsystem '%s' does not have variable '%s'.",
formulaSubsystem->id.c_str(), name.c_str());
return -1;
}
}
return VT_HexVariable | flags | i;
}
if(name.compare(0, 9, "Adjacent.") == 0) {
//Constant hex variables
std::string varname = name.substr(9, name.size() - 9);
if(varname == "Active")
return VT_ConstantVariable | CV_AdjacentActive;
if(varname == "This")
return VT_ConstantVariable | CV_AdjacentThis;
//Tags
if(varname.compare(0, 4, "Tag.")) {
int i = getSysTagIndex(varname.substr(4, varname.size()-4));
if(i < 0) {
if(!formulaQuiet)
error("Error: Formula: Invalid tag '%s'.", name.c_str());
return -1;
}
return VT_AdjacentTag | i;
}
//Subsystems
const SubsystemDef* def = getSubsystemDef(varname);
if(def != nullptr)
return VT_AdjacentSubsystem | def->index;
}
//Ship variables
if(name.compare(0, 5, "Ship.") == 0) {
//Constant hex variables
std::string varname = name.substr(5, name.size() - 5);
//Ship formula variables
int i = getShipVariableIndex(varname);
if(i < 0) {
if(!formulaQuiet)
error("Error: Formula: Invalid variable '%s'.", name.c_str());
return -1;
}
return VT_ShipVariable | flags | i;
}
//Sum variables
if(name.compare(0, 4, "Sum.") == 0) {
//Constant hex variables
std::string varname = name.substr(4, name.size() - 4);
//Ship formula variables
int i = getVariableIndex(varname);
if(i < 0) {
if(!formulaQuiet)
error("Error: Formula: Invalid variable for sum '%s'.", name.c_str());
return -1;
}
return VT_SumVariable | flags | i;
}
//Hex sum variables
if(name.compare(0, 7, "HexSum.") == 0) {
//Constant hex variables
std::string varname = name.substr(7, name.size() - 7);
//Hex formula variables
int i = getHexVariableIndex(varname);
if(i < 0) {
if(!formulaQuiet)
error("Error: Formula: Invalid variable '%s'.", name.c_str());
return -1;
}
return VT_HexSumVariable | flags | i;
}
//Tag count variable
if(name.compare(0, 9, "TagCount.") == 0) {
std::string varname = name.substr(9, name.size() - 9);
int i = getSysTagIndex(varname);
if(i < 0) {
if(!formulaQuiet)
error("Error: Formula: Invalid tag '%s'.", name.c_str());
return -1;
}
return VT_TagCountVariable | i;
}
//Module metavariables
if(formulaSubsystem) {
for(unsigned i = 0, cnt = (unsigned)formulaSubsystem->modules.size(); i < cnt; ++i) {
SubsystemDef::ModuleDesc& mod = *formulaSubsystem->modules[i];
if(name.size() <= mod.id.size() + 1)
continue;
if(name.compare(0, mod.id.size(), mod.id)) {
size_t pos = mod.id.size();
if(name[pos] == '.') {
if(name.compare(pos + 1, name.size() - pos - 1, "Count")) {
return VT_ModuleCount | i;
}
else if(name.compare(pos + 1, name.size() - pos - 1, "Exists")) {
return VT_ModuleExists | i;
}
}
}
}
}
}
//Subsystem variables
int i = getVariableIndex(name);
if(i < 0) {
if(!formulaQuiet)
error("Error: Formula: Invalid variable '%s'.\n", name.c_str());
return -1;
}
if(formulaSubsystem) {
if(i >= (int)formulaSubsystem->variableIndices.size() ||
formulaSubsystem->variableIndices[i] < 0) {
if(!formulaQuiet)
error("Error: Formula: Subsystem '%s' does not have variable '%s'.",
formulaSubsystem->id.c_str(), name.c_str());
return -1;
}
}
return VT_SubsystemVariable | flags | i;
}
Formula* parseFormula(const std::string& str, const SubsystemDef* def, const SubsystemDef::ModifyStage* modifier) {
formulaSubsystem = def;
formulaModifier = modifier;
Formula* f = Formula::fromInfix(str.c_str(), formulaVarIndex);
formulaModifier = 0;
formulaSubsystem = 0;
return f;
}
int SV_Size = -1, HV_Resistance = -1, HV_HP = -1, ShV_HexSize = -1;
struct TemplateBlock {
std::vector<std::pair<int,std::string>> conditions;
std::vector<std::string> lines;
};
bool conditionMatches(const SubsystemDef* cur, std::vector<std::pair<int,std::string>>& conditions) {
bool passesAll = true;
foreach(c, conditions) {
int type = c->first;
bool negation = false;
if(type & TC_NOT) {
type &= ~TC_NOT;
negation = true;
}
bool pass = true;
switch(type) {
case TC_Tag:
if(!cur->hasTag(c->second))
pass = false;
break;
case TC_Modifier:
if(cur->modifierIds.find(c->second) == cur->modifierIds.end())
pass = false;
break;
case TC_Variable: {
int globalIndex = getVariableIndex(c->second);
if(globalIndex < 0) {
pass = false;
}
else {
if((unsigned)globalIndex >= cur->variableIndices.size()) {
pass = false;
}
else if(cur->variableIndices[globalIndex] < 0) {
pass = false;
}
}
} break;
case TC_HexVariable: {
int globalIndex = getHexVariableIndex(c->second);
if(globalIndex < 0) {
pass = false;
}
else {
if((unsigned)globalIndex >= cur->hexVariableIndices.size()) {
pass = false;
}
else if(cur->hexVariableIndices[globalIndex] < 0) {
pass = false;
}
}
} break;
case TC_ShipVariable: {
int globalIndex = getShipVariableIndex(c->second);
if(globalIndex < 0) {
pass = false;
}
else {
if((unsigned)globalIndex >= cur->shipVariableIndices.size()) {
pass = false;
}
else if(cur->shipVariableIndices[globalIndex] < 0) {
pass = false;
}
}
} break;
case TC_Subsystem: {
pass = cur->id == c->second;
} break;
}
if(!negation) {
if(!pass)
passesAll = false;
}
else {
if(pass)
passesAll = false;
}
}
return passesAll;
}
void parseConditions(const std::string& value, std::vector<std::pair<int,std::string>>& conditions) {
std::vector<std::string> conds;
split(value, conds, ',', true);
foreach(it, conds) {
std::vector<std::string> parts;
split(*it, parts, '/', true);
std::string value;
int cond = 0;
if(parts[0][0] == '!') {
parts[0] = parts[0].substr(1);
cond = TC_NOT;
}
if(parts.size() == 2) {
value = parts[1];
if(parts[0] == "tag") {
cond |= TC_Tag;
}
else if(parts[0] == "mod") {
cond |= TC_Modifier;
}
else if(parts[0] == "var") {
cond |= TC_Variable;
}
else if(parts[0] == "hexVar") {
cond |= TC_HexVariable;
}
else if(parts[0] == "shipVar") {
cond |= TC_ShipVariable;
}
else {
error(" Invalid condition: %s", it->c_str());
continue;
}
}
else {
cond |= TC_Subsystem;
value = parts[0];
}
conditions.push_back(
std::pair<int,std::string>(
cond, value));
}
}
void parseShipModifier(SubsystemDef::ShipModifier& mod, const std::string& value) {
std::string conds;
std::string func;
//Separate conditions
auto sep = value.find("::");
if(sep != std::string::npos) {
conds = value.substr(0,sep);
func = value.substr(sep+2);
}
else {
func = value;
}
parseConditions(conds, mod.conditions);
//Check if we have any arguments
std::vector<std::string> args;
std::string name;
if(funcSplit(func, name, args)) {
mod.modifyName = name;
for(size_t i = 0, cnt = args.size(); i < cnt && i < MODIFY_STAGE_MAXARGS; ++i)
mod.str_arguments.push_back(args[i]);
}
else {
mod.modifyName = func;
}
}
DataHandler* sysHandler = 0;
static SubsystemDef* def = 0;
static SubsystemDef::ModuleDesc* mod = 0;
static SubsystemDef::ModifyStage* stage = 0;
static SubsystemDef::Effect* eff = 0;
static SubsystemDef::Effector* efftr = 0;
static SubsystemDef::Assert* ass = 0;
static std::vector<TemplateBlock*> templates;
static TemplateBlock* temp = 0;
static bool inTemplate = false;
static int modStage = 1;
static int overrideHexArcLimitTag = -1;
void clearSubsystemDefinitions() {
foreach(it, subsystems)
delete *it;
subsystems.clear();
subsystemIndices.clear();
variableIndices.clear();
numericTags.clear();
foreach(it, templates)
delete *it;
templates.clear();
def = 0;
mod = 0;
stage = 0;
eff = 0;
efftr = 0;
ass = 0;
temp = 0;
inTemplate = false;
modStage = 1;
ModulesByID.clear();
ModifiersByID.clear();
}
void loadSubsystemDefinitions(const std::string& filename) {
modStage = 1;
def = 0;
mod = 0;
stage = 0;
eff = 0;
efftr = 0;
ass = 0;
temp = 0;
inTemplate = false;
overrideHexArcLimitTag = getSysTagIndex("OverrideHexArcLimit", true);
if(sysHandler != 0) {
sysHandler->read(filename);
SV_Size = getVariableIndex("Size");
HV_Resistance = getHexVariableIndex("Resistance");
HV_HP = getHexVariableIndex("HP");
ShV_HexSize = getShipVariableIndex("HexSize");
return;
}
sysHandler = new DataHandler();
DataHandler& handler = *sysHandler;
handler.defaultHandler([&](std::string& key, std::string& value) {
error(handler.position());
error(" Invalid line format.");
});
{
auto& templateBlock = handler.block("Template");
templateBlock.openBlock([&](std::string& value) -> bool {
temp = new TemplateBlock();
templates.push_back(temp);
parseConditions(value, temp->conditions);
return true;
});
templateBlock.lineHandler([&](std::string& line) {
temp->lines.push_back(line);
});
}
{
auto& subsysBlock = handler.block("Subsystem");
subsysBlock.openBlock([&](std::string& id) -> bool {
def = new SubsystemDef();
def->index = (int)subsystems.size();
def->id = id;
def->variableIndices.resize(variableIndices.size());
modStage = 1;
for(unsigned i = 0; i < def->variableIndices.size(); ++i)
def->variableIndices[i] = -1;
subsystems.push_back(def);
subsystemIndices[id] = def->index;
return true;
});
subsysBlock.closeBlock([&]() {
def = 0;
});
auto getVariable = [&](std::string& name) -> SubsystemDef::Variable& {
bool dependent = false;
if(name.compare(0, 4, "out ") == 0) {
name = name.substr(4);
dependent = true;
}
//Check if it is a hex variable
if(name.compare(0, 4, "Hex.") == 0) {
//Remove hex part
name = name.substr(4, name.size() - 4);
//Find global index
int index;
auto it = hexVariableIndices.find(name);
if(it == hexVariableIndices.end()) {
index = (int)hexVariableIndices.size();
hexVariableIndices[name] = index;
}
else {
index = it->second;
}
//Check if we have the variable
if((int)def->hexVariableIndices.size() <= index) {
int prevLen = (int)def->hexVariableIndices.size();
def->hexVariableIndices.resize(index + 1);
for(int i = prevLen; i <= index; ++i)
def->hexVariableIndices[i] = -1;
}
else {
if(def->hexVariableIndices[index] != -1) {
return def->hexVariables[def->hexVariableIndices[index]];
}
}
def->hexVariableIndices[index] = (int)def->hexVariables.size();
SubsystemDef::Variable var;
var.name = name;
var.index = index;
var.formula = 0;
var.type = SVT_HexVariable;
var.dependent = dependent;
def->hexVariables.push_back(var);
return def->hexVariables.back();
}
//Check if it is a ship variable
else if(name.compare(0, 5, "Ship.") == 0) {
//Remove hex part
name = name.substr(5, name.size() - 5);
//Find global index
int index;
auto it = shipVariableIndices.find(name);
if(it == shipVariableIndices.end()) {
index = (int)shipVariableIndices.size();
shipVariableIndices[name] = index;
}
else {
index = it->second;
}
//Check if we have the variable
if((int)def->shipVariableIndices.size() <= index) {
int prevLen = def->shipVariableIndices.size();
def->shipVariableIndices.resize(index + 1);
for(int i = prevLen; i <= index; ++i)
def->shipVariableIndices[i] = -1;
}
else {
if(def->shipVariableIndices[index] != -1) {
return def->shipVariables[def->shipVariableIndices[index]];
}
}
def->shipVariableIndices[index] = def->shipVariables.size();
SubsystemDef::Variable var;
var.name = name;
var.index = index;
var.formula = 0;
var.type = SVT_ShipVariable;
var.dependent = dependent;
def->shipVariables.push_back(var);
return def->shipVariables.back();
}
else {
//Find global index
int index;
auto it = variableIndices.find(name);
if(it == variableIndices.end()) {
index = variableIndices.size();
variableIndices[name] = index;
}
else {
index = it->second;
}
//Check if we have the variable
if((int)def->variableIndices.size() <= index) {
int prevLen = def->variableIndices.size();
def->variableIndices.resize(index + 1);
for(int i = prevLen; i <= index; ++i)
def->variableIndices[i] = -1;
}
else {
if(def->variableIndices[index] != -1) {
return def->variables[def->variableIndices[index]];
}
}
def->variableIndices[index] = def->variables.size();
SubsystemDef::Variable var;
var.name = name;
var.index = index;
var.formula = 0;
var.type = SVT_SubsystemVariable;
var.dependent = dependent;
def->variables.push_back(var);
return def->variables.back();
}
};
subsysBlock("Name", [&](std::string& value) {
def->name = devices.locale.localize(value);
});
subsysBlock("BaseColor", [&](std::string& value) {
def->baseColor = toColor(value);
});
subsysBlock("TypeColor", [&](std::string& value) {
def->typeColor = toColor(value);
});
subsysBlock("Elevation", [&](std::string& value) {
def->elevation = toNumber<int>(value);
});
subsysBlock("Description", [&](std::string& value) {
def->description = devices.locale.localize(value);
});
subsysBlock("Picture", [&](std::string& value) {
def->picMat = value;
});
auto addTags = [&](std::vector<std::string>& tags) {
foreach(t, tags) {
std::string tag, value;
auto pos = t->find(':');
if(pos != std::string::npos) {
tag = t->substr(0, pos);
if(pos < t->size()-1)
value = t->substr(pos+1);
}
else {
tag = *t;
}
def->tags.insert(tag);
auto it = numericTags.find(tag);
int index = -1;
if(it != numericTags.end()) {
index = it->second;
}
else {
index = numericTags.size();
numericTags[tag] = index;
}
def->numTags.insert(index);
if(!value.empty())
def->tagValues[index].push_back(value);
}
};
subsysBlock("Tags", [&](std::string& value) {
std::vector<std::string> tags;
split(value, tags, ',', true);
addTags(tags);
def->isContiguous = def->tags.find("NonContiguous") == def->tags.end();
def->hasCore = def->tags.find("NoCore") == def->tags.end();
def->alwaysTakeDamage = def->tags.find("AlwaysTakeDamage") != def->tags.end();
def->hexLimitArc = def->tags.find("HexLimitArc") != def->tags.end();
def->isHull = def->tags.find("HullSystem") != def->tags.end();
def->isApplied = def->tags.find("Applied") != def->tags.end();
def->exteriorCore = def->tags.find("ExteriorCore") != def->tags.end();
def->defaultUnlock = def->tags.find("DefaultUnlock") != def->tags.end();
def->passExterior = def->tags.find("PassExterior") != def->tags.end();
def->fauxExterior = def->tags.find("FauxExterior") != def->tags.end();
});
subsysBlock("Hull", [&](std::string& value) {
std::vector<std::string> tags;
split(value, tags, ',', true);
foreach(t, tags) {
def->hullTags.push_back(*t);
*t += "Hull";
}
addTags(tags);
});
subsysBlock("EvaluationOrder", [&](std::string& value) {
def->ordering = toNumber<int>(value);
});
subsysBlock("DamageOrder", [&](std::string& value) {
def->damageOrder = toNumber<int>(value);
});
subsysBlock("OnCheckErrors", [&](std::string& value) {
def->def_onCheckErrors = value;
});
subsysBlock("State", [&](std::string& value) {
std::vector<std::string> args;
split(value, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid state format.");
return;
}
SubsystemDef::StateDesc desc;
toLowercase(args[0]);
if(args[0] == "int")
desc.type = BT_Int;
else if(args[0] == "double")
desc.type = BT_Double;
else if(args[0] == "bool")
desc.type = BT_Bool;
desc.formula = 0;
desc.str_formula = args[1];
def->states.push_back(desc);
});
subsysBlock("Hook", [&](std::string& value) {
def->hooks.push_back(value);
});
subsysBlock("AddShipModifier", [&](std::string& value) {
SubsystemDef::ShipModifier mod;
parseShipModifier(mod, value);
def->shipModifiers.push_back(mod);
});
subsysBlock("AddAdjacentModifier", [&](std::string& value) {
SubsystemDef::ShipModifier mod;
parseShipModifier(mod, value);
def->adjacentModifiers.push_back(mod);
});
subsysBlock("AddPostModifier", [&](std::string& value) {
SubsystemDef::ShipModifier mod;
parseShipModifier(mod, value);
def->postModifiers.push_back(mod);
});
subsysBlock.defaultHandler([&](std::string& key, std::string& value) {
if(!value.empty() && value[0] == '=') {
SubsystemDef::Variable& var = getVariable(key);
value = value.substr(1, value.size() - 1);
var.formula = 0;
var.str_formula = value;
}
else {
error(handler.position());
error(" Invalid line format.");
}
});
{
auto& defaultsBlock = subsysBlock.block("Defaults");
defaultsBlock.defaultHandler([&](std::string& key, std::string& value) {
if(!value.empty() && value[0] == '=') {
SubsystemDef::Variable& var = getVariable(key);
if(var.formula == 0 && var.str_formula.empty()) {
value = value.substr(1, value.size() - 1);
var.formula = 0;
var.str_formula = value;
}
}
else {
error(handler.position());
error(" Invalid line format.");
}
});
}
{
auto& modifyBlock = subsysBlock.block("Modifier");
modifyBlock.openBlock([&](std::string& value) -> bool {
std::vector<std::string> args;
std::string name;
//Check if we have any arguments
if(!funcSplit(value, name, args)) {
name = value;
args.clear();
}
//Check for duplicates
auto it = def->modifierIds.find(name);
if(it != def->modifierIds.end()) {
//Ignored silently in templates so subsystems can
//override modifiers from templates
if(!inTemplate) {
error(handler.position());
error(" Duplicate modifier '%s'.", name.c_str());
}
stage = 0;
return true;
}
//Make the stage
stage = new SubsystemDef::ModifyStage();
stage->umodifid = ModifiersByID.size();
stage->index = def->modifiers.size();
for(unsigned i = 0, cnt = args.size(); i < cnt; ++i)
stage->argumentNames[args[i]] = i;
def->modifiers.push_back(stage);
def->modifierIds[name] = stage;
stage->stage = ++modStage;
ModifiersByID.push_back(stage);
return true;
});
modifyBlock("Stage", [&](std::string& value) {
if(!stage)
return;
stage->stage = toNumber<short>(value) << 16 | modStage;
});
modifyBlock.closeBlock([&]() {
stage = 0;
});
modifyBlock.defaultHandler([&](std::string& key, std::string& value) {
if(!stage)
return;
if(!value.empty() && value[0] == '=') {
SubsystemDef::Variable& var = getVariable(key);
value = value.substr(1, value.size() - 1);
switch(var.type) {
case SVT_SubsystemVariable: {
auto it = stage->variables.find(var.index);
if(it != stage->variables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_variables.push_back(std::pair<int,std::string>(var.index, value));
} break;
case SVT_HexVariable: {
auto it = stage->hexVariables.find(var.index);
if(it != stage->hexVariables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_hexVariables.push_back(std::pair<int,std::string>(var.index, value));
} break;
case SVT_ShipVariable: {
auto it = stage->shipVariables.find(var.index);
if(it != stage->shipVariables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_shipVariables.push_back(std::pair<int,std::string>(var.index, value));
} break;
}
}
else {
error(handler.position());
error(" Invalid line format.");
}
});
}
{
auto& moduleBlock = subsysBlock.block("Module");
moduleBlock.openBlock([&](std::string& value) -> bool {
auto it = def->moduleIndices.find(value);
if(it != def->moduleIndices.end()) {
if(inTemplate) {
mod = def->modules[it->second];
return true;
}
error(handler.position());
error(" Duplicate module.");
return false;
}
mod = new SubsystemDef::ModuleDesc();
def->modules.push_back(mod);
mod->index = def->modules.size() - 1;
mod->id = value;
mod->umodident = def->id + "::" + mod->id;
mod->umodid = ModulesByID.size();
ModulesByID.push_back(mod);
if(value == "Default") {
def->defaultModule = mod;
mod->defaultUnlock = true;
}
else if(value == "Core") {
def->coreModule = mod;
mod->defaultUnlock = true;
mod->required = true;
mod->vital = true;
mod->unique = true;
}
def->moduleIndices[value] = mod->index;
return true;
});
moduleBlock.closeBlock([&]() {
mod = 0;
stage = 0;
});
moduleBlock("Name", [&](std::string& value) {
mod->name = devices.locale.localize(value);
});
moduleBlock("Description", [&](std::string& value) {
mod->description = devices.locale.localize(value);
});
moduleBlock("Color", [&](std::string& value) {
mod->color = toColor(value);
});
moduleBlock("Required", [&](std::string& value) {
mod->required = toBool(value);
});
moduleBlock("Unique", [&](std::string& value) {
mod->unique = toBool(value);
});
moduleBlock("Vital", [&](std::string& value) {
mod->vital = toBool(value);
});
moduleBlock("DefaultUnlock", [&](std::string& value) {
mod->defaultUnlock = toBool(value);
});
moduleBlock("Sprite", [&](std::string& value) {
mod->spriteMat = value;
});
moduleBlock("DrawMode", [&](std::string& value) {
mod->drawMode = toNumber<int>(value);
});
moduleBlock("Hook", [&](std::string& value) {
mod->hooks.push_back(value);
});
moduleBlock("OnEnable", [&](std::string& value) {
mod->def_onEnable = value;
});
moduleBlock("OnDisable", [&](std::string& value) {
mod->def_onDisable = value;
});
moduleBlock("AddModifier", [&](std::string& value) {
mod->str_appliedStages.push_back(value);
});
moduleBlock("AddUniqueModifier", [&](std::string& value) {
mod->str_uniqueAppliedStages.push_back(value);
});
moduleBlock("AddHexModifier", [&](std::string& value) {
mod->str_hexAppliedStages.push_back(value);
});
moduleBlock("OnCheckErrors", [&](std::string& value) {
mod->def_onCheckErrors = value;
});
moduleBlock("Tags", [&](std::string& value) {
std::vector<std::string> tags;
split(value, tags, ',', true);
foreach(t, tags) {
std::string tag, value;
auto pos = t->find(':');
if(pos != std::string::npos) {
tag = t->substr(0, pos);
if(pos < t->size()-1)
value = t->substr(pos+1);
}
else {
tag = *t;
}
mod->tags.insert(tag);
auto it = numericTags.find(tag);
int index = -1;
if(it != numericTags.end()) {
index = it->second;
}
else {
index = numericTags.size();
numericTags[tag] = index;
}
mod->numTags.insert(index);
if(!value.empty())
mod->tagValues[index].push_back(value);
}
});
moduleBlock("AddAdjacentModifier", [&](std::string& value) {
SubsystemDef::ShipModifier m;
parseShipModifier(m, value);
mod->adjacentModifiers.push_back(m);
});
auto addModification = [&](std::string& key, std::string& value) {
SubsystemDef::Variable& var = getVariable(key);
//Create a default stage at 0
if(!stage) {
mod->modifiers.push_back(SubsystemDef::ModifyStage());
stage = &mod->modifiers.back();
stage->stage = ++modStage;
}
switch(var.type) {
case SVT_SubsystemVariable: {
auto it = stage->variables.find(var.index);
if(it != stage->variables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_variables.push_back(std::pair<int,std::string>(var.index, value));
} break;
case SVT_HexVariable: {
auto it = stage->hexVariables.find(var.index);
if(it != stage->hexVariables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_hexVariables.push_back(std::pair<int,std::string>(var.index, value));
} break;
case SVT_ShipVariable: {
auto it = stage->shipVariables.find(var.index);
if(it != stage->shipVariables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_shipVariables.push_back(std::pair<int,std::string>(var.index, value));
} break;
}
};
moduleBlock.defaultHandler([&](std::string& key, std::string& value) {
if(!value.empty() && value[0] == '=') {
value = value.substr(1, value.size()-1);
addModification(key, value);
}
else {
error(handler.position());
error(" Invalid line format.");
}
});
{
auto& assertBlock = moduleBlock.block("Assert");
assertBlock.openBlock([&](std::string& value) -> bool {
mod->asserts.push_back(SubsystemDef::Assert());
ass = &mod->asserts.back();
ass->fatal = true;
ass->unique = false;
ass->formula = 0;
ass->str_formula = value;
ass->message = "Assertion Failed";
return true;
});
assertBlock("Unique", [&](std::string& value) {
ass->unique = toBool(value);
});
assertBlock("Fatal", [&](std::string& value) {
ass->fatal = toBool(value);
});
assertBlock("Message", [&](std::string& value) {
ass->message = devices.locale.localize(value);
});
assertBlock.closeBlock([&]() {
ass = 0;
});
}
{
auto& requiresBlock = moduleBlock.block("Requires");
requiresBlock.openBlock([&](std::string& value) -> bool {
return true;
});
requiresBlock.lineHandler([&](std::string& line) {
auto pos = line.find("=");
if(pos == line.npos) {
error(handler.position());
error(" Invalid line format.");
return;
}
std::vector<std::string> args;
split(line, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid line format.");
return;
}
//Add the variable modification
std::string vname = "Ship.REQUIRES_" + args[0];
std::string vformula = format("Ship.REQUIRES_$1 + $2", args[0], args[1]);
addModification(vname, vformula);
//Add the assert block
SubsystemDef::Assert ass;
ass.fatal = true;
ass.unique = true;
ass.formula = 0;
ass.str_formula = format("Ship.$1 >= Ship.REQUIRES_$1", args[0]);
ass.message = devices.locale.localize(format("ERROR_INSUFFICIENT_$1", args[0]));
mod->asserts.push_back(ass);
});
}
{
auto& providesBlock = moduleBlock.block("Provides");
providesBlock.openBlock([&](std::string& value) -> bool {
return true;
});
providesBlock.lineHandler([&](std::string& line) {
auto pos = line.find("=");
if(pos == line.npos) {
error(handler.position());
error(" Invalid line format.");
return;
}
std::vector<std::string> args;
split(line, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid line format.");
return;
}
//Add the variable modification
std::string vname = "Ship." + args[0];
std::string vformula = format("Ship.$1 + $2", args[0], args[1]);
addModification(vname, vformula);
});
}
{
auto& modifyBlock = moduleBlock.block("Modify");
modifyBlock.openBlock([&](std::string& value) -> bool {
short number = 0;
bool unique = false;
if(streq_nocase(value, "unique")) {
unique = true;
}
else {
if(streq_nocase(value, "unique ", 0, 7)) {
unique = true;
value = value.substr(7, value.size() - 7);
}
if(streq_nocase(value, "stage ", 0, 6)) {
number = toNumber<short>(value.substr(6, value.size() - 6));
}
else if(!value.empty()) {
error(handler.position());
error(" Invalid stage specification, assuming stage 0.");
}
}
if(unique) {
mod->uniqueModifiers.push_back(SubsystemDef::ModifyStage());
stage = &mod->uniqueModifiers.back();
}
else {
mod->modifiers.push_back(SubsystemDef::ModifyStage());
stage = &mod->modifiers.back();
}
stage->stage = number << 16 | ++modStage;
return true;
});
modifyBlock.closeBlock([&]() {
stage = 0;
});
modifyBlock.defaultHandler([&](std::string& key, std::string& value) {
if(!value.empty() && value[0] == '=') {
SubsystemDef::Variable& var = getVariable(key);
value = value.substr(1, value.size() - 1);
switch(var.type) {
case SVT_SubsystemVariable: {
auto it = stage->variables.find(var.index);
if(it != stage->variables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_variables.push_back(std::pair<int,std::string>(var.index, value));
} break;
case SVT_HexVariable: {
auto it = stage->hexVariables.find(var.index);
if(it != stage->hexVariables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_hexVariables.push_back(std::pair<int,std::string>(var.index, value));
} break;
case SVT_ShipVariable: {
auto it = stage->shipVariables.find(var.index);
if(it != stage->shipVariables.end()) {
error(handler.position());
error(" Duplicate variable modifier.");
return;
}
stage->str_shipVariables.push_back(std::pair<int,std::string>(var.index, value));
} break;
}
}
else {
error(handler.position());
error(" Invalid line format.");
}
});
}
{
auto& effectBlock = moduleBlock.block("Effect");
effectBlock.openBlock([&](std::string& value) -> bool {
const EffectDef* type = getEffectDefinition(value);
if(!type) {
eff = 0;
error(handler.position());
error(" Unknown effect %s.", value.c_str());
return false;
}
mod->effects.push_back(SubsystemDef::Effect());
eff = &mod->effects[mod->effects.size() - 1];
eff->type = type;
eff->values.resize(type->valueCount);
eff->str_values.resize(type->valueCount);
for(unsigned i = 0; i < type->valueCount; ++i)
eff->values[i] = 0;
return true;
});
effectBlock.closeBlock([&]() {
eff = 0;
});
effectBlock.lineHandler([&](std::string& line) {
auto pos = line.find("=");
if(pos == line.npos) {
error(handler.position());
error(" Invalid line format.");
return;
}
std::vector<std::string> args;
split(line, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid line format.");
return;
}
auto it = eff->type->valueNames.find(args[0]);
if(it == eff->type->valueNames.end()) {
error(handler.position());
error(" Unknown effect value '%s'.", args[0].c_str());
return;
}
eff->str_values[it->second] = args[1];
});
}
}
{
auto& effectBlock = subsysBlock.block("Effect");
effectBlock.openBlock([&](std::string& value) -> bool {
const EffectDef* type = getEffectDefinition(value);
if(!type) {
eff = 0;
error(handler.position());
error(" Unknown effect %s.", value.c_str());
return false;
}
def->effects.push_back(SubsystemDef::Effect());
eff = &def->effects[def->effects.size() - 1];
eff->type = type;
eff->values.resize(type->valueCount);
eff->str_values.resize(type->valueCount);
for(unsigned i = 0; i < type->valueCount; ++i)
eff->values[i] = 0;
return true;
});
effectBlock.closeBlock([&]() {
eff = 0;
});
effectBlock.lineHandler([&](std::string& line) {
auto pos = line.find("=");
if(pos == line.npos) {
error(handler.position());
error(" Invalid line format.");
return;
}
std::vector<std::string> args;
split(line, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid line format.");
return;
}
auto it = eff->type->valueNames.find(args[0]);
if(it == eff->type->valueNames.end()) {
error(handler.position());
error(" Unknown effect value '%s'.", args[0].c_str());
return;
}
eff->str_values[it->second] = args[1];
});
}
{
auto& effectorBlock = subsysBlock.block("Effector");
effectorBlock.openBlock([&](std::string& value) -> bool {
const EffectorDef* type = getEffectorDefinition(value);
if(!type) {
efftr = 0;
error(handler.position());
error(" Unknown effector %s.", value.c_str());
return false;
}
def->effectors.push_back(SubsystemDef::Effector());
efftr = &def->effectors[def->effectors.size() - 1];
efftr->type = type;
efftr->enabled = true;
efftr->values.resize(type->valueCount);
efftr->str_values.resize(type->valueCount);
efftr->skinIndex = 0;
for(unsigned i = 0; i < type->valueCount; ++i)
efftr->values[i] = 0;
return true;
});
effectorBlock("Disabled", [&](std::string& value) {
efftr->enabled = !toBool(value);
});
effectorBlock("Skin", [&](std::string& value) {
auto s = efftr->type->skinNames.find(value);
if(s != efftr->type->skinNames.end()) {
efftr->skinIndex = s->second;
efftr->skinName = value;
}
else
error("Effector '%s' has no skin '%s'", efftr->type->name.c_str(), value.c_str());
});
effectorBlock.closeBlock([&]() {
efftr = 0;
});
effectorBlock.lineHandler([&](std::string& line) {
auto pos = line.find("=");
if(pos == line.npos) {
error(handler.position());
error(" Invalid line format.");
return;
}
std::vector<std::string> args;
split(line, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid line format.");
return;
}
auto it = efftr->type->valueNames.find(args[0]);
if(it == efftr->type->valueNames.end()) {
error(handler.position());
error(" Unknown effector value '%s'.\n", args[0].c_str());
return;
}
efftr->str_values[it->second] = args[1];
});
}
{
auto& assertBlock = subsysBlock.block("Assert");
assertBlock.openBlock([&](std::string& value) -> bool {
def->asserts.push_back(SubsystemDef::Assert());
ass = &def->asserts.back();
ass->fatal = true;
ass->unique = false;
ass->formula = 0;
ass->str_formula = value;
ass->message = "Assertion Failed";
return true;
});
assertBlock("Unique", [&](std::string& value) {
ass->unique = toBool(value);
});
assertBlock("Fatal", [&](std::string& value) {
ass->fatal = toBool(value);
});
assertBlock("Message", [&](std::string& value) {
ass->message = devices.locale.localize(value);
});
assertBlock.closeBlock([&]() {
ass = 0;
});
}
{
auto& requiresBlock = subsysBlock.block("Requires");
requiresBlock.openBlock([&](std::string& value) -> bool {
return true;
});
requiresBlock.lineHandler([&](std::string& line) {
auto pos = line.find("=");
if(pos == line.npos) {
error(handler.position());
error(" Invalid line format.");
return;
}
std::vector<std::string> args;
split(line, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid line format.");
return;
}
//Add the variable modification
std::string vname = "Ship.REQUIRES_" + args[0];
auto& var = getVariable(vname);
var.str_formula = format("Ship.REQUIRES_$1 + $2",
args[0], args[1]);
//Add the assert block
SubsystemDef::Assert ass;
ass.fatal = true;
ass.unique = true;
ass.formula = 0;
ass.str_formula = format("Ship.$1 >= Ship.REQUIRES_$1", args[0]);
ass.message = devices.locale.localize(format("ERROR_INSUFFICIENT_$1", args[0]));
def->asserts.push_back(ass);
});
}
{
auto& providesBlock = subsysBlock.block("Provides");
providesBlock.openBlock([&](std::string& value) -> bool {
return true;
});
providesBlock.lineHandler([&](std::string& line) {
auto pos = line.find("=");
if(pos == line.npos) {
error(handler.position());
error(" Invalid line format.");
return;
}
std::vector<std::string> args;
split(line, args, '=', true);
if(args.size() != 2) {
error(handler.position());
error(" Invalid line format.");
return;
}
//Add the variable modification
std::string vname = "Ship." + args[0];
auto& var = getVariable(vname);
var.str_formula = format("Ship.$1 + $2", args[0], args[1]);
});
}
}
handler.read(filename);
SV_Size = getVariableIndex("Size");
HV_Resistance = getHexVariableIndex("Resistance");
HV_HP = getHexVariableIndex("HP");
ShV_HexSize = getShipVariableIndex("HexSize");
}
void bindSubsystemHooks() {
foreach(it, subsystems) {
SubsystemDef* def = (*it);
if(!def->def_onCheckErrors.empty())
def->scr_onCheckErrors = devices.scripts.server->getFunction(def->def_onCheckErrors,
"(Design& design, Subsystem& sys)", "bool");
foreach(it, def->modules) {
auto* m = *it;
if(!m->def_onCheckErrors.empty())
m->scr_onCheckErrors = devices.scripts.server->getFunction(m->def_onCheckErrors,
"(Design& design, Subsystem& sys, const vec2u& hex)", "bool");
}
if(!devices.network->isClient) {
foreach(it, def->modules) {
auto* m = *it;
if(!m->def_onEnable.empty()) {
m->scr_onEnable = devices.scripts.server->getFunction(m->def_onEnable,
"(Event& evt, const vec2u& position)", "void");
}
else {
m->scr_onEnable = 0;
}
if(!m->def_onDisable.empty()) {
m->scr_onDisable = devices.scripts.server->getFunction(m->def_onDisable,
"(Event& evt, const vec2u& position)", "void");
}
else {
m->scr_onDisable = 0;
}
}
}
}
}
void executeSubsystemTemplates() {
foreach(it, subsystems) {
SubsystemDef* cur = (*it);
//Add templated code
foreach(t, templates) {
if(conditionMatches(cur, (*t)->conditions)) {
modStage = 1;
def = cur;
mod = 0;
stage = 0;
eff = 0;
efftr = 0;
ass = 0;
temp = 0;
inTemplate = true;
sysHandler->enterBlock("Subsystem");
foreach(l, (*t)->lines)
sysHandler->feed(*l);
sysHandler->end();
}
}
}
}
void finalizeSubsystems() {
foreach(it, subsystems)
(*it)->finalize();
}
void bindSubsystemMaterials() {
foreach(it, subsystems) {
SubsystemDef* def = (*it);
foreach(m, def->modules)
(*m)->sprite = devices.library.getSprite((*m)->spriteMat);
if(!def->picMat.empty())
def->picture = devices.library.getSprite(def->picMat);
else if(def->coreModule)
def->picture = def->coreModule->sprite;
else if(def->defaultModule)
def->picture = def->defaultModule->sprite;
}
}
SubsystemDef::SubsystemDef() : index(-1), ordering(0), damageOrder(0), elevation(0),
defaultModule(0), coreModule(0), typeColor((unsigned)0x00000000),
scr_onCheckErrors(0),
hasCore(false), isContiguous(true), exteriorCore(false),
defaultUnlock(false), isHull(false), isApplied(false), hexLimitArc(false),
passExterior(false), fauxExterior(false) {
}
SubsystemDef::~SubsystemDef() {
foreach(it, variables) {
delete it->formula;
}
foreach(it, effects) {
foreach(f, it->values)
delete *f;
}
foreach(it, states)
delete it->formula;
}
void SubsystemDef::finalize() {
//Create default module
if(!defaultModule) {
SubsystemDef::ModuleDesc* mod = new SubsystemDef::ModuleDesc();
modules.push_back(mod);
mod->index = modules.size() - 1;
mod->id = "Default";
mod->umodident = id + "::" + mod->id;
mod->umodid = ModulesByID.size();
mod->defaultUnlock = true;
ModulesByID.push_back(mod);
defaultModule = mod;
moduleIndices["Default"] = mod->index;
}
//Create core module
if(hasCore && !coreModule) {
SubsystemDef::ModuleDesc* mod = new SubsystemDef::ModuleDesc();
modules.push_back(mod);
mod->index = modules.size() - 1;
mod->id = "Core";
mod->umodident = id + "::" + mod->id;
mod->umodid = ModulesByID.size();
mod->defaultUnlock = true;
ModulesByID.push_back(mod);
coreModule = mod;
moduleIndices["Core"] = mod->index;
}
auto loadFormula = [this](const std::string& str) -> Formula* {
try {
formulaQuiet = false;
return Formula::fromInfix(str.c_str(), formulaVarIndex, false);
}
catch(FormulaError err) {
error("Error in Subsystem '%s' formula '%s': %s", id.c_str(), str.c_str(), err.msg.c_str());
return Formula::fromInfix("0");
}
};
auto loadFormula_quiet = [this](const std::string& str) -> Formula* {
try {
formulaQuiet = true;
return Formula::fromInfix(str.c_str(), formulaVarIndex, false);
}
catch(FormulaError err) {
return nullptr;
}
};
auto addModifier = [this](const std::string& name, const std::string& argname, int prior) -> ModifyStage* {
//Check for duplicates
auto it = modifierIds.find(name);
if(it != modifierIds.end())
return nullptr;
//Make the stage
auto* stage = new ModifyStage();
stage->index = modifiers.size();
stage->umodifid = ModifiersByID.size();
stage->argumentNames[argname] = 0;
stage->stage = prior;
ModifiersByID.push_back(stage);
modifiers.push_back(stage);
modifierIds[name] = stage;
return stage;
};
auto addVariableModifiers = [this,addModifier](SubsystemDef::Variable& var) {
auto* stage = addModifier(var.name+"Factor", "factor", 30);
if(stage) {
switch(var.type) {
case SVT_SubsystemVariable:
stage->str_variables.push_back(std::pair<int,std::string>(var.index, var.name+" * factor"));
break;
case SVT_HexVariable:
stage->str_hexVariables.push_back(std::pair<int,std::string>(var.index, "Hex."+var.name+" * factor"));
break;
}
}
stage = addModifier("AddBase"+var.name+"Factor", "factor", -20);
if(stage) {
switch(var.type) {
case SVT_SubsystemVariable:
stage->str_variables.push_back(std::pair<int,std::string>(var.index, var.name+" + Base::"+var.name+" * factor"));
break;
case SVT_HexVariable:
stage->str_hexVariables.push_back(std::pair<int,std::string>(var.index, "Hex."+var.name+" + Base::Hex."+var.name+" * factor"));
break;
}
}
stage = addModifier("Add"+var.name, "amount", -10);
if(stage) {
switch(var.type) {
case SVT_SubsystemVariable:
stage->str_variables.push_back(std::pair<int,std::string>(var.index, var.name+" + amount"));
break;
case SVT_HexVariable:
stage->str_hexVariables.push_back(std::pair<int,std::string>(var.index, "Hex."+var.name+" + amount"));
break;
}
}
};
//Parse all formulas
formulaSubsystem = this;
foreach(it, variables) {
it->formula = loadFormula(it->str_formula);
addVariableModifiers(*it);
}
foreach(it, hexVariables) {
it->formula = loadFormula(it->str_formula);
addVariableModifiers(*it);
}
foreach(it, shipVariables)
it->formula = loadFormula(it->str_formula);
foreach(it, states)
it->formula = loadFormula(it->str_formula);
foreach(it, asserts)
it->formula = loadFormula(it->str_formula);
foreach(it, shipModifiers)
for(unsigned i = 0, cnt = it->str_arguments.size(); i < cnt; ++i)
it->stage.formulas[i] = loadFormula(it->str_arguments[i]);
foreach(it, postModifiers)
for(unsigned i = 0, cnt = it->str_arguments.size(); i < cnt; ++i)
it->stage.formulas[i] = loadFormula(it->str_arguments[i]);
foreach(it, adjacentModifiers)
for(unsigned i = 0, cnt = it->str_arguments.size(); i < cnt; ++i)
it->stage.formulas[i] = loadFormula(it->str_arguments[i]);
foreach(it, hooks)
for(unsigned i = 0, cnt = it->str_args.size(); i < cnt; ++i)
it->formulas[i] = loadFormula_quiet(it->str_args[i]);
foreach(it, effects)
for(unsigned i = 0, cnt = it->str_values.size(); i < cnt; ++i)
it->values[i] = loadFormula(it->str_values[i]);
foreach(it, effectors)
for(unsigned i = 0, cnt = it->str_values.size(); i < cnt; ++i)
it->values[i] = loadFormula(it->str_values[i]);
foreach(it, modules) {
foreach(m, (*it)->modifiers) {
foreach(v, m->str_variables)
m->variables[v->first] = loadFormula(v->second);
foreach(v, m->str_hexVariables)
m->hexVariables[v->first] = loadFormula(v->second);
foreach(v, m->str_shipVariables)
m->shipVariables[v->first] = loadFormula(v->second);
}
foreach(ass, (*it)->asserts)
ass->formula = loadFormula(ass->str_formula);
foreach(h, (*it)->hooks)
for(unsigned i = 0, cnt = h->str_args.size(); i < cnt; ++i)
h->formulas[i] = loadFormula_quiet(h->str_args[i]);
}
foreach(m, modifiers) {
formulaModifier = *m;
foreach(v, (*m)->str_variables)
(*m)->variables[v->first] = loadFormula(v->second);
foreach(v, (*m)->str_hexVariables)
(*m)->hexVariables[v->first] = loadFormula(v->second);
foreach(v, (*m)->str_shipVariables)
(*m)->shipVariables[v->first] = loadFormula(v->second);
}
formulaModifier = 0;
//Check that we have values for all effect variables
for(auto i = effects.begin(), end = effects.end(); i != end; ++i) {
for(unsigned n = 0; n < i->type->valueCount; ++n) {
auto& desc = i->type->values[n];
if(i->values[n] == 0 && !desc.defaultValue) {
error("Error: Subsystem '%s' effect '%s' is missing values", id.c_str(), i->type->name.c_str());
break;
}
}
}
//Check that we have values for all effector variables
for(auto i = effectors.begin(), end = effectors.end(); i != end; ++i) {
for(unsigned n = 0; n < i->type->valueCount; ++n) {
auto& desc = i->type->values[n];
if(i->values[n] == 0 && !desc.defaultValue) {
error("Error: Subsystem '%s' effector '%s' is missing values", id.c_str(), i->type->name.c_str());
break;
}
}
}
//Parse module applied stages
auto makeAppliedStage = [&](std::string& line, std::vector<SubsystemDef::AppliedStage>& list) {
std::string name;
std::vector<std::string> args;
bool isOptional = false;
if(line.compare(0, 9, "optional ") == 0) {
line = line.substr(9);
isOptional = true;
}
if(!funcSplit(line, name, args)) {
name = line;
args.clear();
}
auto it = modifierIds.find(name);
if(it == modifierIds.end()) {
if(!isOptional) {
error("Error: could not add modifier '%s.%s'.",
id.c_str(), name.c_str());
}
return;
}
const SubsystemDef::ModifyStage* stage = it->second;
if(stage->argumentNames.size() != args.size()) {
error("Error: Modifier '%s.%s' requires %d argument(s), %d given.",
id.c_str(), name.c_str(),
stage->argumentNames.size(), args.size());
return;
}
list.push_back(SubsystemDef::AppliedStage());
SubsystemDef::AppliedStage& as = list.back();
as.stage = stage;
for(unsigned i = 0, cnt = args.size(); i < cnt; ++i)
as.formulas[i] = Formula::fromInfix(args[i].c_str(), formulaVarIndex);
};
foreach(m, modules) {
foreach(it, (*m)->str_appliedStages)
makeAppliedStage(*it, (*m)->appliedStages);
foreach(it, (*m)->str_uniqueAppliedStages)
makeAppliedStage(*it, (*m)->uniqueAppliedStages);
foreach(it, (*m)->str_hexAppliedStages)
makeAppliedStage(*it, (*m)->hexAppliedStages);
foreach(it, (*m)->adjacentModifiers)
for(unsigned i = 0, cnt = it->str_arguments.size(); i < cnt; ++i)
it->stage.formulas[i] = loadFormula(it->str_arguments[i]);
foreach(it, (*m)->effects)
for(unsigned i = 0, cnt = it->str_values.size(); i < cnt; ++i)
it->values[i] = loadFormula(it->str_values[i]);
//Check that we have values for all effect variables
for(auto i = (*m)->effects.begin(), end = (*m)->effects.end(); i != end; ++i) {
for(unsigned n = 0; n < i->type->valueCount; ++n) {
auto& desc = i->type->values[n];
if(i->values[n] == 0 && !desc.defaultValue) {
error("Error: Subsystem '%s', module '%s', effect '%s' is missing values", id.c_str(),
(*m)->name.c_str(), i->type->name.c_str());
break;
}
}
}
}
formulaSubsystem = 0;
}
bool SubsystemDef::hasHullTag(const std::string& tag) const {
foreach(it, hullTags)
if(tag == *it)
return true;
return false;
}
bool SubsystemDef::canUseOn(const HullDef* hull) const {
if(!hull)
return false;
foreach(it, hullTags)
if(hull->hasTag(*it))
return true;
return false;
}
bool SubsystemDef::onCheckErrors(Design* design, Subsystem* sys) const {
if(!scr_onCheckErrors)
return false;
scripts::Call cl = devices.scripts.server->call(scr_onCheckErrors);
bool ret = false;
if(cl.valid()) {
cl.push(design);
cl.push(sys);
cl.call(ret);
}
return ret;
}
bool SubsystemDef::ModuleDesc::onCheckErrors(Design* design, Subsystem* sys, const vec2u& hex) const {
if(!scr_onCheckErrors)
return false;
scripts::Call cl = devices.scripts.server->call(scr_onCheckErrors);
bool ret = false;
if(cl.valid()) {
cl.push(design);
cl.push(sys);
cl.push(&hex);
cl.call(ret);
}
return ret;
}
void SubsystemDef::ModuleDesc::onEnable(EffectEvent& evt, const vec2u& position) const {
if(!scr_onEnable)
return;
scripts::Call cl = devices.scripts.server->call(scr_onEnable);
if(cl.valid()) {
cl.push(&evt);
cl.push(&position);
cl.call();
}
}
void SubsystemDef::ModuleDesc::onDisable(EffectEvent& evt, const vec2u& position) const {
if(!scr_onDisable)
return;
scripts::Call cl = devices.scripts.server->call(scr_onDisable);
if(cl.valid()) {
cl.push(&evt);
cl.push(&position);
cl.call();
}
}
bool SubsystemDef::hasTag(const std::string& tag) const {
auto it = tags.find(tag);
return it != tags.end();
}
bool SubsystemDef::hasTag(int index) const {
auto it = numTags.find(index);
return it != numTags.end();
}
static std::string ERR = "ERR";
const std::string& SubsystemDef::getTagValue(int index, unsigned num) const {
auto it = tagValues.find(index);
if(it != tagValues.end()) {
if(num >= it->second.size())
return ERR;
return it->second[num];
}
return ERR;
}
unsigned SubsystemDef::getTagValueCount(int index) const {
auto it = tagValues.find(index);
if(it != tagValues.end())
return it->second.size();
return 0;
}
bool SubsystemDef::hasTagValue(int index, const std::string& value) const {
auto it = tagValues.find(index);
if(it != tagValues.end()) {
for(size_t i = 0, cnt = it->second.size(); i < cnt; ++i) {
if(it->second[i] == value)
return true;
}
}
return false;
}
bool SubsystemDef::ModuleDesc::hasTag(const std::string& tag) const {
auto it = tags.find(tag);
return it != tags.end();
}
bool SubsystemDef::ModuleDesc::hasTag(int index) const {
auto it = numTags.find(index);
return it != numTags.end();
}
const std::string& SubsystemDef::ModuleDesc::getTagValue(int index, unsigned num) const {
auto it = tagValues.find(index);
if(it != tagValues.end()) {
if(num >= it->second.size())
return ERR;
return it->second[num];
}
return ERR;
}
unsigned SubsystemDef::ModuleDesc::getTagValueCount(int index) const {
auto it = tagValues.find(index);
if(it != tagValues.end())
return it->second.size();
return 0;
}
bool SubsystemDef::ModuleDesc::hasTagValue(int index, const std::string& value) const {
auto it = tagValues.find(index);
if(it != tagValues.end()) {
for(size_t i = 0, cnt = it->second.size(); i < cnt; ++i) {
if(it->second[i] == value)
return true;
}
}
return false;
}
struct LookupData {
Design* design;
Subsystem* system;
int hexIndex;
float args[MODIFY_STAGE_MAXARGS];
};
Threaded(LookupData) lookupData;
static double formulaVariable(void* user, const std::string* name) {
return 0.0;
}
static double formulaIndex(void* user, int index) {
if(index == -1)
return 0.0;
bool isBase = (index & VTF_BaseVariable) != 0;
VariableType type = (VariableType)(index & 0x7f000000);
index &= 0x00ffffff;
switch(type) {
case VT_ConstantVariable:
switch(index) {
case CV_Hexes:
return lookupData.system->hexes.size();
case CV_InteriorHexes:
return lookupData.system->hexes.size() - lookupData.system->exteriorHexes;
case CV_ExteriorHexes:
return lookupData.system->exteriorHexes;
case CV_HexSize:
return lookupData.design->hexSize;
case CV_ShipSize:
return lookupData.design->size;
case CV_ShipTotalHexes:
return lookupData.design->hull->activeCount;
case CV_ShipUsedHexes:
return lookupData.design->usedHexCount;
case CV_ShipEmptyHexes:
return lookupData.design->hull->activeCount - lookupData.design->usedHexCount;
case CV_IsCore:
if(lookupData.hexIndex < 0 || (unsigned)lookupData.hexIndex >= lookupData.system->hexes.size())
return 0.0;
return (lookupData.system->modules[lookupData.hexIndex] == lookupData.system->type->coreModule) ? 1.0 : 0.0;
case CV_HexExterior:
if(lookupData.hexIndex < 0)
return 0.0;
return lookupData.design->hull->isExterior(lookupData.system->hexes[lookupData.hexIndex]) ? 1.0 : 0.0;
case CV_AdjacentActive: {
if(lookupData.hexIndex < 0 || (unsigned)lookupData.hexIndex >= lookupData.system->hexes.size())
return 0.0;
const Design * design = lookupData.design;
vec2u hex = lookupData.system->hexes[lookupData.hexIndex];
double count = 0;
for(unsigned d = 0; d < 6; ++d) {
vec2u pos = hex;
if(!design->hull->active.advance(pos.x, pos.y, HexGridAdjacency(d)))
continue;
if(!design->hull->active.get(pos))
continue;
count += 1.0;
}
return count;
}
case CV_AdjacentThis: {
if(lookupData.hexIndex < 0 || (unsigned)lookupData.hexIndex >= lookupData.system->hexes.size())
return 0.0;
const Design * design = lookupData.design;
vec2u hex = lookupData.system->hexes[lookupData.hexIndex];
double count = 0;
for(unsigned d = 0; d < 6; ++d) {
vec2u pos = hex;
if(!design->hull->active.advance(pos.x, pos.y, HexGridAdjacency(d)))
continue;
if(!design->hull->active.get(pos))
continue;
int sysId = design->grid.get(pos);
if((unsigned)sysId >= design->subsystems.size())
continue;
if(&design->subsystems[sysId] != lookupData.system)
continue;
count += 1.0;
}
return count;
}
}
return 0.0;
case VT_GameConfig:
if((size_t)index < gameConfig.count)
return gameConfig.values[index];
return 0.0;
case VT_ModuleCount:
if(index < 0 || index >= (int)lookupData.system->moduleCounts.size())
return 0.0;
return lookupData.system->moduleCounts[index];
case VT_ModuleExists:
if(index < 0 || index >= (int)lookupData.system->moduleCounts.size())
return 0.0;
return lookupData.system->moduleCounts[index] > 0 ? 1.0 : 0.0;
case VT_HexVariable:
//Make sure we're in a hex context
if(lookupData.hexIndex < 0)
return 0.0;
//Lookup local index
if(index < (int)lookupData.system->type->hexVariableIndices.size())
index = lookupData.system->type->hexVariableIndices[index];
else
index = -1;
//Lookup variable
if(index < 0) {
return 0.0;
}
else {
unsigned baseIndex = lookupData.hexIndex * lookupData.system->type->hexVariables.size();
if(isBase)
return lookupData.system->hexBaseVariables[baseIndex + index];
else
return lookupData.system->hexVariables[baseIndex + index];
}
case VT_ShipVariable:
//Lookup variable
if(index < 0) {
return 0.0;
}
else {
return lookupData.design->shipVariables[index];
}
case VT_SubsystemVariable:
//Lookup local index
if(index < (int)lookupData.system->type->variableIndices.size())
index = lookupData.system->type->variableIndices[index];
else
index = -1;
//Lookup variable
if(index < 0)
return 0.0;
else if(isBase)
return lookupData.system->baseVariables[index];
else
return lookupData.system->variables[index];
case VT_SumVariable: {
if(lookupData.design == nullptr)
return 0.0;
double value = 0.0;
for(size_t i = 0, cnt = lookupData.design->subsystems.size(); i < cnt; ++i) {
auto* sys = &lookupData.design->subsystems[i];
if(sys->variables == nullptr || sys->type == nullptr)
continue;
//Lookup local index
int localIndex = -1;
if((unsigned)index < (unsigned)sys->type->variableIndices.size())
localIndex = sys->type->variableIndices[index];
if(localIndex >= 0) {
if(isBase)
value += sys->baseVariables[localIndex];
else
value += sys->variables[localIndex];
}
}
return value;
}
case VT_HexSumVariable: {
if(lookupData.design == nullptr)
return 0.0;
double value = 0.0;
for(size_t i = 0, cnt = lookupData.design->subsystems.size(); i < cnt; ++i) {
auto* sys = &lookupData.design->subsystems[i];
if(sys->hexVariables == nullptr || sys->type == nullptr)
continue;
//Lookup local index
int localIndex = -1;
if((unsigned)index < (unsigned)sys->type->hexVariableIndices.size())
localIndex = sys->type->hexVariableIndices[index];
if(localIndex < 0)
continue;
for(size_t h = 0, hexCnt = sys->hexes.size(); h < hexCnt; ++h) {
if(sys == lookupData.system && h >= (unsigned)lookupData.hexIndex)
break;
int ind = h * sys->type->hexVariables.size() + localIndex;
if(isBase)
value += sys->hexBaseVariables[ind];
else
value += sys->hexVariables[ind];
}
}
return value;
}
case VT_TagCountVariable: {
if(lookupData.design == nullptr)
return 0.0;
double value = 0.0;
for(size_t i = 0, cnt = lookupData.design->subsystems.size(); i < cnt; ++i) {
if(lookupData.design->subsystems[i].type->hasTag(index))
value += 1.0;
}
return value;
}
case VT_Argument:
if(index >= 0 && index < MODIFY_STAGE_MAXARGS)
return lookupData.args[index];
else
return 0.0;
case VT_AdjacentTag: {
if(lookupData.hexIndex < 0 || (unsigned)lookupData.hexIndex >= lookupData.system->hexes.size())
return 0.0;
const Design * design = lookupData.design;
vec2u hex = lookupData.system->hexes[lookupData.hexIndex];
double count = 0;
for(unsigned d = 0; d < 6; ++d) {
vec2u pos = hex;
if(!design->hull->active.advance(pos.x, pos.y, HexGridAdjacency(d)))
continue;
if(!design->hull->active.get(pos))
continue;
int sysId = design->grid.get(pos);
if((unsigned)sysId >= design->subsystems.size())
continue;
if(!design->subsystems[sysId].type->hasTag(index))
continue;
count += 1.0;
}
return count;
}
case VT_AdjacentSubsystem: {
if(lookupData.hexIndex < 0 || (unsigned)lookupData.hexIndex >= lookupData.system->hexes.size())
return 0.0;
const Design * design = lookupData.design;
vec2u hex = lookupData.system->hexes[lookupData.hexIndex];
double count = 0;
for(unsigned d = 0; d < 6; ++d) {
vec2u pos = hex;
if(!design->hull->active.advance(pos.x, pos.y, HexGridAdjacency(d)))
continue;
if(!design->hull->active.get(pos))
continue;
int sysId = design->grid.get(pos);
if((unsigned)sysId >= design->subsystems.size())
continue;
if(design->subsystems[sysId].type->index != index)
continue;
count += 1.0;
}
return count;
}
}
return 0.0;
}
void Subsystem::init(const SubsystemDef& Def)
{
type = &Def;
unsigned effCount = Def.effects.size();
effects.resize(effCount);
for(unsigned i = 0; i < effCount; ++i)
effects[i].type = Def.effects[i].type;
unsigned efftrCount = Def.effectors.size();
effectors = (Effector*)malloc(efftrCount * sizeof(Effector));
for(unsigned i = 0; i < efftrCount; ++i) {
new(&effectors[i]) Effector(*Def.effectors[i].type);
effectors[i].enabled = Def.effectors[i].enabled;
effectors[i].effectorIndex = i;
effectors[i].skinIndex = Def.effectors[i].skinIndex;
}
defaults = new BasicType[Def.states.size()];
}
Subsystem::Subsystem()
: type(nullptr), exteriorHexes(0), hasErrors(false), variables(0), hexVariables(0),
inDesign(nullptr), index(0), defaults(nullptr), effectors(nullptr)
{
}
Subsystem::Subsystem(const SubsystemDef& Def)
: type(nullptr), exteriorHexes(0), hasErrors(false), variables(0), hexVariables(0),
inDesign(nullptr), index(0), defaults(nullptr), effectors(nullptr)
{
init(Def);
}
void Subsystem::skinEffectors(Empire& emp) {
if(emp.effectorSkin.empty())
return;
unsigned efftrCount = type->effectors.size();
for(unsigned i = 0; i < efftrCount; ++i) {
auto& efftr = effectors[i];
std::string ident = type->effectors[i].skinName;
if(!ident.empty())
ident += "/";
ident += emp.effectorSkin;
auto it = efftr.type.skinNames.find(ident);
if(it != efftr.type.skinNames.end())
efftr.skinIndex = it->second;
}
}
void SubsystemDef::ModifyStage::applyVariables(Subsystem* sys) const {
foreach(v, variables) {
int localIndex = sys->type->variableIndices[v->first];
Formula* formula = v->second;
if(formula)
sys->variables[localIndex] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
}
void SubsystemDef::ModifyStage::applyHexVariables(Subsystem* sys, int hexIndex) const {
foreach(v, hexVariables) {
int localIndex = sys->type->hexVariableIndices[v->first];
localIndex += hexIndex * sys->type->hexVariables.size();
Formula* formula = v->second;
if(formula)
sys->hexVariables[localIndex] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
}
void SubsystemDef::ModifyStage::applyShipVariables(Design* dsg, Subsystem* sys) const {
foreach(v, shipVariables) {
int index = v->first;
Formula* formula = v->second;
if(formula)
dsg->shipVariables[index] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
}
struct RunStage {
int priority;
int amount;
const SubsystemDef::ModifyStage* stage;
float args[MODIFY_STAGE_MAXARGS];
RunStage(int p, int a, const SubsystemDef::ModifyStage* s)
: priority(p), amount(a), stage(s) {
}
RunStage(int a, const SubsystemDef::AppliedStage& as)
: priority(as.stage->stage), amount(a), stage(as.stage) {
for(unsigned i = 0; i < MODIFY_STAGE_MAXARGS; ++i) {
if(as.formulas[i])
args[i] = (float)as.formulas[i]->evaluate(&formulaVariable, &lookupData, &formulaIndex);
else
args[i] = as.arguments[i];
}
}
bool operator<(const RunStage& other) const {
return priority < other.priority;
}
};
void applyShipModifier(const SubsystemDef* type, SubsystemDef::ShipModifier& mod, std::vector<RunStage>& modStages) {
auto fnd = type->modifierIds.find(mod.modifyName);
if(fnd == type->modifierIds.end())
return;
if(!conditionMatches(type, mod.conditions))
return;
SubsystemDef::AppliedStage applied;
for(unsigned i = 0; i < MODIFY_STAGE_MAXARGS; ++i)
applied.arguments[i] = mod.stage.arguments[i];
applied.stage = fnd->second;
modStages.push_back(RunStage(1, applied));
}
void Subsystem::initVariables(Design* design) {
//Make sure the lookup data matches
lookupData.design = design;
lookupData.system = this;
lookupData.hexIndex = -1;
//Get subsystem data from empire
Empire::SubsystemData* ssdata = 0;
if(design->owner) {
ssdata = design->owner->getSubsystemData(type);
//Add an error if this subsystem is not unlocked
if(!ssdata || !ssdata->unlocked) {
std::string errMsg = format(devices.locale.localize("ERROR_NOT_UNLOCKED").c_str(), type->name);
design->errors.push_back(DesignError(true, errMsg, this));
hasErrors = true;
}
}
//Hold a priority queue of considered modify stages
std::vector<RunStage> modStages;
//Evaluate variables
variables = new float[type->variables.size()];
baseVariables = new float[type->variables.size()];
memset(variables, 0, sizeof(float) * type->variables.size());
memset(baseVariables, 0, sizeof(float) * type->variables.size());
//Do modify stages from modules
unsigned modCnt = type->modules.size();
for(unsigned i = 0; i < modCnt; ++i) {
if(moduleCounts[i] > 0) {
auto& mod = *type->modules[i];
//Unique inline modifiers
foreach(it, mod.uniqueModifiers)
modStages.push_back(RunStage(it->stage, 1, &*it));
//Unique applied stages
foreach(it, mod.uniqueAppliedStages)
modStages.push_back(RunStage(1, *it));
//Inline modifiers
foreach(it, mod.modifiers)
modStages.push_back(RunStage(it->stage, moduleCounts[i], &*it));
//Applied stages
foreach(it, mod.appliedStages)
modStages.push_back(RunStage(moduleCounts[i], *it));
}
}
//Ship modifiers
foreach(it, design->modifiers)
applyShipModifier(type, *it, modStages);
//Do modify stages from empire
if(ssdata) {
foreach(it, ssdata->stages)
modStages.push_back(RunStage(1, it->second));
}
std::sort(modStages.begin(), modStages.end());
for(unsigned i = 0; i < type->variables.size(); ++i) {
auto* formula = type->variables[i].formula;
if(formula)
variables[i] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
else
variables[i] = 0;
baseVariables[i] = variables[i];
foreach(it, modStages) {
RunStage& rs = *it;
bool hasArgs = false;
foreach(v, rs.stage->variables) {
unsigned localIndex = type->variableIndices[v->first];
Formula* formula = v->second;
if(localIndex == i && formula) {
if(!hasArgs) {
memcpy(&lookupData.args, &rs.args, sizeof(rs.args));
hasArgs = true;
}
for(int repeats = 0; repeats < rs.amount; ++repeats)
variables[localIndex] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
}
}
}
//Evaluate ship variables
for(unsigned i = 0; i < type->shipVariables.size(); ++i) {
auto* formula = type->shipVariables[i].formula;
int index = type->shipVariables[i].index;
if(formula)
design->shipVariables[index] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
//Check if all modules are unlocked
for(unsigned i = 0; i < modCnt; ++i) {
if(moduleCounts[i] > 0) {
auto& mod = *type->modules[i];
if(ssdata) {
if(ssdata->modulesUnlocked.size() <= (unsigned)mod.index || !ssdata->modulesUnlocked[mod.index]) {
std::string errMsg = format(devices.locale.localize("ERROR_MODULE_NOT_UNLOCKED").c_str(), mod.name);
design->errors.push_back(DesignError(true, errMsg, this, &mod));
hasErrors = true;
}
}
}
}
//Run all the modify stages
foreach(it, modStages) {
RunStage& rs = *it;
memcpy(&lookupData.args, &rs.args, sizeof(rs.args));
for(int i = 0; i < rs.amount; ++i)
rs.stage->applyShipVariables(design, this);
}
//Dump
//for(unsigned j = 0; j < type->variables.size(); ++j) {
//printf("%s.%s = %g\n", type->id.c_str(),
//type->variables[j].name.c_str(), variables[j]);
//}
//Recompute mod stages without hex-specific ones
modStages.clear();
for(unsigned i = 0; i < modCnt; ++i) {
if(moduleCounts[i] > 0) {
auto& mod = *type->modules[i];
//Unique applied stages
foreach(it, mod.uniqueAppliedStages)
if(!it->stage->hexVariables.empty())
modStages.push_back(RunStage(1, *it));
//Applied stages
foreach(it, mod.appliedStages)
if(!it->stage->hexVariables.empty())
modStages.push_back(RunStage(moduleCounts[i], *it));
}
}
//Ship modifiers
foreach(it, design->modifiers)
applyShipModifier(type, *it, modStages);
//Do modify stages from empire
if(ssdata) {
foreach(it, ssdata->stages)
if(!it->second.stage->hexVariables.empty())
modStages.push_back(RunStage(1, it->second));
}
std::sort(modStages.begin(), modStages.end());
//Evaluate hex variables
unsigned varCnt = type->hexVariables.size();
unsigned hexCnt = hexes.size();
hexVariables = new float[varCnt * hexCnt];
hexBaseVariables = new float[varCnt * hexCnt];
hexAdjacentModifiers.resize(hexCnt);
hexEffects.resize(hexes.size());
bool foundCore = false;
for(unsigned i = 0; i < hexCnt; ++i) {
unsigned base = varCnt * i;
lookupData.hexIndex = i;
//Cache the position of the core
if(type->hasCore && modules[i] == type->coreModule) {
core = hexes[i];
foundCore = true;
}
//Initialize all the default formulas for a hex
for(unsigned j = 0; j < varCnt; ++j) {
auto* formula = type->hexVariables[j].formula;
if(formula)
hexVariables[base + j] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
else
hexVariables[base + j] = 0;
hexBaseVariables[base + j] = hexVariables[base + j];
}
//Add the modify stages
auto* mod = modules[i];
foreach(it, mod->uniqueModifiers) {
if(!it->hexVariables.empty()) {
it->applyHexVariables(this, i);
}
}
foreach(it, mod->modifiers) {
if(!it->hexVariables.empty()) {
it->applyHexVariables(this, i);
}
}
foreach(it, mod->hexAppliedStages) {
if(!it->stage->hexVariables.empty()) {
RunStage rs(1, *it);
memcpy(&lookupData.args, &rs.args, sizeof(float) * MODIFY_STAGE_MAXARGS);
rs.stage->applyHexVariables(this, i);
}
}
//Add adjacent modifiers
foreach(it, mod->adjacentModifiers) {
SubsystemDef::ShipModifier mod;
mod.modifyName = it->modifyName;
mod.conditions = it->conditions;
for(unsigned j = 0; j < MODIFY_STAGE_MAXARGS; ++j) {
if(it->stage.formulas[j])
mod.stage.arguments[j] = it->stage.formulas[j]->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
hexAdjacentModifiers[i].push_back(mod);
}
//Run the modify stages
foreach(it, modStages) {
RunStage& rs = *it;
memcpy(&lookupData.args, &rs.args, sizeof(float) * MODIFY_STAGE_MAXARGS);
for(int j = 0; j < rs.amount; ++j)
rs.stage->applyHexVariables(this, i);
}
//Run dependent variables again
for(unsigned j = 0; j < varCnt; ++j) {
if(!type->hexVariables[j].dependent)
continue;
auto* formula = type->hexVariables[j].formula;
if(formula)
hexVariables[base + j] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
//Dump
//for(unsigned j = 0; j < varCnt; ++j) {
//printf("%s[%d,%d].%s = %g\n", type->id.c_str(),
//hexes[i].x, hexes[i].y,
//type->hexVariables[j].name.c_str(),
//hexVariables[base + j]);
//}
}
//Re-evaluate variables marked as dependent to get the correct values
for(unsigned i = 0; i < type->variables.size(); ++i) {
if(!type->variables[i].dependent)
continue;
auto* formula = type->variables[i].formula;
if(formula)
variables[i] = (float)formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
//Add ship modifiers
foreach(it, type->shipModifiers) {
SubsystemDef::ShipModifier mod;
mod.modifyName = it->modifyName;
mod.conditions = it->conditions;
for(unsigned i = 0; i < MODIFY_STAGE_MAXARGS; ++i) {
if(it->stage.formulas[i])
mod.stage.arguments[i] = it->stage.formulas[i]->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
design->modifiers.push_back(mod);
}
//Add adjacent modifiers
foreach(it, type->adjacentModifiers) {
SubsystemDef::ShipModifier mod;
mod.modifyName = it->modifyName;
mod.conditions = it->conditions;
for(unsigned i = 0; i < MODIFY_STAGE_MAXARGS; ++i) {
if(it->stage.formulas[i])
mod.stage.arguments[i] = it->stage.formulas[i]->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
adjacentModifiers.push_back(mod);
}
//Add an error if this subsystem should have a core, but doesn't
if(type->hasCore && !foundCore) {
std::string errMsg = format(devices.locale.localize("ERROR_NO_CORE").c_str(), type->name);
design->errors.push_back(DesignError(true, errMsg, this));
hasErrors = true;
}
//Add an error if we needed an exterior core, but don't
if(type->hasCore && foundCore && type->exteriorCore && !design->hull->isExterior(core)) {
std::string errMsg = format(devices.locale.localize("ERROR_NEEDS_EXTERIOR_CORE").c_str(), type->name);
design->errors.push_back(DesignError(true, errMsg, this, 0, core));
hasErrors = true;
}
//Add an error if any required modules are not present
for(unsigned i = 0, modCnt = type->modules.size(); i < modCnt; ++i) {
auto* mod = type->modules[i];
if(mod->required && moduleCounts[i] == 0 && mod != type->coreModule) {
std::string errMsg = format(devices.locale.localize("ERROR_REQUIRED_MODULE").c_str(), type->name, mod->name);
design->errors.push_back(DesignError(true, errMsg, this, mod));
hasErrors = true;
}
if(mod->unique && moduleCounts[i] > 1) {
std::string errMsg = format(devices.locale.localize("ERROR_UNIQUE_MODULE").c_str(), type->name, mod->name);
design->errors.push_back(DesignError(true, errMsg, this, mod));
hasErrors = true;
}
}
//Add an error if we can't use this subsystem on this hull
if(!type->canUseOn(design->hull)) {
std::string errMsg = format(devices.locale.localize("ERROR_INVALID_HULL").c_str(), type->name);
design->errors.push_back(DesignError(true, errMsg, this));
hasErrors = true;
}
}
void Subsystem::applyAdjacencies(Design* design) {
lookupData.design = design;
lookupData.system = this;
std::vector<RunStage> modStages;
for(size_t n = 0, hexCnt = hexes.size(); n < hexCnt; ++n) {
vec2u hex = hexes[n];
lookupData.hexIndex = n;
if(!design->hull->active.valid(hex))
continue;
//Check all adjacent hexes
for(unsigned i = 0; i < 6; ++i) {
vec2u pos = hex;
if(!design->hull->active.advance(pos.x, pos.y, HexGridAdjacency(i)))
continue;
if(!design->hull->active.get(pos))
continue;
int sysId = design->grid.get(pos);
if((unsigned)sysId >= design->subsystems.size())
continue;
auto& otherSys = design->subsystems[sysId];
int hexId = design->hexIndex.get(pos);
if((unsigned)hexId >= otherSys.hexes.size())
continue;
for(size_t j = 0, jcnt = otherSys.adjacentModifiers.size(); j < jcnt; ++j)
applyShipModifier(this->type, otherSys.adjacentModifiers[j], modStages);
for(size_t j = 0, jcnt = otherSys.hexAdjacentModifiers[hexId].size(); j < jcnt; ++j)
applyShipModifier(this->type, otherSys.hexAdjacentModifiers[hexId][j], modStages);
}
std::sort(modStages.begin(), modStages.end());
//Run all the modify stages
foreach(it, modStages) {
RunStage& rs = *it;
memcpy(&lookupData.args, &rs.args, sizeof(rs.args));
for(int i = 0; i < rs.amount; ++i) {
rs.stage->applyVariables(this);
rs.stage->applyHexVariables(this, n);
}
}
modStages.clear();
}
}
extern double effVariable(void* effector, const std::string* name);
SubsystemDef::HookDesc::HookDesc(const std::string& str) {
if(!funcSplit(str, name, str_args))
name = str;
formulas.resize(str_args.size());
argValues.resize(str_args.size());
for(size_t i = 0, cnt = str_args.size(); i < cnt; ++i) {
formulas[i] = nullptr;
argValues[i] = 0.0;
}
}
void Subsystem::initEffects(Design* design) {
//Make sure the lookup data matches
lookupData.design = design;
lookupData.system = this;
lookupData.hexIndex = -1;
//Evaluate effect values
for(unsigned i = 0; i < type->effects.size(); ++i) {
for(unsigned j = 0; j < type->effects[i].values.size(); ++j) {
if(auto* formula = type->effects[i].values[j])
effects[i].values[j] = formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
else if(effects[i].type->values[j].defaultValue)
effects[i].values[j] = effects[i].type->values[j].defaultValue->evaluate();
}
}
//Evaluate effects from modules
for(unsigned i = 0; i < hexes.size(); ++i) {
auto* module = modules[i];
if(module->effects.empty())
continue;
lookupData.hexIndex = i;
for(unsigned n = 0; n < module->effects.size(); ++n) {
auto& def = module->effects[n];
Effect eff(def.type);
for(unsigned j = 0; j < def.values.size(); ++j) {
if(auto* formula = def.values[j])
eff.values[j] = formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
else if(eff.type->values[j].defaultValue)
eff.values[j] = eff.type->values[j].defaultValue->evaluate();
}
unsigned id = effects.size();
effects.push_back(eff);
hexEffects[i].push_back(id);
}
}
lookupData.hexIndex = -1;
for(unsigned i = 0; i < type->effectors.size(); ++i) {
//Evaluate effector values
for(unsigned j = 0; j < type->effectors[i].values.size(); ++j) {
if(auto* formula = type->effectors[i].values[j])
effectors[i].values[j] = formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
else if(effectors[i].type.values[j].defaultValue)
effectors[i].values[j] = effectors[i].type.values[j].defaultValue->evaluate(effVariable, &effectors[i]);
}
effectors[i].initValues();
//Set relative positions of the effectors
effectors[i].setRelativePosition(core, design->hull, direction);
//Deal with hex-limited angles
if(type->hexLimitArc && design->hull->active.valid(core) && !design->hasTag(overrideHexArcLimitTag)) {
auto& eff = effectors[i];
//Make sure the turret angle is within bounds
vec2d flatAngle(eff.turretAngle.x, -eff.turretAngle.z);
double rad = flatAngle.radians();
unsigned dir = HexGrid<>::AdjacencyFromRadians(rad);
if(!design->hull->isExteriorInDirection(core, dir)) {
double diff = rad - HexGrid<>::RadiansFromAdjacency(HexGridAdjacency(dir));
if(diff >= twopi / 6.0 * 0.5 * 0.99)
dir = (dir+1)%6;
else if(diff <= -twopi / 6.0 * 0.5 * 0.99)
dir = (6+dir-1)%6;
if(!design->hull->isExteriorInDirection(core, dir)) {
std::string errMsg = format(devices.locale.localize("ERROR_HEX_LIMIT_ARC").c_str(), type->name);
design->errors.push_back(DesignError(false, errMsg, this));
hasErrors = true;
eff.fireArc = -1.0;
}
}
//Move the turret angle to the center position so we scrunch the firing arc
if(eff.fireArc > 0) {
double specRad = HexGrid<>::RadiansFromAdjacency(HexGridAdjacency(dir));
double minRad = specRad - (twopi / 12.0);
double arc;
bool shouldChange = false;
arc = eff.fireArc - (rad - minRad);
for(unsigned n = 1; n <= 3 && arc > 0; ++n) {
unsigned chkDir = (6 + dir - n) % 6;
if(!design->hull->isExteriorInDirection(core, chkDir)) {
shouldChange = true;
minRad -= std::min(twopi / 48.0, arc);
break;
}
minRad -= std::min(twopi / 6.0, arc);
arc -= twopi / 6.0;
}
double maxRad = specRad + (twopi / 12.0);
arc = eff.fireArc - (maxRad - rad);
for(unsigned n = 1; n <= 3 && arc > 0; ++n) {
unsigned chkDir = (dir + n) % 6;
if(!design->hull->isExteriorInDirection(core, chkDir)) {
shouldChange = true;
maxRad += std::min(twopi / 48.0, arc);
break;
}
maxRad += std::min(twopi / 6.0, arc);
arc -= twopi / 6.0;
}
if(shouldChange) {
double arcRad = (maxRad - minRad) * 0.5;
eff.fireArc = std::min(arcRad, eff.fireArc);
vec2d newPos(1.0, 0.0);
newPos.rotate(minRad + (arcRad - eff.fireArc) * 0.5 + arcRad);
eff.turretAngle.x = newPos.x;
eff.turretAngle.z = -newPos.y;
}
}
}
//Set relative size of the effector
effectors[i].relativeSize = 3.0 * sqrt((double)hexes.size() / (double)design->hull->activeCount);
}
//Evaluate states
for(unsigned i = 0; i < type->states.size(); ++i) {
double value = 0;
if(auto* formula = type->states[i].formula)
value = formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
defaults[i].type = type->states[i].type;
switch(type->states[i].type) {
default:
case BT_Double:
defaults[i].decimal = value;
break;
case BT_Int:
defaults[i].integer = (int)value;
break;
case BT_Bool:
defaults[i].boolean = (bool)(value != 0.0);
break;
}
}
//Initialize hooks
for(size_t i = 0, cnt = type->hooks.size(); i < cnt; ++i)
addHook(design, type->hooks[i]);
for(size_t i = 0, cnt = modules.size(); i < cnt; ++i) {
auto* module = modules[i];
if(module) {
for(size_t n = 0, ncnt = module->hooks.size(); n < ncnt; ++n)
addHook(design, module->hooks[n]);
}
}
}
void Subsystem::addHook(Design* design, const SubsystemDef::HookDesc& hook) {
if(devices.scripts.server == devices.scripts.cache_shadow)
return;
std::vector<std::string> parts;
split(hook.name, parts, "::");
asITypeInfo* cls = nullptr;
if(parts.size() == 1)
cls = devices.scripts.server->getClass("subsystem_effects", parts[0].c_str());
else if(parts.size() == 2)
cls = devices.scripts.server->getClass(parts[0].c_str(), parts[1].c_str());
if(cls == nullptr)
return;
asIScriptObject* obj = (asIScriptObject*)devices.scripts.server->engine->CreateScriptObject(cls);
if(obj == nullptr)
return;
for(unsigned i = 0, cnt = hook.formulas.size(); i < cnt; ++i) {
if(hook.formulas[i])
hook.argValues[i] = hook.formulas[i]->evaluate(&formulaVariable, &lookupData, &formulaIndex);
else
hook.argValues[i] = 0.0;
}
auto call = devices.scripts.server->call(ScriptInitFunction);
bool retVal = false;
call.setObject(obj);
call.push(design);
call.push(this);
call.push(&hook.str_args);
call.push(&hook.argValues);
call.call(retVal);
if(retVal)
hookClasses.push_back(obj);
else
obj->Release();
}
void Subsystem::evaluatePost(Design* design) {
//Make sure the lookup data matches
lookupData.design = design;
lookupData.system = this;
lookupData.hexIndex = -1;
//Do any post-ship modifiers
std::vector<RunStage> stages;
foreach(it, type->postModifiers) {
SubsystemDef::ShipModifier mod;
mod.modifyName = it->modifyName;
mod.conditions = it->conditions;
for(unsigned i = 0; i < MODIFY_STAGE_MAXARGS; ++i) {
if(it->stage.formulas[i])
mod.stage.arguments[i] = it->stage.formulas[i]->evaluate(&formulaVariable, &lookupData, &formulaIndex);
}
applyShipModifier(type, mod, stages);
}
std::sort(stages.begin(), stages.end());
//Run all the modify stages
foreach(it, stages) {
memcpy(&lookupData.args, it->args, sizeof(it->args));
for(int i = 0; i < it->amount; ++i)
it->stage->applyVariables(this);
}
foreach(it, stages) {
memcpy(&lookupData.args, it->args, sizeof(it->args));
for(int i = 0; i < it->amount; ++i)
it->stage->applyShipVariables(design, this);
}
unsigned hexCnt = hexes.size();
for(unsigned i = 0; i < hexCnt; ++i) {
lookupData.hexIndex = i;
foreach(it, stages) {
memcpy(&lookupData.args, it->args, sizeof(it->args));
for(int n = 0; n < it->amount; ++n)
it->stage->applyHexVariables(this, i);
}
}
}
void Subsystem::evaluateAsserts(Design* design) {
//Make sure the lookup data matches
lookupData.design = design;
lookupData.system = this;
lookupData.hexIndex = -1;
auto checkAssert = [](Subsystem* sys, Design* design, const SubsystemDef::Assert& ass) {
if(!ass.formula)
return;
double val = ass.formula->evaluate(&formulaVariable, &lookupData, &formulaIndex);
if(val <= 0.0) {
//Check uniqueness
std::string msg = format(ass.message.c_str(), sys->type->name.c_str());
if(ass.unique) {
bool duplicate = false;
foreach(e, design->errors) {
if(e->fatal != ass.fatal)
continue;
if(e->text != msg)
continue;
duplicate = true;
break;
}
if(duplicate)
return;
design->errors.push_back(DesignError(
ass.fatal, msg, 0, 0));
sys->hasErrors = true;
}
else {
design->errors.push_back(DesignError(
ass.fatal, msg, sys, 0));
sys->hasErrors = true;
}
}
};
//Check any assertion errors
foreach(it, type->asserts) {
const SubsystemDef::Assert& ass = *it;
checkAssert(this, design, ass);
}
//Check hex asserts
for(unsigned i = 0, hexCount = (unsigned)hexes.size(); i < hexCount; ++i) {
lookupData.hexIndex = i;
foreach(it, modules[i]->asserts) {
const SubsystemDef::Assert& ass = *it;
checkAssert(this, design, ass);
}
if(modules[i]->onCheckErrors(design, this, hexes[i]))
hasErrors = true;
}
//Add any errors from the script check
if(type->onCheckErrors(design, this))
hasErrors = true;
}
void Subsystem::ownerChange(EffectEvent& event, Empire* prevEmpire, Empire* newEmpire) const {
for(unsigned i = 0; i < effects.size(); ++i)
effects[i].ownerChange(event, prevEmpire, newEmpire);
if(!hookClasses.empty()) {
SubsystemEvent evt;
evt.obj = event.obj;
evt.subsystem = this;
evt.blueprint = nullptr;
evt.design = inDesign;
evt.data = nullptr;
evt.efficiency = event.efficiency;
evt.partiality = event.partiality;
if(evt.obj != nullptr && evt.obj->type->blueprintOffset != 0)
evt.blueprint = (Blueprint*)(((size_t)evt.obj) + evt.obj->type->blueprintOffset);
for(size_t i = 0, cnt = hookClasses.size(); i < cnt; ++i) {
if(evt.blueprint != nullptr)
evt.data = evt.blueprint->data[dataOffset+i];
auto cl = devices.scripts.server->call(ScriptHookFunctions[EH_Owner_Change]);
cl.setObject(hookClasses[i]);
cl.push(&evt);
cl.push(prevEmpire);
cl.push(newEmpire);
cl.call();
}
}
}
void Subsystem::call(EffectHook hook, EffectEvent& event) const {
for(unsigned i = 0; i < effects.size(); ++i)
effects[i].call(hook, event);
if(!hookClasses.empty()) {
SubsystemEvent evt;
evt.obj = event.obj;
evt.subsystem = this;
evt.design = inDesign;
evt.blueprint = nullptr;
evt.data = nullptr;
evt.efficiency = event.efficiency;
evt.partiality = event.partiality;
if(evt.obj != nullptr && evt.obj->type->blueprintOffset != 0)
evt.blueprint = (Blueprint*)(((size_t)evt.obj) + evt.obj->type->blueprintOffset);
for(size_t i = 0, cnt = hookClasses.size(); i < cnt; ++i) {
if(evt.blueprint != nullptr)
evt.data = evt.blueprint->data[dataOffset+i];
auto cl = devices.scripts.server->call(ScriptHookFunctions[hook]);
cl.setObject(hookClasses[i]);
cl.push(&evt);
cl.call();
}
}
}
void Subsystem::save(EffectEvent& event, SaveMessage& msg) const {
if(!hookClasses.empty()) {
SubsystemEvent evt;
evt.obj = event.obj;
evt.subsystem = this;
evt.design = inDesign;
evt.blueprint = nullptr;
evt.data = nullptr;
evt.efficiency = event.efficiency;
evt.partiality = event.partiality;
if(evt.obj != nullptr && evt.obj->type->blueprintOffset != 0)
evt.blueprint = (Blueprint*)(((size_t)evt.obj) + evt.obj->type->blueprintOffset);
for(size_t i = 0, cnt = hookClasses.size(); i < cnt; ++i) {
if(evt.blueprint != nullptr)
evt.data = evt.blueprint->data[dataOffset+i];
auto cl = devices.scripts.server->call(ScriptHookFunctions[EH_Save]);
cl.setObject(hookClasses[i]);
cl.push(&evt);
cl.push(&msg);
cl.call();
}
}
}
void Subsystem::load(EffectEvent& event, SaveMessage& msg) const {
if(!hookClasses.empty()) {
SubsystemEvent evt;
evt.obj = event.obj;
evt.subsystem = this;
evt.design = inDesign;
evt.blueprint = nullptr;
evt.data = nullptr;
evt.efficiency = event.efficiency;
evt.partiality = event.partiality;
if(evt.obj != nullptr && evt.obj->type->blueprintOffset != 0)
evt.blueprint = (Blueprint*)(((size_t)evt.obj) + evt.obj->type->blueprintOffset);
for(size_t i = 0, cnt = hookClasses.size(); i < cnt; ++i) {
if(evt.blueprint != nullptr && dataOffset+i < inDesign->dataCount)
evt.data = evt.blueprint->data[dataOffset+i];
auto cl = devices.scripts.server->call(ScriptHookFunctions[EH_Load]);
cl.setObject(hookClasses[i]);
cl.push(&evt);
cl.push(&msg);
cl.call();
}
}
}
void Subsystem::tick(EffectEvent& event) const {
//Tick Effects
EffectStatus status = event.status;
for(unsigned i = 0; i < effects.size(); ++i) {
effects[i].call(EH_Tick, event);
//Cancel when any effect suspends or continues
if(status == ES_Suspended) {
if(event.status != ES_Suspended)
return;
}
else {
if(event.status == ES_Suspended)
return;
}
}
if(!hookClasses.empty() && event.status == ES_Active) {
SubsystemEvent evt;
evt.obj = event.obj;
evt.subsystem = this;
evt.design = inDesign;
evt.blueprint = nullptr;
evt.data = nullptr;
evt.efficiency = event.efficiency;
evt.partiality = event.partiality;
if(evt.obj != nullptr && evt.obj->type->blueprintOffset != 0)
evt.blueprint = (Blueprint*)(((size_t)evt.obj) + evt.obj->type->blueprintOffset);
for(size_t i = 0, cnt = hookClasses.size(); i < cnt; ++i) {
if(evt.blueprint != nullptr)
evt.data = evt.blueprint->data[dataOffset+i];
auto cl = devices.scripts.server->call(ScriptHookFunctions[EH_Tick]);
cl.setObject(hookClasses[i]);
cl.push(&evt);
cl.push(event.time);
cl.call();
}
}
}
DamageEventStatus Subsystem::damage(DamageEvent& event, const vec2u& position) const {
for(unsigned i = 0; i < type->effects.size(); ++i) {
switch(effects[i].damage(event, position)) {
case DE_Continue:
break;
case DE_SkipHex:
return DE_SkipHex;
case DE_EndDamage:
return DE_EndDamage;
}
}
if(inDesign != nullptr && inDesign->hull->active.valid(position)) {
unsigned hexIndex = (unsigned)inDesign->hexIndex[position];
if(hexIndex < hexEffects.size()) {
auto& hexEffs = hexEffects[hexIndex];
for(unsigned i = 0; i < hexEffs.size(); ++i) {
switch(effects[hexEffs[i]].damage(event, position)) {
case DE_Continue:
break;
case DE_SkipHex:
return DE_SkipHex;
case DE_EndDamage:
return DE_EndDamage;
}
}
}
}
if(!hookClasses.empty()) {
SubsystemEvent evt;
evt.obj = event.obj;
evt.subsystem = this;
evt.design = inDesign;
evt.blueprint = nullptr;
evt.data = nullptr;
if(evt.obj != nullptr && evt.obj->type->blueprintOffset != 0)
evt.blueprint = (Blueprint*)(((size_t)evt.obj) + evt.obj->type->blueprintOffset);
for(size_t i = 0, cnt = hookClasses.size(); i < cnt; ++i) {
if(evt.blueprint != nullptr)
evt.data = evt.blueprint->data[dataOffset+i];
auto cl = devices.scripts.server->call(ScriptHookFunctions[EH_Damage]);
unsigned retVal = 0;
cl.setObject(hookClasses[i]);
cl.push(&evt);
cl.push(&event);
cl.push(&position);
cl.call(retVal);
switch(retVal) {
case DE_Continue:
break;
case DE_SkipHex:
return DE_SkipHex;
case DE_EndDamage:
return DE_EndDamage;
}
}
}
return DE_Continue;
}
bool Subsystem::hasGlobalDamage() const {
if(!hookClasses.empty())
return true;
for(unsigned i = 0; i < effects.size(); ++i) {
if(effects[i].type->hooks[EH_GlobalDamage])
return true;
}
return false;
}
DamageEventStatus Subsystem::globalDamage(DamageEvent& event, vec2u& position, vec2d& endPoint) const {
for(unsigned i = 0; i < effects.size(); ++i) {
switch(effects[i].globalDamage(event, position, endPoint)) {
case DE_Continue:
break;
case DE_SkipHex:
return DE_SkipHex;
case DE_EndDamage:
return DE_EndDamage;
}
}
if(!hookClasses.empty()) {
SubsystemEvent evt;
evt.obj = event.obj;
evt.subsystem = this;
evt.design = inDesign;
evt.blueprint = nullptr;
evt.data = nullptr;
if(evt.obj != nullptr && evt.obj->type->blueprintOffset != 0)
evt.blueprint = (Blueprint*)(((size_t)evt.obj) + evt.obj->type->blueprintOffset);
for(size_t i = 0, cnt = hookClasses.size(); i < cnt; ++i) {
if(evt.blueprint != nullptr)
evt.data = evt.blueprint->data[dataOffset+i];
auto cl = devices.scripts.server->call(ScriptHookFunctions[EH_GlobalDamage]);
unsigned retVal = 0;
cl.setObject(hookClasses[i]);
cl.push(&evt);
cl.push(&event);
cl.push(&position);
cl.push(&endPoint);
cl.call(retVal);
switch(retVal) {
case DE_Continue:
break;
case DE_SkipHex:
return DE_SkipHex;
case DE_EndDamage:
return DE_EndDamage;
}
}
}
return DE_Continue;
}
float* Subsystem::variable(int index) {
if(index < 0)
return 0;
if((size_t)index >= type->variableIndices.size() || type->variableIndices[index] < 0)
return 0;
return &variables[type->variableIndices[index]];
}
const float* Subsystem::variable(int index) const {
//NOTE: Legit
return ((Subsystem*)this)->variable(index);
}
float* Subsystem::hexVariable(int index, int hexIndex) {
if(index < 0 || hexIndex < 0 || (unsigned)hexIndex >= hexes.size())
return 0;
if((size_t)index >= type->hexVariableIndices.size() || type->hexVariableIndices[index] < 0)
return 0;
int base = hexIndex * type->hexVariables.size();
int localIndex = type->hexVariableIndices[index];
return &hexVariables[base + localIndex];
}
const float* Subsystem::hexVariable(int index, int hexIndex) const {
//NOTE: Legit
return ((Subsystem*)this)->hexVariable(index, hexIndex);
}
void Subsystem::markConnected(HexGrid<bool>& grid, vec2u hex) {
if(!grid.valid(hex) || grid[hex])
return;
grid[hex] = true;
for(unsigned i = 0; i < 6; ++i) {
vec2u pos = hex;
if(grid.advance(pos, HexGridAdjacency(i))) {
if(inDesign->grid[pos] == int(this->index))
markConnected(grid, pos);
}
}
}
Subsystem::~Subsystem() {
delete[] variables;
delete[] hexVariables;
}
void Subsystem::init(SaveFile& file) {
int typeID = file.readIdentifier(SI_Subsystem);
type = getSubsystemDef(typeID);
if(type == 0)
throw SaveFileError("Subsystem definition does not exist");
file >> core >> exteriorHexes >> stateOffset >> effectorOffset;
file >> direction;
if(file >= SFV_0008)
file >> dataOffset;
else
dataOffset = 0;
unsigned hexCount = file;
hexes.resize(hexCount);
- file.read(&hexes.front(), hexes.size() * sizeof(vec2u));
+ file.read(hexes.data(), hexes.size() * sizeof(vec2u));
hexEffects.resize(hexCount);
if(file >= SFV_0010) {
for(unsigned i = 0; i < hexCount; ++i) {
unsigned cnt = file;
hexEffects[i].resize(cnt);
for(unsigned j = 0; j < cnt; ++j)
file >> hexEffects[i][j];
}
}
moduleCounts.resize(type->modules.size(), 0);
unsigned moduleCount = file;
modules.resize(moduleCount);
for(unsigned i = 0; i < modules.size(); ++i) {
int modIndex = -1;
if(file >= SFV_0012) {
int index = file.readIdentifier(SI_SubsystemModule);
if(index >= 0 && index < (int)ModulesByID.size())
modIndex = ModulesByID[index]->index;
}
else {
int index = file;
//Sorry, no actual way to do this nicely
if(index == 0) {
auto it = type->moduleIndices.find("Default");
if(it != type->moduleIndices.end())
modIndex = it->second;
}
else if(index == 1) {
auto it = type->moduleIndices.find("Core");
if(it != type->moduleIndices.end())
modIndex = it->second;
}
else {
auto it = type->moduleIndices.find("Bulkhead");
if(it != type->moduleIndices.end())
modIndex = it->second;
}
}
if(modIndex < 0 || modIndex >= (int)type->modules.size())
modIndex = type->defaultModule->index;
modules[i] = type->modules[modIndex];
moduleCounts[modIndex] += 1;
}
if(file >= SFV_0010) {
unsigned cnt = file;
effects.resize(cnt);
for(unsigned i = 0; i < cnt; ++i) {
effects[i].type = getEffectDefinition(file.readIdentifier(SI_Effect));
file.read(effects[i].values, sizeof(double) * EFFECT_MAX_VALUES);
}
}
else {
effects.resize(type->effects.size());
for(unsigned i = 0; i < type->effects.size(); ++i) {
effects[i].type = type->effects[i].type;
file.read(effects[i].values, sizeof(double) * effects[i].type->valueCount);
}
}
effectors = (Effector*)malloc(type->effectors.size() * sizeof(Effector));
for(unsigned i = 0; i < type->effectors.size(); ++i) {
new(&effectors[i]) Effector(*type->effectors[i].type);
Effector& effector = effectors[i];
effector.effectorIndex = i;
effector.load(file);
}
defaults = new BasicType[type->states.size()];
file.read(defaults, sizeof(BasicType) * type->states.size());
variables = new float[type->variables.size()]();
baseVariables = new float[type->variables.size()]();
hexVariables = new float[type->hexVariables.size() * hexCount]();
hexBaseVariables = new float[type->hexVariables.size() * hexCount]();
unsigned cnt = file;
for(unsigned i = 0; i < cnt; ++i) {
int globIndex = file.readIdentifier(SI_SubsystemVar);
int index = -1;
if((size_t)globIndex < type->variableIndices.size() && type->variableIndices[globIndex] >= 0)
index = type->variableIndices[globIndex];
if(index != -1) {
file >> variables[index];
file >> baseVariables[index];
}
else {
file.read<float>();
file.read<float>();
}
}
unsigned varCnt = file;
for(unsigned i = 0; i < varCnt; ++i) {
int globIndex = file.readIdentifier(SI_HexVar);
int index = -1;
if((size_t)globIndex < type->hexVariableIndices.size() && type->hexVariableIndices[globIndex] >= 0)
index = type->hexVariableIndices[globIndex];
for(unsigned j = 0; j < hexCount; ++j) {
int base = j * varCnt;
if(index != -1) {
file >> hexVariables[base + index];
file >> hexBaseVariables[base + index];
}
else {
file.read<float>();
file.read<float>();
}
}
}
}
void Subsystem::postLoad(Design* design) {
lookupData.design = design;
lookupData.system = this;
lookupData.hexIndex = -1;
//Initialize hooks
for(size_t i = 0, cnt = type->hooks.size(); i < cnt; ++i)
addHook(design, type->hooks[i]);
for(size_t i = 0, cnt = modules.size(); i < cnt; ++i) {
auto* module = modules[i];
if(module) {
for(size_t n = 0, ncnt = module->hooks.size(); n < ncnt; ++n)
addHook(design, module->hooks[n]);
}
}
}
Subsystem::Subsystem(SaveFile& file)
: type(nullptr), exteriorHexes(0), hasErrors(false), variables(0), hexVariables(0),
inDesign(nullptr), index(0), defaults(nullptr), effectors(nullptr)
{
init(file);
}
void Subsystem::save(SaveFile& file) const {
file.writeIdentifier(SI_Subsystem, type->index);
file << core << exteriorHexes << stateOffset << effectorOffset;
file << direction;
file << dataOffset;
file << unsigned(hexes.size());
- file.write(&hexes.front(), hexes.size() * sizeof(vec2u));
+ file.write(hexes.data(), hexes.size() * sizeof(vec2u));
for(unsigned i = 0; i < hexes.size(); ++i) {
file << (unsigned)hexEffects[i].size();
for(unsigned j = 0; j < hexEffects[i].size(); ++j)
file << hexEffects[i][j];
}
file << unsigned(modules.size());
for(unsigned i = 0; i < modules.size(); ++i)
file.writeIdentifier(SI_SubsystemModule, modules[i]->umodid);
file << (unsigned)effects.size();
for(unsigned i = 0; i < effects.size(); ++i) {
file.writeIdentifier(SI_Effect, effects[i].type->id);
file.write(effects[i].values, sizeof(double) * EFFECT_MAX_VALUES);
}
for(unsigned i = 0; i < type->effectors.size(); ++i) {
Effector& effector = effectors[i];
effector.save(file);
}
file.write(defaults, sizeof(BasicType) * type->states.size());
unsigned cnt = type->variables.size();
file << cnt;
for(unsigned i = 0; i < cnt; ++i) {
file.writeIdentifier(SI_SubsystemVar, type->variables[i].index);
file << variables[i];
file << baseVariables[i];
}
unsigned varCnt = type->hexVariables.size();
unsigned hexCnt = hexes.size();
file << varCnt;
for(unsigned i = 0; i < varCnt; ++i) {
file.writeIdentifier(SI_HexVar, type->hexVariables[i].index);
for(unsigned j = 0; j < hexCnt; ++j) {
int base = j * varCnt;
file << hexVariables[base + i];
file << hexBaseVariables[base + i];
}
}
}
void Subsystem::writeData(net::Message& msg) const {
msg.writeSmall(type->index);
msg.writeSmall(hexes.size());
for(size_t i = 0, cnt = hexes.size(); i < cnt; ++i) {
msg.writeSmall(hexes[i].x);
msg.writeSmall(hexes[i].y);
msg.writeSmall(modules[i]->index);
}
for(size_t i = 0, cnt = type->modules.size(); i < cnt; ++i)
msg.writeSmall(moduleCounts[i]);
msg.writeSmall(core.x);
msg.writeSmall(core.y);
msg.writeDirection(direction.x, direction.y, direction.z);
msg.writeSmall(exteriorHexes);
msg.writeSmall(stateOffset);
msg.writeSmall(effectorOffset);
for(size_t i = 0, cnt = type->variables.size(); i < cnt; ++i) {
msg << variables[i];
msg << baseVariables[i];
}
unsigned varCnt = type->hexVariables.size() * hexes.size();
for(size_t i = 0; i < varCnt; ++i) {
msg << hexVariables[i];
msg << hexBaseVariables[i];
}
for(size_t i = 0; i < type->states.size(); ++i) {
switch(type->states[i].type) {
default:
case BT_Double:
msg << defaults[i].decimal;
break;
case BT_Int:
msg << defaults[i].integer;
break;
case BT_Bool:
msg << defaults[i].boolean;
break;
}
}
msg << (unsigned)effects.size();
for(size_t i = 0, cnt = effects.size(); i < cnt; ++i)
effects[i].writeData(msg);
for(size_t i = 0, cnt = type->effectors.size(); i < cnt; ++i)
effectors[i].writeData(msg);
}
Subsystem::Subsystem(net::Message& msg) : hasErrors(false), inDesign(nullptr), index(0) {
unsigned sysId = msg.readSmall();
type = getSubsystemDef(sysId);
hexes.resize(msg.readSmall());
modules.resize(hexes.size());
hexEffects.resize(hexes.size());
for(size_t i = 0, cnt = hexes.size(); i < cnt; ++i) {
hexes[i].x = msg.readSmall();
hexes[i].y = msg.readSmall();
modules[i] = type->modules[msg.readSmall()];
}
moduleCounts.resize(type->modules.size());
for(size_t i = 0, cnt = type->modules.size(); i < cnt; ++i)
moduleCounts[i] = msg.readSmall();
core.x = msg.readSmall();
core.y = msg.readSmall();
msg.readDirection(direction.x, direction.y, direction.z);
exteriorHexes = msg.readSmall();
stateOffset = msg.readSmall();
effectorOffset = msg.readSmall();
dataOffset = 0;
variables = new float[type->variables.size()];
baseVariables = new float[type->variables.size()];
for(size_t i = 0, cnt = type->variables.size(); i < cnt; ++i) {
msg >> variables[i];
msg >> baseVariables[i];
}
unsigned varCnt = type->hexVariables.size() * hexes.size();
hexVariables = new float[varCnt];
hexBaseVariables = new float[varCnt];
for(size_t i = 0; i < varCnt; ++i) {
msg >> hexVariables[i];
msg >> hexBaseVariables[i];
}
defaults = new BasicType[type->states.size()];
for(size_t i = 0; i < type->states.size(); ++i) {
defaults[i].type = type->states[i].type;
switch(type->states[i].type) {
default:
case BT_Double:
msg >> defaults[i].decimal;
break;
case BT_Int:
msg >> defaults[i].integer;
break;
case BT_Bool:
msg >> defaults[i].boolean;
break;
}
}
unsigned cnt = 0;
msg >> cnt;
effects.resize(cnt);
for(size_t i = 0; i < cnt; ++i)
effects[i].readData(msg);
effectors = (Effector*)malloc(type->effectors.size() * sizeof(Effector));
for(size_t i = 0, cnt = type->effectors.size(); i < cnt; ++i)
new(&effectors[i]) Effector(msg);
}
diff --git a/source/game/render/bmf_loader.cpp b/source/game/render/bmf_loader.cpp
index b64b171..06ca661 100644
--- a/source/game/render/bmf_loader.cpp
+++ b/source/game/render/bmf_loader.cpp
@@ -1,265 +1,265 @@
#include "bmf_loader.h"
#include <fstream>
#include <map>
#include <string.h>
//BMF Specification (version 0):
//uint32 == "BMF "
//uint32: version number (0 for current version)
//
//uint32: vertex count
//Repeat <vertex count>:
// float x,y,z: vertex[n] coordinates
//
//uint32: normal count
//Repeat <normal count>:
// float x,y,z: normal[n] values
//
//uint32: uv count
//Repeat <uv count>:
// float u,v: uv[n] coordinates
//
//uint32: face count
//Repeat <face count>:
// If <vertex count> <= 0xffff
// uint16 v1,v2,v3: face[n] vertex indices
// Else
// uint32 v1,v2,v3: face[n] vertex indices
//
// If <normal count> > 0
// If <normal count> <= 0xffff
// uint16 n1,n2,n3: face[n] normal indices
// Else
// uint32 n1,n2,n3: face[n] normal indices
//
// If <uv count> > 0
// If <uv count> <= 0xffff
// uint16 u1,u2,u3: face[n] uv indices
// Else
// uint32 u1,u2,u3: face[n] uv indices
//First 4 characters of any Binary Mesh File
const char* bmfHead = "BMF ";
namespace render {
namespace bmf {
struct VertexIndex {
unsigned a, b, c;
VertexIndex() : a(0), b(0), c(0) {}
VertexIndex(unsigned A, unsigned B, unsigned C) : a(A), b(B), c(C) {}
bool operator<(const VertexIndex& other) const {
return memcmp(this, &other, sizeof(unsigned) * 3) < 0;
}
};
}
using namespace bmf;
struct UV {
float u, v;
};
void loadBinaryMesh(const char* filename, Mesh& mesh) {
static_assert(sizeof(vec3f) == 12, "vec3f must be the size of 3 floats");
static_assert(sizeof(UV) == 8, "UV must be the size of 2 floats");
std::vector<vec3f> vertices;
std::vector<vec3f> normals;
std::vector<UV> uvs;
std::ifstream file(filename, std::ios_base::binary | std::ios_base::in);
if(!file.is_open())
return;
char buff[4];
file.read(buff, 4);
if(file.fail() || strncmp(bmfHead, buff, 4) != 0)
return;
unsigned version;
file.read((char*)&version, sizeof(version));
if(file.fail() || version != 0)
return;
//Vertices
unsigned count;
file.read((char*)&count, sizeof(count));
if(file.fail() || count == 0)
return;
vertices.resize(count);
- file.read((char*)&vertices.front(), sizeof(vec3f) * count);
+ file.read((char*)vertices.data(), sizeof(vec3f) * count);
//Normals
file.read((char*)&count, sizeof(count));
if(file.fail())
return;
normals.resize(count);
- file.read((char*)&normals.front(), sizeof(vec3f) * count);
+ file.read((char*)normals.data(), sizeof(vec3f) * count);
//UVs
file.read((char*)&count, sizeof(count));
if(file.fail())
return;
uvs.resize(count);
- file.read((char*)&uvs.front(), sizeof(UV) * count);
+ file.read((char*)uvs.data(), sizeof(UV) * count);
//Faces
file.read((char*)&count, sizeof(count));
if(file.fail())
return;
std::map<VertexIndex,unsigned> vertexMap;
mesh.faces.reserve(count);
mesh.vertices.reserve(count);
for(unsigned i = 0; i < count; ++i) {
Mesh::Face face;
Vertex vertex[3];
VertexIndex vertIndices[3];
//Load vertex position indices
for(unsigned j = 0; j < 3; ++j) {
unsigned index;
if(vertices.size() <= 0xffff) {
unsigned short v;
file.read((char*)&v, sizeof(v));
index = v;
}
else {
file.read((char*)&index, sizeof(index));
}
if(index >= vertices.size())
index = 0;
vertex[j].position = vertices[index];
vertIndices[j].a = index;
}
//Load vertex normal indices
if(!normals.empty()) {
for(unsigned j = 0; j < 3; ++j) {
unsigned index;
if(normals.size() <= 0xffff) {
unsigned short v;
file.read((char*)&v, sizeof(v));
index = v;
}
else {
file.read((char*)&index, sizeof(index));
}
if(index >= normals.size())
index = 0;
vertex[j].normal = normals[index];
vertIndices[j].b = index;
}
}
//Load vertex uv indices
if(!uvs.empty()) {
for(unsigned j = 0; j < 3; ++j) {
unsigned index;
if(uvs.size() <= 0xffff) {
unsigned short v;
file.read((char*)&v, sizeof(v));
index = v;
}
else {
file.read((char*)&index, sizeof(index));
}
if(index >= uvs.size())
index = 0;
vertex[j].u = uvs[index].u;
vertex[j].v = uvs[index].v;
vertIndices[j].c = index;
}
}
if(file.fail())
return;
//Automatically fuse identical vertices and store results in mesh
unsigned indices[3];
for(unsigned j = 0; j < 3; ++j) {
auto previous = vertexMap.find(vertIndices[j]);
if(previous != vertexMap.end()) {
indices[j] = previous->second;
}
else {
indices[j] = (unsigned)mesh.vertices.size();
mesh.vertices.push_back(vertex[j]);
vertexMap[vertIndices[j]] = indices[j];
}
}
face.a = indices[0];
face.b = indices[1];
face.c = indices[2];
mesh.faces.push_back(face);
}
}
bool saveBinaryMesh(const char* filename, Mesh& mesh) {
std::ofstream file(filename, std::ios_base::binary | std::ios_base::out);
if(!file.is_open())
return false;
file.write(bmfHead, 4);
unsigned version = 0;
file.write((char*)&version, sizeof(version));
//TODO: Writes duplicate data unnecessarily
unsigned count;
count = (unsigned)mesh.vertices.size();
file.write((char*)&count, sizeof(count));
for(unsigned i = 0; i < count; ++i)
file.write((char*)&mesh.vertices[i].position, sizeof(vec3f));
count = (unsigned)mesh.vertices.size();
file.write((char*)&count, sizeof(count));
for(unsigned i = 0; i < count; ++i)
file.write((char*)&mesh.vertices[i].normal, sizeof(vec3f));
count = (unsigned)mesh.vertices.size();
file.write((char*)&count, sizeof(count));
for(unsigned i = 0; i < count; ++i) {
file.write((char*)&mesh.vertices[i].u, sizeof(float));
file.write((char*)&mesh.vertices[i].v, sizeof(float));
}
bool shortIndices = mesh.vertices.size() <= 0xffff;
count = (unsigned)mesh.faces.size();
file.write((char*)&count, sizeof(count));
for(unsigned i = 0; i < count; ++i) {
Mesh::Face face = mesh.faces[i];
if(shortIndices) {
unsigned short data[] = {face.a, face.b, face.c, face.a, face.b, face.c, face.a, face.b, face.c};
file.write((char*)data, sizeof(data));
}
else {
unsigned data[] = {face.a, face.b, face.c, face.a, face.b, face.c, face.a, face.b, face.c};
file.write((char*)data, sizeof(data));
}
}
return true;
}
};
diff --git a/source/game/render/gl_vertexBuffer.cpp b/source/game/render/gl_vertexBuffer.cpp
index 3a04192..bfeaf07 100644
--- a/source/game/render/gl_vertexBuffer.cpp
+++ b/source/game/render/gl_vertexBuffer.cpp
@@ -1,316 +1,316 @@
#include "vertexBuffer.h"
#include "compat/gl.h"
#include "main/references.h"
#include "compat/misc.h"
#include <unordered_map>
const unsigned maxVerts = 2048, maxInds = 4096;
unsigned drawnSteps = 0, bufferFlushes = 0;
namespace render {
unsigned vbFloatLimit = 24, vbMaxSteps = 200;
unsigned vbFlushCounts[FC_COUNT] = {0,0,0,0};
extern const RenderMesh* lastRenderedMesh;
extern float* shaderUniforms;
VertexBufferTCV tcv;
threads::Mutex bufferLock;
extern bool useVertexArrays();
inline bool getRequestSize(unsigned& indexCount, unsigned& vertCount, unsigned polygons, unsigned polyType) {
switch(polyType) {
case PT_Lines:
indexCount = polygons * 2;
vertCount = polygons * 2;
return true;
case PT_LineStrip:
indexCount = polygons * 2;
vertCount = polygons + 1;
return true;
case PT_Triangles:
indexCount = polygons * 3;
vertCount = polygons * 3;
return false;
case PT_Quads:
indexCount = polygons * 6;
vertCount = polygons * 4;
return false;
NO_DEFAULT
}
}
void buildIndices(std::vector<unsigned short>& indices, unsigned indexCount, unsigned prevVerts, unsigned polygons, unsigned polyType) {
//Fill out indices according to the polygon type
auto prevInds = indices.size();
indices.resize(prevInds + indexCount);
unsigned short* pIndices = &indices.at(0);
switch(polyType) {
case PT_Lines:
for(unsigned i = 0; i < polygons * 2; ++i)
pIndices[prevInds + i] = prevVerts + i;
break;
case PT_LineStrip:
for(unsigned i = 0; i < polygons; ++i) {
pIndices[prevInds + (i*2)] = prevVerts + i;
pIndices[prevInds + (i*2) + 1] = prevVerts + i + 1;
}
break;
case PT_Triangles:
for(unsigned i = 0; i < polygons * 3; ++i)
pIndices[prevInds + i] = prevVerts + i;
break;
case PT_Quads:
for(unsigned i = 0; i < polygons; ++i) {
auto off = prevInds + (i*6);
auto vOff = prevVerts + (i*4);
pIndices[off] = vOff;
pIndices[off+1] = vOff+2;
pIndices[off+2] = vOff+1;
pIndices[off+3] = vOff;
pIndices[off+4] = vOff+3;
pIndices[off+5] = vOff+2;
}
break;
NO_DEFAULT
}
}
void renderVertexBuffers() {
tcv.draw();
}
VertexBufferTCV::VertexBufferTCV()
: last(0)
{
vertices.reserve(maxVerts);
indices.reserve(maxInds);
steps.reserve(vbMaxSteps);
shaderBufferSize = 40000;
shaderBuffer = new float[shaderBufferSize];
pNextShaderBuffer = shaderBuffer;
}
VertexBufferTCV::~VertexBufferTCV() {
for(auto i = vertBuffer.begin(), end = vertBuffer.end(); i != end; ++i)
glDeleteBuffers(1, &*i);
for(auto i = indBuffer.begin(), end = indBuffer.end(); i != end; ++i)
glDeleteBuffers(1, &*i);
delete[] shaderBuffer;
}
void VertexBufferTCV::flushRetainingLast(FlushCause reason) {
RenderStep step = *last;
float* prevBuffer = pNextShaderBuffer;
//We may have added a step that we decided we can't render, we just pop the empty step
if(step.vertEnd == 0)
steps.pop_back();
draw(reason);
step.vertStart = 0;
step.vertEnd = 0;
step.indexOffset = 0;
if(step.shaderCache) {
memcpy(pNextShaderBuffer, step.shaderCache, (prevBuffer - step.shaderCache) * sizeof(float));
auto count = prevBuffer - step.shaderCache;
step.shaderCache = pNextShaderBuffer;
pNextShaderBuffer += count;
}
steps.push_back(step);
last = &steps.back();
}
void VertexBufferTCV::duplicateLast() {
if(steps.size() != steps.capacity()) {
steps.push_back(*last);
last = &steps.back();
last->indexOffset = (unsigned short)indices.size();
last->vertStart = (unsigned short)vertices.size();
}
else {
flushRetainingLast(FC_StepLimit);
}
}
VertexTCV* VertexBufferTCV::request(unsigned polygons, unsigned polyType) {
unsigned indexCount = 0;
unsigned vertCount = 0;
bool isLines = getRequestSize(indexCount, vertCount, polygons, polyType);
unsigned prevVerts = (unsigned)vertices.size();
if(prevVerts + vertCount > maxVerts
|| indices.size() + indexCount > maxInds)
{
flushRetainingLast(FC_VertexLimit);
last->lines = isLines;
prevVerts = 0;
}
if(last->lines == isLines) {
vertices.resize(prevVerts + vertCount);
buildIndices(indices, indexCount, prevVerts, polygons, polyType);
if(last->vertEnd)
last->vertEnd += vertCount;
else
last->vertEnd = last->vertStart + vertCount - 1;
return &vertices[prevVerts];
}
else if(last->vertEnd != 0) {
duplicateLast();
last->lines = isLines;
vertices.resize(prevVerts + vertCount);
buildIndices(indices, indexCount, prevVerts, polygons, polyType);
last->vertEnd = last->vertStart + vertCount - 1;
return &vertices[prevVerts];
}
else {
last->lines = isLines;
vertices.resize(prevVerts + vertCount);
buildIndices(indices, indexCount, prevVerts, polygons, polyType);
last->vertEnd = last->vertStart + vertCount - 1;
return &vertices[prevVerts];
}
}
void VertexBufferTCV::draw(FlushCause reason) {
if(vertices.empty())
return;
if(vertBuffer.empty()) {
GLuint buffs[24];
glGenBuffers(24, buffs);
for(unsigned i = 0; i < 12; ++i)
vertBuffer.push_back(buffs[i]);
for(unsigned i = 12; i < 24; ++i)
indBuffer.push_back(buffs[i]);
}
{
lastRenderedMesh = reinterpret_cast<const render::RenderMesh*>(this);
if(useVertexArrays())
glBindVertexArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indBuffer.front());
glBindBuffer(GL_ARRAY_BUFFER, vertBuffer.front());
indBuffer.push_back(indBuffer.front());
indBuffer.pop_front();
vertBuffer.push_back(vertBuffer.front());
vertBuffer.pop_front();
if(!useVertexArrays()) {
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
glDisableVertexAttribArray(4);
glDisableVertexAttribArray(5);
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(VertexTCV), (void*)offsetof(VertexTCV, uv));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexTCV), (void*)offsetof(VertexTCV, col));
glVertexPointer(3, GL_FLOAT, sizeof(VertexTCV), (void*)offsetof(VertexTCV, pos));
}
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned short),
&indices[0], GL_STREAM_DRAW);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(VertexTCV), &vertices[0], GL_STREAM_DRAW);
drawnSteps += (unsigned)steps.size();
bufferFlushes += 1;
vbFlushCounts[reason] += 1;
- RenderStep* pSteps = &steps.front();
+ RenderStep* pSteps = steps.data();
for(unsigned i = 0, cnt = (unsigned)steps.size(); i < cnt; ++i) {
auto& step = pSteps[i];
shaderUniforms = step.shaderCache;
devices.render->switchToRenderState(*step.material);
unsigned count = ((i+1) < cnt ? pSteps[i+1].indexOffset : (unsigned short)indices.size()) - step.indexOffset;
glDrawRangeElements(step.lines ? GL_LINES : GL_TRIANGLES, step.vertStart, step.vertEnd,
count, GL_UNSIGNED_SHORT, (void*)(step.indexOffset * sizeof(unsigned short)));
}
shaderUniforms = 0;
vertices.clear();
indices.clear();
steps.clear();
last = 0;
pNextShaderBuffer = shaderBuffer;
}
VertexBufferTCV* VertexBufferTCV::fetch(const RenderState* mat) {
auto& vbuff = tcv;
if(vbuff.last == 0 || vbuff.last->material != mat) {
if(vbuff.steps.size() == vbMaxSteps)
vbuff.draw(FC_StepLimit);
RenderStep step;
step.material = mat;
step.lines = false;
step.indexOffset = (unsigned short)tcv.indices.size();
step.vertStart = tcv.steps.empty() ? 0 : tcv.steps.back().vertEnd + 1;
step.vertEnd = 0;
if(mat->shader && !mat->shader->constant) {
step.shaderCache = tcv.pNextShaderBuffer;
mat->shader->saveDynamicVars(tcv.pNextShaderBuffer);
tcv.pNextShaderBuffer += mat->shader->dynamicFloats;
}
else {
step.shaderCache = 0;
}
vbuff.steps.push_back(step);
vbuff.last = &vbuff.steps.back();
}
else if(mat->shader && !mat->shader->constant) {
auto* buffer = vbuff.pNextShaderBuffer;
unsigned floats = mat->shader->dynamicFloats;
if(buffer + floats >= vbuff.shaderBuffer + vbuff.shaderBufferSize) {
//Flush the buffer and re-fetch the step
vbuff.draw(FC_ShaderLimit);
return fetch(mat);
}
else {
mat->shader->saveDynamicVars(buffer);
auto* lastStep = vbuff.last;
//When a shader uses a small enough amount of data, check to see if it's duplicated
//If it is, we can batch it into one step
if(floats > vbFloatLimit || memcmp(lastStep->shaderCache, buffer, floats * sizeof(float)) != 0) {
tcv.steps.push_back(*lastStep);
lastStep = &tcv.steps.back();
tcv.last = lastStep;
lastStep->shaderCache = buffer;
lastStep->indexOffset = (unsigned short)tcv.indices.size();
lastStep->vertStart = lastStep->vertEnd + 1;
lastStep->vertEnd = 0;
vbuff.pNextShaderBuffer += floats;
}
}
}
return &vbuff;
}
};

File Metadata

Mime Type
text/x-diff
Expires
Fri, Sep 12, 8:12 PM (1 d, 15 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
42864
Default Alt Text
(158 KB)

Event Timeline