Lucas de Vries
1267 lines
30 KiB
C++
1267 lines
30 KiB
C++
#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);
|
|
|
|
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());
|
|
|
|
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();
|
|
}
|