void WeaponDef::LoadSound(
const LuaTable& wdTable,
const std::string& soundKey,
const unsigned int soundIdx,
std::vector<GuiSoundSet::Data>& soundData)
{
string name = "";
int id = -1;
float volume = -1.0f;
soundData.push_back(GuiSoundSet::Data(name, id, volume));
assert(soundIdx < soundData.size());
assert(soundData[soundIdx].id == -1);
if (soundKey == "soundStart") {
name = wdTable.GetString(soundKey, "");
volume = wdTable.GetFloat(soundKey + "Volume", -1.0f);
}
else if (soundKey == "soundHitDry") {
name = wdTable.GetString(soundKey, wdTable.GetString("soundHit", ""));
volume = wdTable.GetFloat(soundKey + "Volume", wdTable.GetFloat("soundHitVolume", -1.0f));
}
else if (soundKey == "soundHitWet") {
name = wdTable.GetString(soundKey, wdTable.GetString("soundHit", ""));
volume = wdTable.GetFloat(soundKey + "Volume", wdTable.GetFloat("soundHitVolume", -1.0f));
}
if (name.empty())
return;
if ((id = CommonDefHandler::LoadSoundFile(name)) <= 0)
return;
soundData[soundIdx] = GuiSoundSet::Data(name, id, volume);
}
void CMapInfo::ReadTerrainTypes()
{
const LuaTable terrTypeTable =
mapRoot->SubTable("terrainTypes");
for (int tt = 0; tt < 256; tt++) {
TerrainType& terrType = terrainTypes[tt];
const LuaTable terrain = terrTypeTable.SubTable(tt);
terrType.name = terrain.GetString("name", "Default");
terrType.hardness = terrain.GetFloat("hardness", 1.0f);
terrType.receiveTracks = terrain.GetBool("receiveTracks", true);
const LuaTable moveTable = terrain.SubTable("moveSpeeds");
terrType.tankSpeed = moveTable.GetFloat("tank", 1.0f);
terrType.kbotSpeed = moveTable.GetFloat("kbot", 1.0f);
terrType.hoverSpeed = moveTable.GetFloat("hover", 1.0f);
terrType.shipSpeed = moveTable.GetFloat("ship", 1.0f);
// clamps
terrType.hardness = max(0.0f, terrType.hardness);
terrType.tankSpeed = max(0.0f, terrType.tankSpeed);
terrType.kbotSpeed = max(0.0f, terrType.kbotSpeed);
terrType.hoverSpeed = max(0.0f, terrType.hoverSpeed);
terrType.shipSpeed = max(0.0f, terrType.shipSpeed);
}
}
void CWeaponDefHandler::LoadSound(const LuaTable& wdTable,
GuiSoundSet& gsound, const string& soundCat)
{
string name = "";
float volume = -1.0f;
if (soundCat == "start") {
name = wdTable.GetString("soundStart", "");
volume = wdTable.GetFloat("soundStartVolume", -1.0f);
}
else if (soundCat == "hit") {
name = wdTable.GetString("soundHit", "");
volume = wdTable.GetFloat("soundHitVolume", -1.0f);
}
if (name != "") {
const int id = LoadSoundFile(name);
if (id > 0)
{
GuiSoundSet::Data soundData(name, 0, volume);
gsound.sounds.push_back(soundData);
gsound.setID(0, id);
}
}
}
void CMapInfo::ReadGlobal()
{
const LuaTable topTable = *mapRoot;
map.humanName = topTable.GetString("description", map.name);
map.wantedScript = topTable.GetString("script", map.wantedScript);
map.hardness = topTable.GetFloat("maphardness", 100.0f);
map.notDeformable = topTable.GetBool("notDeformable", false);
map.gravity = topTable.GetFloat("gravity", 130.0f);
map.gravity = max(0.001f, map.gravity);
map.gravity = -map.gravity / (GAME_SPEED * GAME_SPEED);
map.tidalStrength = topTable.GetFloat("tidalStrength", 0.0f);
map.maxMetal = topTable.GetFloat("maxMetal", 0.02f);
map.extractorRadius = topTable.GetFloat("extractorRadius", 500.0f);
map.voidWater = topTable.GetBool("voidWater", false);
// clamps
map.hardness = max(0.0f, map.hardness);
map.tidalStrength = max(0.0f, map.tidalStrength);
map.maxMetal = max(0.0f, map.maxMetal);
map.extractorRadius = max(0.0f, map.extractorRadius);
}
void CMapInfo::ReadGlobal()
{
const LuaTable topTable = parser->GetRoot();
map.description = topTable.GetString("description", map.name);
map.author = topTable.GetString("author", "");
map.hardness = topTable.GetFloat("maphardness", 100.0f);
map.notDeformable = topTable.GetBool("notDeformable", false);
map.gravity = topTable.GetFloat("gravity", 130.0f);
map.gravity = max(0.001f, map.gravity);
map.gravity = -map.gravity / (GAME_SPEED * GAME_SPEED);
map.tidalStrength = topTable.GetFloat("tidalStrength", 0.0f);
map.maxMetal = topTable.GetFloat("maxMetal", 0.02f);
map.extractorRadius = topTable.GetFloat("extractorRadius", 500.0f);
map.voidWater = topTable.GetBool("voidWater", false);
// clamps
if (-0.001f < map.hardness && map.hardness <= 0.0f)
map.hardness = -0.001f;
else if (0.0f <= map.hardness && map.hardness < 0.001f)
map.hardness = 0.001f;
map.tidalStrength = max(0.000f, map.tidalStrength);
map.maxMetal = max(0.000f, map.maxMetal);
map.extractorRadius = max(0.000f, map.extractorRadius);
}
void CMapInfo::ReadGrass()
{
const LuaTable grassTable = parser->GetRoot().SubTable("grass");
grass.bladeWaveScale = grassTable.GetFloat("bladeWaveScale", 1.0f);
grass.bladeWidth = grassTable.GetFloat("bladeWidth", 0.32f);
grass.bladeHeight = grassTable.GetFloat("bladeHeight", 4.0f);
grass.bladeAngle = grassTable.GetFloat("bladeAngle", 1.57f);
}
void CUnitDefHandler::LoadSounds(const LuaTable& soundsTable, GuiSoundSet& gsound, const string& soundName)
{
string fileName = soundsTable.GetString(soundName, "");
if (!fileName.empty()) {
LoadSound(gsound, fileName, 1.0f);
return;
}
LuaTable sndTable = soundsTable.SubTable(soundName);
for (int i = 1; true; i++) {
LuaTable sndFileTable = sndTable.SubTable(i);
if (sndFileTable.IsValid()) {
fileName = sndFileTable.GetString("file", "");
if (!fileName.empty()) {
const float volume = sndFileTable.GetFloat("volume", 1.0f);
if (volume > 0.0f) {
LoadSound(gsound, fileName, volume);
}
}
} else {
fileName = sndTable.GetString(i, "");
if (fileName.empty()) {
break;
}
LoadSound(gsound, fileName, 1.0f);
}
}
}
void CMapInfo::ReadStartPos()
{
const float defX = 1000.0f;
const float defZ = 1000.0f;
const float defXStep = 100.0f;
const float defZStep = 100.0f;
const LuaTable teamsTable = mapRoot->SubTable("teams");
for (int t = 0; t < MAX_TEAMS; ++t) {
float3 pos;
pos.x = defX + (defXStep * t);
pos.z = defZ + (defZStep * t);
pos.y = 0.0f;
const LuaTable posTable = teamsTable.SubTable(t).SubTable("startPos");
if (posTable.KeyExists("x") &&
posTable.KeyExists("z")) {
pos.x = posTable.GetFloat("x", pos.x);
pos.z = posTable.GetFloat("z", pos.z);
havePos.push_back(true);
} else {
havePos.push_back(false);
}
startPos.push_back(pos);
}
}
// Calculate model radius from the min/max extents
void CAssParser::CalculateModelProperties(S3DModel* model, const LuaTable& modelTable)
{
CalculateModelDimensions(model, model->rootPiece);
// note: overrides default midpos of the SpringRadius piece
model->relMidPos.y = (model->maxs.y + model->mins.y) * 0.5f;
// Simplified dimensions used for rough calculations
model->radius = modelTable.GetFloat("radius", float3::max(float3::fabs(model->maxs), float3::fabs(model->mins)).Length());
model->height = modelTable.GetFloat("height", model->maxs.y);
model->relMidPos = modelTable.GetFloat3("midpos", model->relMidPos);
model->mins = modelTable.GetFloat3("mins", model->mins);
model->maxs = modelTable.GetFloat3("maxs", model->maxs);
model->drawRadius = model->radius;
}
void SolidObjectDecalDef::Parse(const LuaTable& table) {
groundDecalTypeName = table.GetString("groundDecalType", table.GetString("buildingGroundDecalType", ""));
trackDecalTypeName = table.GetString("trackType", "StdTank");
useGroundDecal = table.GetBool("useGroundDecal", table.GetBool("useBuildingGroundDecal", false));
groundDecalType = -1;
groundDecalSizeX = table.GetInt("groundDecalSizeX", table.GetInt("buildingGroundDecalSizeX", 4));
groundDecalSizeY = table.GetInt("groundDecalSizeY", table.GetInt("buildingGroundDecalSizeY", 4));
groundDecalDecaySpeed = table.GetFloat("groundDecalDecaySpeed", table.GetFloat("buildingGroundDecalDecaySpeed", 0.1f));
leaveTrackDecals = table.GetBool("leaveTracks", false);
trackDecalType = -1;
trackDecalWidth = table.GetFloat("trackWidth", 32.0f);
trackDecalOffset = table.GetFloat("trackOffset", 0.0f);
trackDecalStrength = table.GetFloat("trackStrength", 0.0f);
trackDecalStretch = table.GetFloat("trackStretch", 1.0f);
}
void CMapInfo::ReadSmf()
{
// SMF specific settings
const LuaTable mapResTable = parser->GetRoot().SubTable("resources");
smf.detailTexName = mapResTable.GetString("detailTex", "");
smf.specularTexName = mapResTable.GetString("specularTex", "");
smf.splatDetailTexName = mapResTable.GetString("splatDetailTex", "");
smf.splatDistrTexName = mapResTable.GetString("splatDistrTex", "");
smf.grassBladeTexName = mapResTable.GetString("grassBladeTex", "");
smf.grassShadingTexName = mapResTable.GetString("grassShadingTex", "");
smf.skyReflectModTexName = mapResTable.GetString("skyReflectModTex", "");
smf.detailNormalTexName = mapResTable.GetString("detailNormalTex", "");
smf.lightEmissionTexName = mapResTable.GetString("lightEmissionTex", "");
if (!smf.detailTexName.empty()) {
smf.detailTexName = "maps/" + smf.detailTexName;
} else {
const LuaTable& resGfxMaps = resRoot->SubTable("graphics").SubTable("maps");
smf.detailTexName = resGfxMaps.GetString("detailtex", "detailtex2.bmp");
smf.detailTexName = "bitmaps/" + smf.detailTexName;
}
if (!smf.specularTexName.empty()) { smf.specularTexName = "maps/" + smf.specularTexName; }
if (!smf.splatDetailTexName.empty()) { smf.splatDetailTexName = "maps/" + smf.splatDetailTexName; }
if (!smf.splatDistrTexName.empty()) { smf.splatDistrTexName = "maps/" + smf.splatDistrTexName; }
if (!smf.grassBladeTexName.empty()) { smf.grassBladeTexName = "maps/" + smf.grassBladeTexName; }
if (!smf.grassShadingTexName.empty()) { smf.grassShadingTexName = "maps/" + smf.grassShadingTexName; }
if (!smf.skyReflectModTexName.empty()) { smf.skyReflectModTexName = "maps/" + smf.skyReflectModTexName; }
if (!smf.detailNormalTexName.empty()) { smf.detailNormalTexName = "maps/" + smf.detailNormalTexName; }
if (!smf.lightEmissionTexName.empty()) { smf.lightEmissionTexName = "maps/" + smf.lightEmissionTexName; }
// height overrides
const LuaTable smfTable = parser->GetRoot().SubTable("smf");
smf.minHeightOverride = smfTable.KeyExists("minHeight");
smf.maxHeightOverride = smfTable.KeyExists("maxHeight");
smf.minHeight = smfTable.GetFloat("minHeight", 0.0f);
smf.maxHeight = smfTable.GetFloat("maxHeight", 0.0f);
std::stringstream ss;
for (int i = 0; /* no test */; i++) {
ss.str("");
ss << "smtFileName" << i;
if (smfTable.KeyExists(ss.str())) {
smf.smtFileNames.push_back(smfTable.GetString(ss.str(), ".smt"));
} else {
break;
}
}
}
void CWeaponDefHandler::LoadSound(const LuaTable& wdTable,
GuiSoundSet& gsound, const string& soundCat)
{
string name = "";
float volume = -1.0f;
if (soundCat == "start") {
name = wdTable.GetString("soundStart", "");
volume = wdTable.GetFloat("soundStartVolume", -1.0f);
}
else if (soundCat == "hit") {
name = wdTable.GetString("soundHit", "");
volume = wdTable.GetFloat("soundHitVolume", -1.0f);
}
if (name != "") {
if (!sound->HasSoundItem(name))
{
if (name.find(".wav") == string::npos) {
// .wav extension missing, add it
name += ".wav";
}
const string soundPath = "sounds/" + name;
CFileHandler sfile(soundPath);
if (sfile.FileExists()) {
// only push data if we extracted a valid name
GuiSoundSet::Data soundData(name, 0, volume);
gsound.sounds.push_back(soundData);
int id = sound->GetSoundId(soundPath);
gsound.setID(0, id);
}
}
else
{
GuiSoundSet::Data soundData(name, 0, volume);
gsound.sounds.push_back(soundData);
int id = sound->GetSoundId(name);
gsound.setID(0, id);
}
}
}
void CMapInfo::ReadAtmosphere()
{
// MAP\ATMOSPHERE
const LuaTable atmoTable = mapRoot->SubTable("atmosphere");
atmosphere_t& atmo = atmosphere;
atmo.cloudDensity = atmoTable.GetFloat("cloudDensity", 0.5f);
atmo.minWind = atmoTable.GetFloat("minWind", 5.0f);
atmo.maxWind = atmoTable.GetFloat("maxWind", 25.0f);
atmo.fogStart = atmoTable.GetFloat("fogStart", 0.1f);
atmo.fogColor = atmoTable.GetFloat3("fogColor", float3(0.7f, 0.7f, 0.8f));
atmo.skyColor = atmoTable.GetFloat3("skyColor", float3(0.1f, 0.15f, 0.7f));
atmo.sunColor = atmoTable.GetFloat3("sunColor", float3(1.0f, 1.0f, 1.0f));
atmo.cloudColor = atmoTable.GetFloat3("cloudColor", float3(1.0f, 1.0f, 1.0f));
atmo.skyBox = atmoTable.GetString("skyBox", "");
// clamps
atmo.cloudDensity = max(0.0f, atmo.cloudDensity);
atmo.maxWind = max(0.0f, atmo.maxWind);
atmo.minWind = max(0.0f, atmo.minWind);
atmo.minWind = min(atmo.maxWind, atmo.minWind);
}
// Calculate model radius from the min/max extents
void CAssParser::CalculateModelProperties(S3DModel* model, const LuaTable& modelTable)
{
CalculateModelDimensions(model, model->rootPiece);
model->mins = modelTable.GetFloat3("mins", model->mins);
model->maxs = modelTable.GetFloat3("maxs", model->maxs);
model->radius = modelTable.GetFloat("radius", (model->maxs - model->mins ).Length() * 0.5f);
model->height = modelTable.GetFloat("height", (model->maxs.y - model->mins.y) );
model->relMidPos = modelTable.GetFloat3("midpos", (model->maxs + model->mins) * 0.5f);
}
void CMapInfo::ReadLight()
{
const LuaTable lightTable = mapRoot->SubTable("lighting");
light.sunDir = lightTable.GetFloat3("sunDir", float3(0.0f, 1.0f, 2.0f));
light.sunDir.Normalize();
light.groundAmbientColor = lightTable.GetFloat3("groundAmbientColor",
float3(0.5f, 0.5f, 0.5f));
light.groundSunColor = lightTable.GetFloat3("groundDiffuseColor",
float3(0.5f, 0.5f, 0.5f));
light.groundSpecularColor = lightTable.GetFloat3("groundSpecularColor",
float3(0.1f, 0.1f, 0.1f));
light.groundShadowDensity = lightTable.GetFloat("groundShadowDensity", 0.8f);
light.unitAmbientColor = lightTable.GetFloat3("unitAmbientColor",
float3(0.4f, 0.4f, 0.4f));
light.unitSunColor = lightTable.GetFloat3("unitDiffuseColor",
float3(0.7f, 0.7f, 0.7f));
light.specularSunColor = lightTable.GetFloat3("unitSpecularColor",
light.unitSunColor);
light.unitShadowDensity = lightTable.GetFloat("unitShadowDensity", 0.8f);
}
void CMapInfo::ReadLight()
{
const LuaTable lightTable = parser->GetRoot().SubTable("lighting");
light.sunStartAngle = lightTable.GetFloat("sunStartAngle", 0.0f);
light.sunOrbitTime = lightTable.GetFloat("sunOrbitTime", 1440.0f);
light.sunDir = lightTable.GetFloat4("sunDir", float4(0.0f, 1.0f, 2.0f, FLT_MAX));
if (light.sunDir.w == FLT_MAX) { // if four params are not specified for sundir, fallback to the old three param format
light.sunDir = lightTable.GetFloat3("sunDir", float3(0.0f, 1.0f, 2.0f));
light.sunDir.w = FLT_MAX;
}
light.sunDir.ANormalize();
light.groundAmbientColor = lightTable.GetFloat3("groundAmbientColor", float3(0.5f, 0.5f, 0.5f));
light.groundSunColor = lightTable.GetFloat3("groundDiffuseColor", float3(0.5f, 0.5f, 0.5f));
light.groundSpecularColor = lightTable.GetFloat3("groundSpecularColor", float3(0.1f, 0.1f, 0.1f));
light.groundShadowDensity = lightTable.GetFloat("groundShadowDensity", 0.8f);
light.unitAmbientColor = lightTable.GetFloat3("unitAmbientColor", float3(0.4f, 0.4f, 0.4f));
light.unitSunColor = lightTable.GetFloat3("unitDiffuseColor", float3(0.7f, 0.7f, 0.7f));
light.unitSpecularColor = lightTable.GetFloat3("unitSpecularColor", light.unitSunColor);
light.unitShadowDensity = lightTable.GetFloat("unitShadowDensity", 0.8f);
}
bool MapParser::GetStartPos(int team, float3& pos) const
{
if (!parser->IsValid()) {
return false;
}
const LuaTable teamsTable = parser->GetRoot().SubTable("teams");
const LuaTable posTable = teamsTable.SubTable(team).SubTable("startPos");
if (!posTable.IsValid()) {
return false;
}
pos.x = posTable.GetFloat("x", pos.x);
pos.z = posTable.GetFloat("z", pos.z);
return true;
}
bool MapParser::GetStartPos(int team, float3& pos) const
{
errorLog.clear();
if (!parser->IsValid()) {
errorLog = "Map-Parser: Failed to get start position for team " + IntToString(team) + ", reason: " + parser->GetErrorLog();
return false;
}
const LuaTable teamsTable = parser->GetRoot().SubTable("teams");
const LuaTable posTable = teamsTable.SubTable(team).SubTable("startPos");
if (!posTable.IsValid()) {
errorLog = "Map-Parser: Failed to get start position for team " + IntToString(team) + ", reason: Not defined in the map's config!";
return false;
}
pos.x = posTable.GetFloat("x", pos.x);
pos.z = posTable.GetFloat("z", pos.z);
return true;
}
void CMapInfo::ReadSmf()
{
// SMF specific settings
const LuaTable mapResTable = mapRoot->SubTable("resources");
smf.detailTexName = mapResTable.GetString("detailTex", "");
if (!smf.detailTexName.empty()) {
smf.detailTexName = "maps/" + smf.detailTexName;
}
else {
const LuaTable resGfxMaps = resRoot->SubTable("graphics").SubTable("maps");
smf.detailTexName = resGfxMaps.GetString("detailtex", "detailtex2.bmp");
smf.detailTexName = "bitmaps/" + smf.detailTexName;
}
// height overrides
const LuaTable smfTable = mapRoot->SubTable("smf");
smf.minHeightOverride = smfTable.KeyExists("minHeight");
smf.maxHeightOverride = smfTable.KeyExists("maxHeight");
smf.minHeight = smfTable.GetFloat("minHeight", 0.0f);
smf.maxHeight = smfTable.GetFloat("maxHeight", 0.0f);
}
void CAssParser::LoadPieceTransformations(SAssPiece* piece, const LuaTable& pieceMetaTable)
{
//! Process transforms
float3 rotate, scale, offset;
aiVector3D _scale, _offset;
aiQuaternion _rotate;
piece->node->mTransformation.Decompose(_scale,_rotate,_offset);
LOG_S(LOG_SECTION_PIECE,
"(%d:%s) Assimp offset (%f,%f,%f), rotate (%f,%f,%f), scale (%f,%f,%f)",
piece->model->numPieces, piece->name.c_str(),
_offset.x, _offset.y, _offset.z,
_rotate.x, _rotate.y, _rotate.z,
_scale.x, _scale.y, _scale.z
);
offset = pieceMetaTable.GetFloat3("offset", float3(_offset.x, _offset.y, _offset.z));
offset.x = pieceMetaTable.GetFloat("offsetx", offset.x);
offset.y = pieceMetaTable.GetFloat("offsety", offset.y);
offset.z = pieceMetaTable.GetFloat("offsetz", offset.z);
rotate = QuaternionToRadianAngles(_rotate);
rotate = float3(rotate.z, rotate.x, rotate.y); //! swizzle
rotate = pieceMetaTable.GetFloat3("rotate", rotate * RADTODEG);
rotate.x = pieceMetaTable.GetFloat("rotatex", rotate.x);
rotate.y = pieceMetaTable.GetFloat("rotatey", rotate.y);
rotate.z = pieceMetaTable.GetFloat("rotatez", rotate.z);
rotate *= DEGTORAD;
scale = pieceMetaTable.GetFloat3("scale", float3(_scale.x, _scale.z, _scale.y));
scale.x = pieceMetaTable.GetFloat("scalex", scale.x);
scale.y = pieceMetaTable.GetFloat("scaley", scale.y);
scale.z = pieceMetaTable.GetFloat("scalez", scale.z);
LOG_S(LOG_SECTION_PIECE,
"(%d:%s) Relative offset (%f,%f,%f), rotate (%f,%f,%f), scale (%f,%f,%f)",
piece->model->numPieces, piece->name.c_str(),
offset.x, offset.y, offset.z,
rotate.x, rotate.y, rotate.z,
scale.x, scale.y, scale.z
);
piece->offset = offset;
piece->rot = rotate;
piece->scale = scale;
}
void CCustomExplosionGenerator::Load(CExplosionGeneratorHandler* h, const string& tag)
{
static std::map<string, CEGData> cachedCEGs;
std::map<string, CEGData>::iterator it = cachedCEGs.find(tag);
if (it == cachedCEGs.end()) {
CEGData cegData;
const LuaTable& root = h->GetTable();
const LuaTable expTable = root.SubTable(tag);
if (!expTable.IsValid()) {
throw content_error("Explosion info for " + tag + " not found.");
}
vector<string> spawns;
expTable.GetKeys(spawns);
for (vector<string>::iterator si = spawns.begin(); si != spawns.end(); ++si) {
ProjectileSpawnInfo psi;
const string& spawnName = *si;
const LuaTable spawnTable = expTable.SubTable(spawnName);
if (!spawnTable.IsValid() || spawnName == "groundflash") {
continue;
}
const string className = spawnTable.GetString("class", spawnName);
unsigned int flags = 0;
if (spawnTable.GetBool("ground", false)) {
flags |= SPW_GROUND;
}
if (spawnTable.GetBool("water", false)) {
flags |= SPW_WATER;
}
if (spawnTable.GetBool("air", false)) {
flags |= SPW_AIR;
}
if (spawnTable.GetBool("underwater", false)) {
flags |= SPW_UNDERWATER;
}
if (spawnTable.GetBool("unit", false)) {
flags |= SPW_UNIT;
}
if (spawnTable.GetBool("nounit", false)) {
flags |= SPW_NO_UNIT;
}
psi.projectileClass = h->projectileClasses.GetClass(className);
psi.flags = flags;
psi.count = spawnTable.GetInt("count", 1);
string code;
map<string, string> props;
map<string, string>::const_iterator propIt;
spawnTable.SubTable("properties").GetMap(props);
for (propIt = props.begin(); propIt != props.end(); ++propIt) {
creg::Class::Member* m = psi.projectileClass->FindMember(propIt->first.c_str());
if (m && (m->flags & creg::CM_Config)) {
ParseExplosionCode(&psi, m->offset, m->type, propIt->second, code);
}
}
code += (char)OP_END;
psi.code.resize(code.size());
copy(code.begin(), code.end(), psi.code.begin());
cegData.projectileSpawn.push_back(psi);
}
const LuaTable gndTable = expTable.SubTable("groundflash");
const int ttl = gndTable.GetInt("ttl", 0);
if (ttl > 0) {
cegData.groundFlash.circleAlpha = gndTable.GetFloat("circleAlpha", 0.0f);
cegData.groundFlash.flashSize = gndTable.GetFloat("flashSize", 0.0f);
cegData.groundFlash.flashAlpha = gndTable.GetFloat("flashAlpha", 0.0f);
cegData.groundFlash.circleGrowth = gndTable.GetFloat("circleGrowth", 0.0f);
cegData.groundFlash.color = gndTable.GetFloat3("color", float3(1.0f, 1.0f, 0.8f));
unsigned int flags = SPW_GROUND;
if (gndTable.GetBool("ground", false)) {
flags |= SPW_GROUND;
}
if (gndTable.GetBool("water", false)) {
flags |= SPW_WATER;
}
if (gndTable.GetBool("air", false)) {
flags |= SPW_AIR;
}
if (gndTable.GetBool("underwater", false)) {
flags |= SPW_UNDERWATER;
}
if (gndTable.GetBool("unit", false)) {
flags |= SPW_UNIT;
}
if (gndTable.GetBool("nounit", false)) {
flags |= SPW_NO_UNIT;
}
cegData.groundFlash.flags = flags;
cegData.groundFlash.ttl = ttl;
}
cegData.useDefaultExplosions = expTable.GetBool("useDefaultExplosions", false);
cachedCEGs[tag] = cegData;
currentCEG = &cachedCEGs[tag];
} else {
currentCEG = &(it->second);
}
}
unsigned int CCustomExplosionGenerator::Load(CExplosionGeneratorHandler* h, const string& tag)
{
unsigned int explosionID = -1U;
if (tag.empty()) {
return explosionID;
}
const std::map<std::string, unsigned int>::const_iterator it = explosionIDs.find(tag);
if (it == explosionIDs.end()) {
CEGData cegData;
const LuaTable* root = h->GetExplosionTableRoot();
const LuaTable& expTable = (root != NULL)? root->SubTable(tag): LuaTable();
if (!expTable.IsValid()) {
// not a fatal error: any calls to ::Explosion will just return early
logOutput.Print("[CCEG::Load] WARNING: table for CEG \"" + tag + "\" invalid (parse errors?)");
return explosionID;
}
vector<string> spawns;
expTable.GetKeys(spawns);
for (vector<string>::iterator si = spawns.begin(); si != spawns.end(); ++si) {
ProjectileSpawnInfo psi;
const string& spawnName = *si;
const LuaTable spawnTable = expTable.SubTable(spawnName);
if (!spawnTable.IsValid() || spawnName == "groundflash") {
continue;
}
const string className = spawnTable.GetString("class", spawnName);
psi.projectileClass = h->projectileClasses.GetClass(className);
psi.flags = GetFlagsFromTable(spawnTable);
psi.count = spawnTable.GetInt("count", 1);
if (psi.projectileClass->binder->flags & creg::CF_Synced) {
psi.flags |= SPW_SYNCED;
}
string code;
map<string, string> props;
map<string, string>::const_iterator propIt;
spawnTable.SubTable("properties").GetMap(props);
for (propIt = props.begin(); propIt != props.end(); ++propIt) {
creg::Class::Member* m = psi.projectileClass->FindMember(propIt->first.c_str());
if (m && (m->flags & creg::CM_Config)) {
ParseExplosionCode(&psi, m->offset, m->type, propIt->second, code);
}
}
code += (char)OP_END;
psi.code.resize(code.size());
copy(code.begin(), code.end(), psi.code.begin());
cegData.projectileSpawn.push_back(psi);
}
const LuaTable gndTable = expTable.SubTable("groundflash");
const int ttl = gndTable.GetInt("ttl", 0);
if (ttl > 0) {
cegData.groundFlash.circleAlpha = gndTable.GetFloat("circleAlpha", 0.0f);
cegData.groundFlash.flashSize = gndTable.GetFloat("flashSize", 0.0f);
cegData.groundFlash.flashAlpha = gndTable.GetFloat("flashAlpha", 0.0f);
cegData.groundFlash.circleGrowth = gndTable.GetFloat("circleGrowth", 0.0f);
cegData.groundFlash.color = gndTable.GetFloat3("color", float3(1.0f, 1.0f, 0.8f));
cegData.groundFlash.flags = SPW_GROUND | GetFlagsFromTable(gndTable);
cegData.groundFlash.ttl = ttl;
}
cegData.useDefaultExplosions = expTable.GetBool("useDefaultExplosions", false);
explosionID = explosionData.size();
explosionData.push_back(cegData);
explosionIDs[tag] = explosionID;
} else {
explosionID = it->second;
}
return explosionID;
}
void CCustomExplosionGenerator::Load(CExplosionGeneratorHandler* h, const string& tag)
{
typedef std::map<string, CEGData> CEGMap;
typedef std::map<string, CEGData>::iterator CEGMapIt;
CEGMapIt it = cachedCEGs.find(tag);
if (it == cachedCEGs.end()) {
CEGData cegData;
const LuaTable& root = h->GetTable();
const LuaTable expTable = root.SubTable(tag);
if (!expTable.IsValid()) {
throw content_error("Explosion info for " + tag + " not found.");
}
vector<string> spawns;
expTable.GetKeys(spawns);
for (vector<string>::iterator si = spawns.begin(); si != spawns.end(); ++si) {
ProjectileSpawnInfo psi;
const string& spawnName = *si;
const LuaTable spawnTable = expTable.SubTable(spawnName);
if (!spawnTable.IsValid() || spawnName == "groundflash") {
continue;
}
const string className = spawnTable.GetString("class", spawnName);
psi.projectileClass = h->projectileClasses.GetClass(className);
psi.flags = GetFlagsFromTable(spawnTable);
psi.count = spawnTable.GetInt("count", 1);
if (psi.projectileClass->binder->flags & creg::CF_Synced) {
psi.flags |= SPW_SYNCED;
}
string code;
map<string, string> props;
map<string, string>::const_iterator propIt;
spawnTable.SubTable("properties").GetMap(props);
for (propIt = props.begin(); propIt != props.end(); ++propIt) {
creg::Class::Member* m = psi.projectileClass->FindMember(propIt->first.c_str());
if (m && (m->flags & creg::CM_Config)) {
ParseExplosionCode(&psi, m->offset, m->type, propIt->second, code);
}
}
code += (char)OP_END;
psi.code.resize(code.size());
copy(code.begin(), code.end(), psi.code.begin());
cegData.projectileSpawn.push_back(psi);
}
const LuaTable gndTable = expTable.SubTable("groundflash");
const int ttl = gndTable.GetInt("ttl", 0);
if (ttl > 0) {
cegData.groundFlash.circleAlpha = gndTable.GetFloat("circleAlpha", 0.0f);
cegData.groundFlash.flashSize = gndTable.GetFloat("flashSize", 0.0f);
cegData.groundFlash.flashAlpha = gndTable.GetFloat("flashAlpha", 0.0f);
cegData.groundFlash.circleGrowth = gndTable.GetFloat("circleGrowth", 0.0f);
cegData.groundFlash.color = gndTable.GetFloat3("color", float3(1.0f, 1.0f, 0.8f));
cegData.groundFlash.flags = SPW_GROUND | GetFlagsFromTable(gndTable);
cegData.groundFlash.ttl = ttl;
}
cegData.useDefaultExplosions = expTable.GetBool("useDefaultExplosions", false);
it = cachedCEGs.insert(std::make_pair(tag, cegData)).first;
}
currentCEG = it;
}
void CWeaponDefHandler::ParseTAWeapon(const LuaTable& wdTable, WeaponDef& wd)
{
bool lineofsight;
bool ballistic;
//bool twophase;
bool beamweapon;
bool manualBombSettings; //Allow the user to manually specify the burst and burstrate for his AircraftBomb
//bool guided;
//bool vlaunch;
int rendertype;
int color;
int beamlaser;
//bool tracking;
//bool selfprop;
//bool turret;
//bool smokeTrail;
//string modelName;
wd.tdfId = wdTable.GetInt("id", 0);
wd.filename = wdTable.GetString("filename", "unknown");
wd.description = wdTable.GetString("name", "Weapon");
wd.cegTag = wdTable.GetString("cegTag", "");
wd.avoidFriendly = wdTable.GetBool("avoidFriendly", true);
wd.avoidFeature = wdTable.GetBool("avoidFeature", true);
wd.collisionFlags = 0;
const bool collideFriendly = wdTable.GetBool("collideFriendly", true);
const bool collideFeature = wdTable.GetBool("collideFeature", true);
if (!collideFriendly) { wd.collisionFlags += COLLISION_NOFRIENDLY; }
if (!collideFeature) { wd.collisionFlags += COLLISION_NOFEATURE; }
wd.minIntensity = wdTable.GetFloat("minIntensity", 0.0f);
wd.dropped = wdTable.GetBool("dropped", false);
manualBombSettings = wdTable.GetBool("manualBombSettings", false);
lineofsight = wdTable.GetBool("lineOfSight", false);
ballistic = wdTable.GetBool("ballistic", false);
wd.twophase = wdTable.GetBool("twoPhase", false);
beamweapon = wdTable.GetBool("beamWeapon", false);
wd.guided = wdTable.GetBool("guidance", false);
rendertype = wdTable.GetInt("renderType", 0);
color = wdTable.GetInt("color", 0);
beamlaser = wdTable.GetInt("beamlaser", 0);
wd.vlaunch = wdTable.GetBool("vlaunch", false);
wd.selfprop = wdTable.GetBool("selfprop", false);
wd.turret = wdTable.GetBool("turret", false);
wd.noSelfDamage = wdTable.GetBool("noSelfDamage", false);
wd.visuals.modelName = wdTable.GetString("model", "");
wd.visuals.smokeTrail = wdTable.GetBool("smokeTrail", false);
wd.visuals.alwaysVisible = wdTable.GetBool("alwaysVisible", false);
wd.waterweapon = wdTable.GetBool("waterWeapon", false);
wd.fireSubmersed = wdTable.GetBool("fireSubmersed", wd.waterweapon);
wd.submissile = wdTable.GetBool("submissile", false);
wd.tracks = wdTable.GetBool("tracks", false);
wd.fixedLauncher = wdTable.GetBool("fixedLauncher", false);
wd.noExplode = wdTable.GetBool("noExplode", false);
wd.isShield = wdTable.GetBool("isShield", false);
wd.maxvelocity = wdTable.GetFloat("weaponVelocity", 0.0f);
wd.beamtime = wdTable.GetFloat("beamTime", 1.0f);
wd.beamburst = wdTable.GetBool("beamburst", false);
wd.waterBounce = wdTable.GetBool("waterbounce", false);
wd.groundBounce = wdTable.GetBool("groundbounce", false);
wd.bounceSlip = wdTable.GetFloat("bounceslip", 1);
wd.bounceRebound = wdTable.GetFloat("bouncerebound", 1);
wd.numBounce = wdTable.GetInt("numbounce", -1);
wd.thickness = wdTable.GetFloat("thickness", 2.0f);
wd.corethickness = wdTable.GetFloat("coreThickness", 0.25f);
wd.laserflaresize = wdTable.GetFloat("laserFlareSize", 15.0f);
wd.intensity = wdTable.GetFloat("intensity", 0.9f);
wd.duration = wdTable.GetFloat("duration", 0.05f);
wd.falloffRate = wdTable.GetFloat("fallOffRate", 0.5f);
wd.lodDistance = wdTable.GetInt("lodDistance", 1000);
wd.visuals.sizeDecay = wdTable.GetFloat("sizeDecay", 0.0f);
wd.visuals.alphaDecay = wdTable.GetFloat("alphaDecay", 1.0f);
wd.visuals.separation = wdTable.GetFloat("separation", 1.0f);
wd.visuals.noGap = wdTable.GetBool("noGap", true);
wd.visuals.stages = wdTable.GetInt("stages", 5);
if (wd.name.find("disintegrator") != string::npos) { //fulhack
wd.visuals.renderType = WEAPON_RENDERTYPE_FIREBALL;
} else if (wd.visuals.modelName.compare("") != 0) {
wd.visuals.renderType = WEAPON_RENDERTYPE_MODEL;
} else if (beamweapon) {
wd.visuals.renderType = WEAPON_RENDERTYPE_LASER;
} else {
wd.visuals.renderType = WEAPON_RENDERTYPE_PLASMA;
}
wd.gravityAffected = false;
if (wd.dropped || ballistic) {
wd.gravityAffected = true;
}
if (wd.dropped) {
wd.type = "AircraftBomb";
} else if (wd.vlaunch) {
wd.type = "StarburstLauncher";
} else if (beamlaser) {
wd.type = "BeamLaser";
} else if (wd.isShield) {
wd.type = "Shield";
} else if (wd.waterweapon) {
wd.type = "TorpedoLauncher";
} else if (wd.name.find("disintegrator") != string::npos) {
wd.type = "DGun";
} else if (lineofsight) {
if (rendertype==7) {
wd.type = "LightingCannon";
} else if (beamweapon) {
wd.type = "LaserCannon";
} else if (wd.visuals.modelName.find("laser") != string::npos) {
wd.type = "LaserCannon"; //swta fix
} else if (/*selfprop && */wd.visuals.smokeTrail) {
wd.type = "MissileLauncher";
} else if (rendertype == 4 && color == 2) {
wd.type = "EmgCannon";
} else if (rendertype == 5) {
wd.type = "Flame";
// } else if(rendertype == 1) {
// wd.type = "MissileLauncher";
} else {
wd.type = "Cannon";
}
} else {
wd.type = "Cannon";
}
string ttype = wdTable.GetString("weaponType", "");
if (ttype != "") {
wd.type = ttype;
}
// logOutput.Print("%s as %s",weaponname.c_str(),wd.type.c_str());
const bool melee = (wd.type == "Melee");
wd.targetBorder = wdTable.GetFloat("targetBorder", melee ? 1.0f : 0.0f);
if (wd.targetBorder > 1.0f) {
logOutput.Print("warning: targetBorder truncated to 1 (was %f)", wd.targetBorder);
wd.targetBorder = 1.0f;
} else if (wd.targetBorder < -1.0f) {
logOutput.Print("warning: targetBorder truncated to -1 (was %f)", wd.targetBorder);
wd.targetBorder = -1.0f;
}
wd.cylinderTargetting = wdTable.GetFloat("cylinderTargetting", melee ? 1.0f : 0.0f);
wd.range = wdTable.GetFloat("range", 10.0f);
const float accuracy = wdTable.GetFloat("accuracy", 0.0f);
const float sprayangle = wdTable.GetFloat("sprayAngle", 0.0f);
const float movingAccuracy = wdTable.GetFloat("movingAccuracy", accuracy);
// should really be tan but TA seem to cap it somehow
// should also be 7fff or ffff theoretically but neither seems good
wd.accuracy = sin((accuracy) * PI / 0xafff);
wd.sprayangle = sin((sprayangle) * PI / 0xafff);
wd.movingAccuracy = sin((movingAccuracy) * PI / 0xafff);
wd.targetMoveError = wdTable.GetFloat("targetMoveError", 0.0f);
wd.leadLimit = wdTable.GetFloat("leadLimit", -1.0f);
wd.leadBonus = wdTable.GetFloat("leadBonus", 0.0f);
// setup the default damages
const LuaTable dmgTable = wdTable.SubTable("damage");
float defDamage = dmgTable.GetFloat("default", 0.0f);
if (defDamage == 0.0f) {
defDamage = 1.0f; //avoid division by zeroes
}
for (int a = 0; a < damageArrayHandler->GetNumTypes(); ++a) {
wd.damages[a] = defDamage;
}
map<string, float> damages;
dmgTable.GetMap(damages);
map<string, float>::const_iterator di;
for (di = damages.begin(); di != damages.end(); ++di) {
const int type = damageArrayHandler->GetTypeFromName(di->first);
if (type != 0) {
float dmg = di->second;
if (dmg != 0.0f) {
wd.damages[type] = dmg;
} else {
wd.damages[type] = 1.0f;
}
}
}
wd.damages.impulseFactor = wdTable.GetFloat("impulseFactor", 1.0f);
wd.damages.impulseBoost = wdTable.GetFloat("impulseBoost", 0.0f);
wd.damages.craterMult = wdTable.GetFloat("craterMult", wd.damages.impulseFactor);
wd.damages.craterBoost = wdTable.GetFloat("craterBoost", 0.0f);
wd.areaOfEffect = wdTable.GetFloat("areaOfEffect", 8.0f) * 0.5f;
wd.edgeEffectiveness = wdTable.GetFloat("edgeEffectiveness", 0.0f);
// prevent 0/0 division in CGameHelper::Explosion
if (wd.edgeEffectiveness > 0.999f) {
wd.edgeEffectiveness = 0.999f;
}
wd.projectilespeed = wdTable.GetFloat("weaponVelocity", 0.0f) / GAME_SPEED;
wd.startvelocity = max(0.01f, wdTable.GetFloat("startVelocity", 0.0f) / GAME_SPEED);
wd.weaponacceleration = wdTable.GetFloat("weaponAcceleration", 0.0f) / GAME_SPEED / GAME_SPEED;
wd.reload = wdTable.GetFloat("reloadtime", 1.0f);
wd.salvodelay = wdTable.GetFloat("burstrate", 0.1f);
wd.salvosize = wdTable.GetInt("burst", 1);
wd.projectilespershot = wdTable.GetInt("projectiles", 1);
wd.maxAngle = wdTable.GetFloat("tolerance", 3000.0f) * 180.0f / 0x7fff;
wd.restTime = 0.0f;
wd.metalcost = wdTable.GetFloat("metalpershot", 0.0f);
wd.energycost = wdTable.GetFloat("energypershot", 0.0f);
wd.selfExplode = wdTable.GetBool("burnblow", false);
wd.predictBoost = wdTable.GetFloat("predictBoost", wd.selfExplode ? 0.5f : 0.0f);
wd.sweepFire = wdTable.GetBool("sweepfire", false);
wd.canAttackGround = wdTable.GetBool("canattackground", true);
wd.myGravity = wdTable.GetFloat("myGravity", 0.0f);
wd.fireStarter = wdTable.GetFloat("fireStarter", 0.0f) * 0.01f;
wd.paralyzer = wdTable.GetBool("paralyzer", false);
if (wd.paralyzer) {
wd.damages.paralyzeDamageTime = max(0, wdTable.GetInt("paralyzeTime", 10));
} else {
wd.damages.paralyzeDamageTime = 0;
}
const float defShake = wd.paralyzer ? 0.0f : wd.damages.GetDefaultDamage();
wd.cameraShake = wdTable.GetFloat("cameraShake", defShake);
wd.cameraShake = max(0.0f, wd.cameraShake);
wd.soundTrigger = wdTable.GetBool("soundTrigger", false);
//sunparser->GetDef(wd.highTrajectory, "0", weaponname + "minbarrelangle");
wd.stockpile = wdTable.GetBool("stockpile", false);
wd.interceptor = wdTable.GetInt("interceptor", 0);
wd.targetable = wdTable.GetInt("targetable", 0);
wd.manualfire = wdTable.GetBool("commandfire", false);
wd.coverageRange = wdTable.GetFloat("coverage", 0.0f);
// FIXME -- remove the old style ?
LuaTable shTable = wdTable.SubTable("shield");
const float3 shieldBadColor (1.0f, 0.5f, 0.5f);
const float3 shieldGoodColor(0.5f, 0.5f, 1.0f);
if (shTable.IsValid()) {
wd.shieldRepulser = shTable.GetBool("repulser", false);
wd.smartShield = shTable.GetBool("smart", false);
wd.exteriorShield = shTable.GetBool("exterior", false);
wd.visibleShield = shTable.GetBool("visible", false);
wd.visibleShieldRepulse = shTable.GetBool("visibleRepulse", false);
wd.visibleShieldHitFrames = shTable.GetInt("visibleHitFrames", 0);
wd.shieldEnergyUse = shTable.GetFloat("energyUse", 0.0f);
wd.shieldForce = shTable.GetFloat("force", 0.0f);
wd.shieldRadius = shTable.GetFloat("radius", 0.0f);
wd.shieldMaxSpeed = shTable.GetFloat("maxSpeed", 0.0f);
wd.shieldPower = shTable.GetFloat("power", 0.0f);
wd.shieldPowerRegen = shTable.GetFloat("powerRegen", 0.0f);
wd.shieldPowerRegenEnergy = shTable.GetFloat("powerRegenEnergy", 0.0f);
wd.shieldStartingPower = shTable.GetFloat("startingPower", 0.0f);
wd.shieldInterceptType = shTable.GetInt("interceptType", 0);
wd.shieldBadColor = shTable.GetFloat3("badColor", shieldBadColor);
wd.shieldGoodColor = shTable.GetFloat3("goodColor", shieldGoodColor);
wd.shieldAlpha = shTable.GetFloat("alpha", 0.2f);
}
else {
wd.shieldRepulser = wdTable.GetBool("shieldRepulser", false);
wd.smartShield = wdTable.GetBool("smartShield", false);
wd.exteriorShield = wdTable.GetBool("exteriorShield", false);
wd.visibleShield = wdTable.GetBool("visibleShield", false);
wd.visibleShieldRepulse = wdTable.GetBool("visibleShieldRepulse", false);
wd.visibleShieldHitFrames = wdTable.GetInt("visibleShieldHitFrames", 0);
wd.shieldEnergyUse = wdTable.GetFloat("shieldEnergyUse", 0.0f);
wd.shieldForce = wdTable.GetFloat("shieldForce", 0.0f);
wd.shieldRadius = wdTable.GetFloat("shieldRadius", 0.0f);
wd.shieldMaxSpeed = wdTable.GetFloat("shieldMaxSpeed", 0.0f);
wd.shieldPower = wdTable.GetFloat("shieldPower", 0.0f);
wd.shieldPowerRegen = wdTable.GetFloat("shieldPowerRegen", 0.0f);
wd.shieldPowerRegenEnergy = wdTable.GetFloat("shieldPowerRegenEnergy", 0.0f);
wd.shieldStartingPower = wdTable.GetFloat("shieldStartingPower", 0.0f);
wd.shieldInterceptType = wdTable.GetInt("shieldInterceptType", 0);
wd.shieldBadColor = wdTable.GetFloat3("shieldBadColor", shieldBadColor);
wd.shieldGoodColor = wdTable.GetFloat3("shieldGoodColor", shieldGoodColor);
wd.shieldAlpha = wdTable.GetFloat("shieldAlpha", 0.2f);
}
int defInterceptType = 0;
if (wd.type == "Cannon") {
defInterceptType = 1;
} else if ((wd.type == "LaserCannon") || (wd.type == "BeamLaser")) {
defInterceptType = 2;
} else if ((wd.type == "StarburstLauncher") || (wd.type == "MissileLauncher")) {
defInterceptType = 4;
}
wd.interceptedByShieldType = wdTable.GetInt("interceptedByShieldType", defInterceptType);
wd.wobble = wdTable.GetFloat("wobble", 0.0f) * PI / 0x7fff / 30.0f;
wd.dance = wdTable.GetFloat("dance", 0.0f) / GAME_SPEED;
wd.trajectoryHeight = wdTable.GetFloat("trajectoryHeight", 0.0f);
wd.noAutoTarget = (wd.manualfire || wd.interceptor || wd.isShield);
wd.onlyTargetCategory = 0xffffffff;
if (wdTable.GetBool("toAirWeapon", false)) {
// fix if we sometime call aircrafts otherwise
wd.onlyTargetCategory = CCategoryHandler::Instance()->GetCategories("VTOL");
//logOutput.Print("air only weapon %s %i",weaponname.c_str(),wd.onlyTargetCategory);
}
wd.largeBeamLaser = wdTable.GetBool("largeBeamLaser", false);
wd.visuals.tilelength = wdTable.GetFloat("tileLength", 200.0f);
wd.visuals.scrollspeed = wdTable.GetFloat("scrollSpeed", 5.0f);
wd.visuals.pulseSpeed = wdTable.GetFloat("pulseSpeed", 1.0f);
wd.visuals.beamdecay = wdTable.GetFloat("beamDecay", 1.0f);
wd.visuals.beamttl = wdTable.GetInt("beamTTL", 0);
if (wd.type == "Cannon") {
wd.heightmod = wdTable.GetFloat("heightMod", 0.8f);
} else if (wd.type == "BeamLaser") {
wd.heightmod = wdTable.GetFloat("heightMod", 1.0f);
} else {
wd.heightmod = wdTable.GetFloat("heightMod", 0.2f);
}
wd.supplycost = 0.0f;
wd.onlyForward = !wd.turret && (wd.type != "StarburstLauncher");
const int color2 = wdTable.GetInt("color2", 0);
const float3 rgbcol = hs2rgb(color / float(255), color2 / float(255));
wd.visuals.color = wdTable.GetFloat3("rgbColor", rgbcol);
wd.visuals.color2 = wdTable.GetFloat3("rgbColor2", float3(1.0f, 1.0f, 1.0f));
wd.uptime = wdTable.GetFloat("weaponTimer", 0.0f);
wd.flighttime = wdTable.GetInt("flightTime", 0) * 32;
wd.turnrate = wdTable.GetFloat("turnRate", 0.0f) * PI / 0x7fff / 30.0f;
if ((wd.type == "AircraftBomb") && !manualBombSettings) {
if (wd.reload < 0.5f) {
wd.salvodelay = min(0.2f, wd.reload);
wd.salvosize = (int)(1 / wd.salvodelay) + 1;
wd.reload = 5;
} else {
wd.salvodelay = min(0.4f, wd.reload);
wd.salvosize = 2;
}
}
//if(!wd.turret && (wd.type != "TorpedoLauncher")) {
// wd.maxAngle*=0.4f;
//}
//2+min(damages[0]*0.0025f,weaponDef->areaOfEffect*0.1f)
const float tempsize = 2.0f + min(wd.damages[0] * 0.0025f, wd.areaOfEffect * 0.1f);
wd.size = wdTable.GetFloat("size", tempsize);
wd.sizeGrowth = wdTable.GetFloat("sizeGrowth", 0.2f);
wd.collisionSize = wdTable.GetFloat("collisionSize", 0.05f);
wd.visuals.colorMap = 0;
const string colormap = wdTable.GetString("colormap", "");
if (colormap != "") {
wd.visuals.colorMap = CColorMap::LoadFromDefString(colormap);
}
wd.heightBoostFactor = wdTable.GetFloat("heightBoostFactor", -1.0f);
wd.proximityPriority = wdTable.GetFloat("proximityPriority", 1.0f);
// get some weapon specific defaults
if (wd.type == "Cannon") {
// CExplosiveProjectile
wd.visuals.texture1 = &ph->plasmatex;
wd.visuals.color = wdTable.GetFloat3("rgbColor", float3(1.0f,0.5f,0.0f));
wd.intensity = wdTable.GetFloat("intensity", 0.2f);
} else if (wd.type == "Rifle") {
// ...
} else if (wd.type == "Melee") {
// ...
} else if (wd.type == "AircraftBomb") {
// CExplosiveProjectile or CTorpedoProjectile
wd.visuals.texture1 = &ph->plasmatex;
} else if (wd.type == "Shield") {
wd.visuals.texture1 = &ph->perlintex;
} else if (wd.type == "Flame") {
// CFlameProjectile
wd.visuals.texture1 = &ph->flametex;
wd.size = wdTable.GetFloat("size", tempsize);
wd.sizeGrowth = wdTable.GetFloat("sizeGrowth", 0.5f);
wd.collisionSize = wdTable.GetFloat("collisionSize", 0.5f);
wd.duration = wdTable.GetFloat("flameGfxTime", 1.2f);
if (wd.visuals.colorMap == 0) {
wd.visuals.colorMap = CColorMap::Load12f(1.000f, 1.000f, 1.000f, 0.100f,
0.025f, 0.025f, 0.025f, 0.100f,
0.000f, 0.000f, 0.000f, 0.000f);
}
} else if (wd.type == "MissileLauncher") {
// CMissileProjectile
wd.visuals.texture1 = &ph->missileflaretex;
wd.visuals.texture2 = &ph->missiletrailtex;
} else if (wd.type == "TorpedoLauncher") {
// CExplosiveProjectile or CTorpedoProjectile
wd.visuals.texture1 = &ph->plasmatex;
} else if (wd.type == "LaserCannon") {
// CLaserProjectile
wd.visuals.texture1 = &ph->laserfallofftex;
wd.visuals.texture2 = &ph->laserendtex;
wd.visuals.hardStop = wdTable.GetBool("hardstop", false);
wd.collisionSize = wdTable.GetFloat("collisionSize", 0.5f);
} else if (wd.type == "BeamLaser") {
if (wd.largeBeamLaser) {
wd.visuals.texture1 = ph->textureAtlas->GetTexturePtr("largebeam");
wd.visuals.texture2 = &ph->laserendtex;
wd.visuals.texture3 = ph->textureAtlas->GetTexturePtr("muzzleside");
wd.visuals.texture4 = &ph->beamlaserflaretex;
} else {
wd.visuals.texture1 = &ph->laserfallofftex;
wd.visuals.texture2 = &ph->laserendtex;
wd.visuals.texture3 = &ph->beamlaserflaretex;
}
} else if (wd.type == "LightingCannon") {
wd.visuals.texture1 = &ph->laserfallofftex;
wd.thickness = wdTable.GetFloat("thickness", 0.8f);
} else if (wd.type == "EmgCannon") {
// CEmgProjectile
wd.visuals.texture1 = &ph->plasmatex;
wd.visuals.color = wdTable.GetFloat3("rgbColor", float3(0.9f,0.9f,0.2f));
wd.size = wdTable.GetFloat("size", 3.0f);
} else if (wd.type == "DGun") {
// CFireBallProjectile
wd.collisionSize = wdTable.GetFloat("collisionSize", 10.0f);
} else if (wd.type == "StarburstLauncher") {
// CStarburstProjectile
wd.visuals.texture1 = &ph->sbflaretex;
wd.visuals.texture2 = &ph->sbtrailtex;
wd.visuals.texture3 = &ph->explotex;
} else {
wd.visuals.texture1 = &ph->plasmatex;
wd.visuals.texture2 = &ph->plasmatex;
}
// FIXME -- remove the 'textureN' format?
LuaTable texTable = wdTable.SubTable("textures");
string texName;
texName = wdTable.GetString("texture1", "");
texName = texTable.GetString(1, texName);
if (texName != "") {
wd.visuals.texture1 = ph->textureAtlas->GetTexturePtr(texName);
}
texName = wdTable.GetString("texture2", "");
texName = texTable.GetString(2, texName);
if (texName != "") {
wd.visuals.texture2 = ph->textureAtlas->GetTexturePtr(texName);
}
texName = wdTable.GetString("texture3", "");
texName = texTable.GetString(3, texName);
if (texName != "") {
wd.visuals.texture3 = ph->textureAtlas->GetTexturePtr(texName);
}
texName = wdTable.GetString("texture4", "");
texName = texTable.GetString(4, texName);
if (texName != "") {
wd.visuals.texture4 = ph->textureAtlas->GetTexturePtr(texName);
}
const string expGenTag = wdTable.GetString("explosionGenerator", "");
if (expGenTag.empty()) {
wd.explosionGenerator = NULL;
} else {
wd.explosionGenerator = explGenHandler->LoadGenerator(expGenTag);
}
const string bounceExpGenTag = wdTable.GetString("bounceExplosionGenerator", "");
if (bounceExpGenTag.empty()) {
wd.bounceExplosionGenerator = NULL;
} else {
wd.bounceExplosionGenerator = explGenHandler->LoadGenerator(bounceExpGenTag);
}
const float gd = max(30.0f, wd.damages[0] / 20.0f);
const float defExpSpeed = (8.0f + (gd * 2.5f)) / (9.0f + (sqrtf(gd) * 0.7f)) * 0.5f;
wd.explosionSpeed = wdTable.GetFloat("explosionSpeed", defExpSpeed);
// Dynamic Damage
wd.dynDamageInverted = wdTable.GetBool("dynDamageInverted", false);
wd.dynDamageExp = wdTable.GetFloat("dynDamageExp", 0.0f);
wd.dynDamageMin = wdTable.GetFloat("dynDamageMin", 0.0f);
wd.dynDamageRange = wdTable.GetFloat("dynDamageRange", 0.0f);
LoadSound(wdTable, wd.firesound, "firesound");
LoadSound(wdTable, wd.soundhit, "soundhit");
if ((wd.firesound.getVolume(0) == -1.0f) ||
(wd.soundhit.getVolume(0) == -1.0f)) {
// no volume (-1.0f) read from weapon definition, set it dynamically here
if (wd.damages[0] <= 50.0f) {
wd.soundhit.setVolume(0, 5.0f);
wd.firesound.setVolume(0, 5.0f);
}
else {
float soundVolume = sqrt(wd.damages[0] * 0.5f);
if (wd.type == "LaserCannon") {
soundVolume *= 0.5f;
}
float hitSoundVolume = soundVolume;
if ((soundVolume > 100.0f) &&
((wd.type == "MissileLauncher") ||
(wd.type == "StarburstLauncher"))) {
soundVolume = 10.0f * sqrt(soundVolume);
}
if (wd.firesound.getVolume(0) == -1.0f) {
wd.firesound.setVolume(0, soundVolume);
}
soundVolume = hitSoundVolume;
if (wd.areaOfEffect > 8.0f) {
soundVolume *= 2.0f;
}
if (wd.type == "DGun") {
soundVolume *= 0.15f;
}
if (wd.soundhit.getVolume(0) == -1.0f) {
wd.soundhit.setVolume(0, soundVolume);
}
}
}
}
/*
* CArchiveScanner::ArchiveData
*/
CArchiveScanner::ArchiveData::ArchiveData(const LuaTable& archiveTable)
{
if (!archiveTable.IsValid()) {
return;
}
std::vector<std::string> keys;
if (!archiveTable.GetKeys(keys)) {
return;
}
std::vector<std::string>::const_iterator key;
for (key = keys.begin(); key != keys.end(); ++key) {
const std::string& keyLower = StringToLower(*key);
if (!ArchiveData::IsReservedKey(keyLower)) {
if (keyLower == "modtype") {
SetInfoItemValueInteger(*key, archiveTable.GetInt(*key, 0));
continue;
}
const int luaType = archiveTable.GetType(*key);
switch (luaType) {
case LuaTable::STRING: {
SetInfoItemValueString(*key, archiveTable.GetString(*key, ""));
} break;
case LuaTable::NUMBER: {
SetInfoItemValueFloat(*key, archiveTable.GetFloat(*key, 0.0f));
} break;
case LuaTable::BOOLEAN: {
SetInfoItemValueBool(*key, archiveTable.GetBool(*key, false));
} break;
default: {
// just ignore unsupported types (most likely to be lua-tables)
//throw content_error("Lua-type " + IntToString(luaType) + " not supported in archive-info, but it is used on key \"" + *key + "\"");
} break;
}
}
}
const LuaTable _dependencies = archiveTable.SubTable("depend");
for (int dep = 1; _dependencies.KeyExists(dep); ++dep) {
dependencies.push_back(_dependencies.GetString(dep, ""));
}
const LuaTable _replaces = archiveTable.SubTable("replace");
for (int rep = 1; _replaces.KeyExists(rep); ++rep) {
replaces.push_back(_replaces.GetString(rep, ""));
}
//! FIXME
//! XXX HACK needed until lobbies, lobbyserver and unitsync are sorted out
//! so they can uniquely identify different versions of the same mod.
//! (at time of this writing they use name only)
//! NOTE when changing this, this function is used both by the code that
//! reads ArchiveCache.lua and the code that reads modinfo.lua from the mod.
//! so make sure it doesn't keep adding stuff to the name everytime
//! Spring/unitsync is loaded.
const std::string& name = GetName();
const std::string& version = GetVersion();
if ((name.find(version) == std::string::npos) && !version.empty()) {
SetInfoItemValueString("name", name + " " + version);
}
}
void CAssParser::LoadPieceTransformations(
SAssPiece* piece,
const S3DModel* model,
const aiNode* pieceNode,
const LuaTable& pieceTable
) {
aiVector3D aiScaleVec, aiTransVec;
aiQuaternion aiRotateQuat;
// process transforms
pieceNode->mTransformation.Decompose(aiScaleVec, aiRotateQuat, aiTransVec);
// metadata-scaling
piece->scales = pieceTable.GetFloat3("scale", aiVectorToFloat3(aiScaleVec));
piece->scales.x = pieceTable.GetFloat("scalex", piece->scales.x);
piece->scales.y = pieceTable.GetFloat("scaley", piece->scales.y);
piece->scales.z = pieceTable.GetFloat("scalez", piece->scales.z);
if (piece->scales.x != piece->scales.y || piece->scales.y != piece->scales.z) {
// LOG_SL(LOG_SECTION_MODEL, L_WARNING, "Spring doesn't support non-uniform scaling");
piece->scales.y = piece->scales.x;
piece->scales.z = piece->scales.x;
}
// metadata-translation
piece->offset = pieceTable.GetFloat3("offset", aiVectorToFloat3(aiTransVec));
piece->offset.x = pieceTable.GetFloat("offsetx", piece->offset.x);
piece->offset.y = pieceTable.GetFloat("offsety", piece->offset.y);
piece->offset.z = pieceTable.GetFloat("offsetz", piece->offset.z);
// metadata-rotation
// NOTE:
// these rotations are "pre-scripting" but "post-modelling"
// together with the (baked) aiRotateQuad they determine the
// model's pose *before* any animations execute
//
// float3 rotAngles = pieceTable.GetFloat3("rotate", aiQuaternionToRadianAngles(aiRotateQuat) * RADTODEG);
float3 pieceRotAngles = pieceTable.GetFloat3("rotate", ZeroVector);
pieceRotAngles.x = pieceTable.GetFloat("rotatex", pieceRotAngles.x);
pieceRotAngles.y = pieceTable.GetFloat("rotatey", pieceRotAngles.y);
pieceRotAngles.z = pieceTable.GetFloat("rotatez", pieceRotAngles.z);
pieceRotAngles *= DEGTORAD;
LOG_SL(LOG_SECTION_PIECE, L_INFO,
"(%d:%s) Assimp offset (%f,%f,%f), rotate (%f,%f,%f,%f), scale (%f,%f,%f)",
model->numPieces, piece->name.c_str(),
aiTransVec.x, aiTransVec.y, aiTransVec.z,
aiRotateQuat.w, aiRotateQuat.x, aiRotateQuat.y, aiRotateQuat.z,
aiScaleVec.x, aiScaleVec.y, aiScaleVec.z
);
LOG_SL(LOG_SECTION_PIECE, L_INFO,
"(%d:%s) Relative offset (%f,%f,%f), rotate (%f,%f,%f), scale (%f,%f,%f)",
model->numPieces, piece->name.c_str(),
piece->offset.x, piece->offset.y, piece->offset.z,
pieceRotAngles.x, pieceRotAngles.y, pieceRotAngles.z,
piece->scales.x, piece->scales.y, piece->scales.z
);
// NOTE:
// at least collada (.dae) files generated by Blender represent
// a coordinate-system that differs from the "standard" formats
// (3DO, S3O, ...) for which existing tools at least have prior
// knowledge of Spring's expectations --> let the user override
// the ROOT rotational transform and the rotation-axis mapping
// used by animation scripts (but re-modelling/re-exporting is
// always preferred!) even though AssImp should convert models
// to its own system which matches that of Spring
//
// .dae : x=Rgt, y=-Fwd, z= Up, as=(-1, -1, 1), am=AXIS_XZY (if Z_UP)
// .dae : x=Rgt, y=-Fwd, z= Up, as=(-1, -1, 1), am=AXIS_XZY (if Y_UP) [!?]
// .blend: ????
piece->bakedRotMatrix = aiMatrixToMatrix(aiMatrix4x4t<float>(aiRotateQuat.GetMatrix()));
if (piece == model->GetRootPiece()) {
const float3 xaxis = pieceTable.GetFloat3("xaxis", piece->bakedRotMatrix.GetX());
const float3 yaxis = pieceTable.GetFloat3("yaxis", piece->bakedRotMatrix.GetY());
const float3 zaxis = pieceTable.GetFloat3("zaxis", piece->bakedRotMatrix.GetZ());
if (math::fabs(xaxis.SqLength() - yaxis.SqLength()) < 0.01f && math::fabs(yaxis.SqLength() - zaxis.SqLength()) < 0.01f) {
piece->bakedRotMatrix = CMatrix44f(ZeroVector, xaxis, yaxis, zaxis);
}
}
piece->rotAxisSigns = pieceTable.GetFloat3("rotAxisSigns", float3(-OnesVector));
piece->axisMapType = AxisMappingType(pieceTable.GetInt("rotAxisMap", AXIS_MAPPING_XYZ));
// construct 'baked' part of the piece-space matrix
// AssImp order is translate * rotate * scale * v;
// we leave the translation and scale parts out and
// put those in <offset> and <scales> --> transform
// is just R instead of T * R * S
//
// note: for all non-AssImp models this is identity!
//
piece->ComposeRotation(piece->bakedRotMatrix, pieceRotAngles);
piece->SetHasIdentityRotation(piece->bakedRotMatrix.IsIdentity() == 0);
assert(piece->bakedRotMatrix.IsOrthoNormal() == 0);
}
void CModInfo::Init(const char* modname)
{
filename = modname;
humanName = archiveScanner->ModArchiveToModName(modname);
const CArchiveScanner::ModData md = archiveScanner->ModArchiveToModData(modname);
shortName = md.shortName;
version = md.version;
mutator = md.mutator;
description = md.description;
// initialize the parser
LuaParser parser("gamedata/modrules.lua",
SPRING_VFS_MOD_BASE, SPRING_VFS_ZIP);
// customize the defs environment
parser.GetTable("Spring");
parser.AddFunc("GetModOptions", LuaSyncedRead::GetModOptions);
parser.EndTable();
parser.Execute();
if (!parser.IsValid()) {
logOutput.Print("Error loading modrules, using defaults");
logOutput.Print(parser.GetErrorLog());
}
const LuaTable root = parser.GetRoot();
// determine if bombers are allowed to leave map boundaries
const LuaTable movementTbl = root.SubTable("movement");
allowAirPlanesToLeaveMap = movementTbl.GetBool("allowAirPlanesToLeaveMap", true);
// determine whether the modder allows the user to use team coloured nanospray
const LuaTable nanosprayTbl = root.SubTable("nanospray");
allowTeamColors = nanosprayTbl.GetBool("allow_team_colors", true);
if (allowTeamColors) {
// Load the users preference for team coloured nanospray
gu->teamNanospray = !!configHandler->Get("TeamNanoSpray", 1);
}
// constructions
const LuaTable constructionTbl = root.SubTable("construction");
constructionDecay = constructionTbl.GetBool("constructionDecay", true);
constructionDecayTime = (int)(constructionTbl.GetFloat("constructionDecayTime", 6.66) * 30);
constructionDecaySpeed = constructionTbl.GetFloat("constructionDecaySpeed", 0.03);
// reclaim
const LuaTable reclaimTbl = root.SubTable("reclaim");
multiReclaim = reclaimTbl.GetInt("multiReclaim", 0);
reclaimMethod = reclaimTbl.GetInt("reclaimMethod", 1);
reclaimUnitMethod = reclaimTbl.GetInt("unitMethod", 1);
reclaimUnitEnergyCostFactor = reclaimTbl.GetFloat("unitEnergyCostFactor", 0.0);
reclaimUnitEfficiency = reclaimTbl.GetFloat("unitEfficiency", 1.0);
reclaimFeatureEnergyCostFactor = reclaimTbl.GetFloat("featureEnergyCostFactor", 0.0);
reclaimAllowEnemies = reclaimTbl.GetBool("allowEnemies", true);
reclaimAllowAllies = reclaimTbl.GetBool("allowAllies", true);
// repair
const LuaTable repairTbl = root.SubTable("repair");
repairEnergyCostFactor = repairTbl.GetFloat("energyCostFactor", 0.0);
// resurrect
const LuaTable resurrectTbl = root.SubTable("resurrect");
resurrectEnergyCostFactor = resurrectTbl.GetFloat("energyCostFactor", 0.5);
// capture
const LuaTable captureTbl = root.SubTable("capture");
captureEnergyCostFactor = captureTbl.GetFloat("energyCostFactor", 0.0);
// fire-at-dead-units
const LuaTable fireAtDeadTbl = root.SubTable("fireAtDead");
fireAtKilled = fireAtDeadTbl.GetBool("fireAtKilled", false);
fireAtCrashing = fireAtDeadTbl.GetBool("fireAtCrashing", false);
// transportability
const LuaTable transportTbl = root.SubTable("transportability");
transportAir = transportTbl.GetInt("transportAir", false);
transportShip = transportTbl.GetInt("transportShip", false);
transportHover = transportTbl.GetInt("transportHover", false);
transportGround = transportTbl.GetInt("transportGround", true);
// experience
const LuaTable experienceTbl = root.SubTable("experience");
CUnit::SetExpMultiplier (experienceTbl.GetFloat("experienceMult", 1.0f));
CUnit::SetExpPowerScale (experienceTbl.GetFloat("powerScale", 1.0f));
CUnit::SetExpHealthScale(experienceTbl.GetFloat("healthScale", 0.7f));
CUnit::SetExpReloadScale(experienceTbl.GetFloat("reloadScale", 0.4f));
// flanking bonus
const LuaTable flankingBonusTbl = root.SubTable("flankingBonus");
flankingBonusModeDefault = flankingBonusTbl.GetInt("defaultMode", 1);
// feature visibility
const LuaTable featureLOS = root.SubTable("featureLOS");
featureVisibility = featureLOS.GetInt("featureVisibility", 3);
if (featureVisibility < 0 || featureVisibility > 3)
throw content_error("invalid modinfo: featureVisibility, valid range is 0..3");
// sensors
const LuaTable sensors = root.SubTable("sensors");
requireSonarUnderWater = sensors.GetBool("requireSonarUnderWater", true);
/// LoS
const LuaTable los = sensors.SubTable("los");
// losMipLevel is used as index to readmap->mipHeightmap,
// so the max value is CReadMap::numHeightMipMaps - 1
losMipLevel = los.GetInt("losMipLevel", 1);
losMul = los.GetFloat("losMul", 1.0f);
if ((losMipLevel < 0) || (losMipLevel > 6)) {
throw content_error("Sensors\\Los\\LosMipLevel out of bounds. "
"The minimum value is 0. The maximum value is 6.");
}
// airLosMipLevel doesn't have such restrictions, it's just used in various
// bitshifts with signed integers
airMipLevel = los.GetInt("airMipLevel", 2);
if ((airMipLevel < 0) || (airMipLevel > 30)) {
throw content_error("Sensors\\Los\\AirLosMipLevel out of bounds. "
"The minimum value is 0. The maximum value is 30.");
}
airLosMul = los.GetFloat("airLosMul", 1.0f);
}
MoveDef::MoveDef(const LuaTable& moveDefTable, int moveDefID) {
*this = MoveDef();
name = StringToLower(moveDefTable.GetString("name", ""));
pathType = moveDefID - 1;
crushStrength = moveDefTable.GetFloat("crushStrength", 10.0f);
const LuaTable& depthModTable = moveDefTable.SubTable("depthModParams");
const LuaTable& speedModMultsTable = moveDefTable.SubTable("speedModMults");
const float minWaterDepth = moveDefTable.GetFloat("minWaterDepth", GetDefaultMinWaterDepth());
const float maxWaterDepth = moveDefTable.GetFloat("maxWaterDepth", GetDefaultMaxWaterDepth());
switch ((speedModClass = ParseSpeedModClass(name, moveDefTable))) {
case MoveDef::Tank: {
// fall-through
}
case MoveDef::KBot: {
depthModParams[DEPTHMOD_MIN_HEIGHT] = std::max(0.00f, depthModTable.GetFloat("minHeight", 0.0f ));
depthModParams[DEPTHMOD_MAX_HEIGHT] = ( depthModTable.GetFloat("maxHeight", std::numeric_limits<float>::max() ));
depthModParams[DEPTHMOD_MAX_SCALE ] = std::max(0.01f, depthModTable.GetFloat("maxScale", std::numeric_limits<float>::max() ));
depthModParams[DEPTHMOD_QUA_COEFF ] = std::max(0.00f, depthModTable.GetFloat("quadraticCoeff", 0.0f ));
depthModParams[DEPTHMOD_LIN_COEFF ] = std::max(0.00f, depthModTable.GetFloat("linearCoeff", moveDefTable.GetFloat("depthMod", 0.1f)));
depthModParams[DEPTHMOD_CON_COEFF ] = std::max(0.00f, depthModTable.GetFloat("constantCoeff", 1.0f ));
// ensure [depthModMinHeight, depthModMaxHeight] is a valid range
depthModParams[DEPTHMOD_MAX_HEIGHT] = std::max(depthModParams[DEPTHMOD_MIN_HEIGHT], depthModParams[DEPTHMOD_MAX_HEIGHT]);
depth = maxWaterDepth;
maxSlope = DegreesToMaxSlope(moveDefTable.GetFloat("maxSlope", 60.0f));
} break;
case MoveDef::Hover: {
depth = maxWaterDepth;
maxSlope = DegreesToMaxSlope(moveDefTable.GetFloat("maxSlope", 15.0f));
} break;
case MoveDef::Ship: {
depth = minWaterDepth;
subMarine = moveDefTable.GetBool("subMarine", false);
} break;
}
speedModMults[SPEEDMOD_MOBILE_BUSY_MULT] = std::max(0.01f, speedModMultsTable.GetFloat("mobileBusyMult", 1.0f /*0.10f*/));
speedModMults[SPEEDMOD_MOBILE_IDLE_MULT] = std::max(0.01f, speedModMultsTable.GetFloat("mobileIdleMult", 1.0f /*0.35f*/));
speedModMults[SPEEDMOD_MOBILE_MOVE_MULT] = std::max(0.01f, speedModMultsTable.GetFloat("mobileMoveMult", 1.0f /*0.65f*/));
avoidMobilesOnPath = moveDefTable.GetBool("avoidMobilesOnPath", true);
allowTerrainCollisions = moveDefTable.GetBool("allowTerrainCollisions", true);
heatMapping = moveDefTable.GetBool("heatMapping", false);
flowMapping = moveDefTable.GetBool("flowMapping", true);
heatMod = moveDefTable.GetFloat("heatMod", (1.0f / (GAME_SPEED * 2)) * 0.25f);
flowMod = moveDefTable.GetFloat("flowMod", 1.0f);
// by default heat decays to zero after N=2 seconds
//
// the cost contribution to a square from heat must
// be on the same order as its normal movement cost
// PER FRAME, i.e. such that heatMod * heatProduced
// ~= O(1 / (GAME_SPEED * N)) because unit behavior
// in groups quickly becomes FUBAR if heatMod >>> 1
//
heatProduced = moveDefTable.GetInt("heatProduced", GAME_SPEED * 2);
// <maxSlope> ranges from 0.0 to 60 * 1.5 degrees, ie. from 0.0 to
// 0.5 * PI radians, ie. from 1.0 - cos(0.0) to 1.0 - cos(0.5 * PI)
// = [0, 1] --> DEFAULT <slopeMod> values range from (4 / 0.001) to
// (4 / 1.001) = [4000.0, 3.996]
//
// speedMod values for a terrain-square slope in [0, 1] are given by
// (1.0 / (1.0 + slope * slopeMod)) and therefore have a MAXIMUM at
// <slope=0, slopeMod=...> and a MINIMUM at <slope=1, slopeMod=4000>
// (of 1.0 / (1.0 + 0.0 * ...) = 1.0 and 1.0 / (1.0 + 1.0 * 4000.0)
// = 0.00025 respectively)
//
slopeMod = moveDefTable.GetFloat("slopeMod", 4.0f / (maxSlope + 0.001f));
// ground units hug the ocean floor when in water,
// ships stay at a "fixed" level (their waterline)
followGround = (speedModClass == MoveDef::Tank || speedModClass == MoveDef::KBot);
// TODO:
// remove terrainClass, not used anywhere
// and only AI's MIGHT have benefit from it
//
// tank or bot that cannot get its threads / feet
// wet, or hovercraft (which doesn't touch ground
// or water)
if ((followGround && maxWaterDepth <= 0.0f) || speedModClass == MoveDef::Hover)
terrainClass = MoveDef::Land;
// ship (or sub) that cannot crawl onto shore, OR tank
// or bot restricted to snorkling (strange but possible)
if ((speedModClass == MoveDef::Ship && minWaterDepth > 0.0f) || (followGround && minWaterDepth > 0.0f))
terrainClass = MoveDef::Water;
// tank or kbot that CAN go skinny-dipping (amph.),
// or ship that CAN sprout legs when at the beach
if ((followGround && maxWaterDepth > 0.0f) || (speedModClass == MoveDef::Ship && minWaterDepth < 0.0f))
terrainClass = MoveDef::Mixed;
const int xsizeDef = std::max(1, moveDefTable.GetInt("footprintX", 1));
const int zsizeDef = std::max(1, moveDefTable.GetInt("footprintZ", xsizeDef));
// make all mobile footprints point-symmetric in heightmap space
// (meaning that only non-even dimensions are possible and each
// footprint always has a unique center square)
xsize = xsizeDef * SPRING_FOOTPRINT_SCALE;
zsize = zsizeDef * SPRING_FOOTPRINT_SCALE;
xsize -= ((xsize & 1)? 0: 1);
zsize -= ((zsize & 1)? 0: 1);
// precalculated data for MoveMath
xsizeh = xsize >> 1;
zsizeh = zsize >> 1;
assert((xsize & 1) == 1);
assert((zsize & 1) == 1);
}
void CUnitDefHandler::ParseUnitDefTable(const LuaTable& udTable, const string& unitName, int id)
{
UnitDef& ud = unitDefs[id];
// allocate and fill ud->unitImage
ud.buildPicName = udTable.GetString("buildPic", "");
ud.humanName = udTable.GetString("name", "");
if (ud.humanName.empty()) {
const string errmsg = "missing 'name' parameter for the " + unitName + " unitdef";
throw content_error(errmsg);
}
ud.filename = udTable.GetString("filename", "");
if (ud.filename.empty()) {
const string errmsg = "missing 'filename' parameter for the" + unitName + " unitdef";
throw content_error(errmsg);
}
ud.tooltip = udTable.GetString("description", ud.name);
const string decoy = udTable.GetString("decoyFor", "");
if (!decoy.empty()) {
decoyNameMap[ud.name] = StringToLower(decoy);
}
ud.gaia = udTable.GetString("gaia", "");
ud.isCommander = udTable.GetBool("commander", false);
if (ud.isCommander && gameSetup) {
ud.metalStorage = udTable.GetFloat("metalStorage", gameSetup->startMetal);
ud.energyStorage = udTable.GetFloat("energyStorage", gameSetup->startEnergy);
} else {
ud.metalStorage = udTable.GetFloat("metalStorage", 0.0f);
ud.energyStorage = udTable.GetFloat("energyStorage", 0.0f);
}
ud.extractsMetal = udTable.GetFloat("extractsMetal", 0.0f);
ud.windGenerator = udTable.GetFloat("windGenerator", 0.0f);
ud.tidalGenerator = udTable.GetFloat("tidalGenerator", 0.0f);
ud.metalUpkeep = udTable.GetFloat("metalUse", 0.0f);
ud.energyUpkeep = udTable.GetFloat("energyUse", 0.0f);
ud.metalMake = udTable.GetFloat("metalMake", 0.0f);
ud.makesMetal = udTable.GetFloat("makesMetal", 0.0f);
ud.energyMake = udTable.GetFloat("energyMake", 0.0f);
ud.health = udTable.GetFloat("maxDamage", 0.0f);
ud.autoHeal = udTable.GetFloat("autoHeal", 0.0f) * (16.0f / GAME_SPEED);
ud.idleAutoHeal = udTable.GetFloat("idleAutoHeal", 10.0f) * (16.0f / GAME_SPEED);
ud.idleTime = udTable.GetInt("idleTime", 600);
ud.buildangle = udTable.GetInt("buildAngle", 0);
ud.isMetalMaker = (ud.makesMetal >= 1 && ud.energyUpkeep > ud.makesMetal * 40);
ud.controlRadius = 32;
ud.losHeight = 20;
ud.metalCost = udTable.GetFloat("buildCostMetal", 0.0f);
if (ud.metalCost < 1.0f) {
ud.metalCost = 1.0f; //avoid some nasty divide by 0 etc
}
ud.mass = udTable.GetFloat("mass", 0.0f);
if (ud.mass <= 0.0f) {
ud.mass=ud.metalCost;
}
ud.energyCost = udTable.GetFloat("buildCostEnergy", 0.0f);
ud.buildTime = udTable.GetFloat("buildTime", 0.0f);
if (ud.buildTime < 1.0f) {
ud.buildTime = 1.0f; //avoid some nasty divide by 0 etc
}
ud.aihint = id; // FIXME? (as noted in SelectedUnits.cpp, aihint is ignored)
ud.cobID = udTable.GetInt("cobID", -1);
ud.losRadius = udTable.GetFloat("sightDistance", 0.0f) * modInfo.losMul / (SQUARE_SIZE * (1 << modInfo.losMipLevel));
ud.airLosRadius = udTable.GetFloat("airSightDistance", -1.0f);
if (ud.airLosRadius == -1.0f) {
ud.airLosRadius=udTable.GetFloat("sightDistance", 0.0f) * modInfo.airLosMul * 1.5f / (SQUARE_SIZE * (1 << modInfo.airMipLevel));
} else {
ud.airLosRadius = ud.airLosRadius * modInfo.airLosMul / (SQUARE_SIZE * (1 << modInfo.airMipLevel));
}
ud.canSubmerge = udTable.GetBool("canSubmerge", false);
ud.canfly = udTable.GetBool("canFly", false);
ud.canmove = udTable.GetBool("canMove", false);
ud.reclaimable = udTable.GetBool("reclaimable", true);
ud.capturable = udTable.GetBool("capturable", true);
ud.repairable = udTable.GetBool("repairable", true);
ud.canAttack = udTable.GetBool("canAttack", true);
ud.canFight = udTable.GetBool("canFight", true);
ud.canPatrol = udTable.GetBool("canPatrol", true);
ud.canGuard = udTable.GetBool("canGuard", true);
ud.canRepeat = udTable.GetBool("canRepeat", true);
ud.builder = udTable.GetBool("builder", true);
ud.canRestore = udTable.GetBool("canRestore", ud.builder);
ud.canRepair = udTable.GetBool("canRepair", ud.builder);
ud.canReclaim = udTable.GetBool("canReclaim", ud.builder);
ud.canAssist = udTable.GetBool("canAssist", ud.builder);
ud.canBeAssisted = udTable.GetBool("canBeAssisted", true);
ud.canSelfRepair = udTable.GetBool("canSelfRepair", false);
ud.fullHealthFactory = udTable.GetBool("fullHealthFactory", false);
ud.factoryHeadingTakeoff = udTable.GetBool("factoryHeadingTakeoff", true);
ud.upright = udTable.GetBool("upright", false);
ud.collide = udTable.GetBool("collide", true);
ud.onoffable = udTable.GetBool("onoffable", false);
ud.maxSlope = udTable.GetFloat("maxSlope", 0.0f);
ud.maxHeightDif = 40 * tan(ud.maxSlope * (PI / 180));
ud.maxSlope = cos(ud.maxSlope * (PI / 180));
ud.minWaterDepth = udTable.GetFloat("minWaterDepth", -10e6f);
ud.maxWaterDepth = udTable.GetFloat("maxWaterDepth", +10e6f);
ud.minCollisionSpeed = udTable.GetFloat("minCollisionSpeed", 1.0f);
ud.slideTolerance = udTable.GetFloat("slideTolerance", 0.0f); // disabled
ud.pushResistant = udTable.GetBool("pushResistant", false);
ud.waterline = udTable.GetFloat("waterline", 0.0f);
if ((ud.waterline >= 5.0f) && ud.canmove) {
// make subs travel at somewhat larger depths
// to reduce vulnerability to surface weapons
ud.waterline += 10.0f;
}
ud.canSelfD = udTable.GetBool("canSelfDestruct", true);
ud.selfDCountdown = udTable.GetInt("selfDestructCountdown", 5);
ud.speed = udTable.GetFloat("maxVelocity", 0.0f) * GAME_SPEED;
ud.rSpeed = udTable.GetFloat("maxReverseVelocity", 0.0f) * GAME_SPEED;
ud.speed = fabs(ud.speed);
ud.rSpeed = fabs(ud.rSpeed);
ud.maxAcc = fabs(udTable.GetFloat("acceleration", 0.5f)); // no negative values
ud.maxDec = fabs(udTable.GetFloat("brakeRate", 3.0f * ud.maxAcc)) * (ud.canfly? 0.1f: 1.0f); // no negative values
ud.turnRate = udTable.GetFloat("turnRate", 0.0f);
ud.turnInPlace = udTable.GetBool( "turnInPlace", true);
ud.turnInPlaceDistance = udTable.GetFloat("turnInPlaceDistance", 350.f);
ud.turnInPlaceSpeedLimit = udTable.GetFloat("turnInPlaceSpeedLimit", 15.f);
const bool noAutoFire = udTable.GetBool("noAutoFire", false);
ud.canFireControl = udTable.GetBool("canFireControl", !noAutoFire);
ud.fireState = udTable.GetInt("fireState", ud.canFireControl ? -1 : 2);
ud.fireState = std::min(ud.fireState,2);
ud.moveState = udTable.GetInt("moveState", (ud.canmove && ud.speed>0.0f) ? -1 : 1);
ud.moveState = std::min(ud.moveState,2);
ud.buildRange3D = udTable.GetBool("buildRange3D", false);
ud.buildDistance = udTable.GetFloat("buildDistance", 128.0f);
ud.buildDistance = std::max(128.0f, ud.buildDistance);
ud.buildSpeed = udTable.GetFloat("workerTime", 0.0f);
ud.repairSpeed = udTable.GetFloat("repairSpeed", ud.buildSpeed);
ud.maxRepairSpeed = udTable.GetFloat("maxRepairSpeed", 1e20f);
ud.reclaimSpeed = udTable.GetFloat("reclaimSpeed", ud.buildSpeed);
ud.resurrectSpeed = udTable.GetFloat("resurrectSpeed", ud.buildSpeed);
ud.captureSpeed = udTable.GetFloat("captureSpeed", ud.buildSpeed);
ud.terraformSpeed = udTable.GetFloat("terraformSpeed", ud.buildSpeed);
ud.flankingBonusMode = udTable.GetInt("flankingBonusMode", modInfo.flankingBonusModeDefault);
ud.flankingBonusMax = udTable.GetFloat("flankingBonusMax", 1.9f);
ud.flankingBonusMin = udTable.GetFloat("flankingBonusMin", 0.9);
ud.flankingBonusDir = udTable.GetFloat3("flankingBonusDir", float3(0.0f, 0.0f, 1.0f));
ud.flankingBonusMobilityAdd = udTable.GetFloat("flankingBonusMobilityAdd", 0.01f);
ud.armoredMultiple = udTable.GetFloat("damageModifier", 1.0f);
ud.armorType = damageArrayHandler->GetTypeFromName(ud.name);
ud.radarRadius = udTable.GetInt("radarDistance", 0);
ud.sonarRadius = udTable.GetInt("sonarDistance", 0);
ud.jammerRadius = udTable.GetInt("radarDistanceJam", 0);
ud.sonarJamRadius = udTable.GetInt("sonarDistanceJam", 0);
ud.stealth = udTable.GetBool("stealth", false);
ud.sonarStealth = udTable.GetBool("sonarStealth", false);
ud.targfac = udTable.GetBool("isTargetingUpgrade", false);
ud.isFeature = udTable.GetBool("isFeature", false);
ud.canResurrect = udTable.GetBool("canResurrect", false);
ud.canCapture = udTable.GetBool("canCapture", false);
ud.hideDamage = udTable.GetBool("hideDamage", false);
ud.showPlayerName = udTable.GetBool("showPlayerName", false);
ud.cloakCost = udTable.GetFloat("cloakCost", -1.0f);
ud.cloakCostMoving = udTable.GetFloat("cloakCostMoving", -1.0f);
if (ud.cloakCostMoving < 0) {
ud.cloakCostMoving = ud.cloakCost;
}
ud.canCloak = (ud.cloakCost >= 0);
ud.startCloaked = udTable.GetBool("initCloaked", false);
ud.decloakDistance = udTable.GetFloat("minCloakDistance", 0.0f);
ud.decloakSpherical = udTable.GetBool("decloakSpherical", true);
ud.decloakOnFire = udTable.GetBool("decloakOnFire", true);
ud.highTrajectoryType = udTable.GetInt("highTrajectory", 0);
ud.canKamikaze = udTable.GetBool("kamikaze", false);
ud.kamikazeDist = udTable.GetFloat("kamikazeDistance", -25.0f) + 25.0f; //we count 3d distance while ta count 2d distance so increase slightly
ud.showNanoFrame = udTable.GetBool("showNanoFrame", true);
ud.showNanoSpray = udTable.GetBool("showNanoSpray", true);
ud.nanoColor = udTable.GetFloat3("nanoColor", float3(0.2f,0.7f,0.2f));
ud.canhover = udTable.GetBool("canHover", false);
ud.floater = udTable.GetBool("floater", udTable.KeyExists("WaterLine"));
ud.builder = udTable.GetBool("builder", false);
if (ud.builder && !ud.buildSpeed) { // core anti is flagged as builder for some reason
ud.builder = false;
}
ud.airStrafe = udTable.GetBool("airStrafe", true);
ud.hoverAttack = udTable.GetBool("hoverAttack", false);
ud.wantedHeight = udTable.GetFloat("cruiseAlt", 0.0f);
ud.dlHoverFactor = udTable.GetFloat("airHoverFactor", -1.0f);
ud.bankingAllowed = udTable.GetBool("bankingAllowed", true);
ud.transportSize = udTable.GetInt("transportSize", 0);
ud.minTransportSize = udTable.GetInt("minTransportSize", 0);
ud.transportCapacity = udTable.GetInt("transportCapacity", 0);
ud.isFirePlatform = udTable.GetBool("isFirePlatform", false);
ud.isAirBase = udTable.GetBool("isAirBase", false);
ud.loadingRadius = udTable.GetFloat("loadingRadius", 220.0f);
ud.unloadSpread = udTable.GetFloat("unloadSpread", 1.0f);
ud.transportMass = udTable.GetFloat("transportMass", 100000.0f);
ud.minTransportMass = udTable.GetFloat("minTransportMass", 0.0f);
ud.holdSteady = udTable.GetBool("holdSteady", true);
ud.releaseHeld = udTable.GetBool("releaseHeld", false);
ud.cantBeTransported = udTable.GetBool("cantBeTransported", false);
ud.transportByEnemy = udTable.GetBool("transportByEnemy", true);
ud.fallSpeed = udTable.GetFloat("fallSpeed", 0.2);
ud.unitFallSpeed = udTable.GetFloat("unitFallSpeed", 0);
ud.transportUnloadMethod = udTable.GetInt("transportUnloadMethod" , 0);
// modrules transport settings
if ((!modInfo.transportAir && ud.canfly) ||
(!modInfo.transportShip && ud.floater) ||
(!modInfo.transportHover && ud.canhover) ||
(!modInfo.transportGround && !ud.canhover && !ud.floater && !ud.canfly)) {
ud.cantBeTransported = true;
}
ud.wingDrag = udTable.GetFloat("wingDrag", 0.07f); // drag caused by wings
ud.wingDrag = std::min(1.0f, std::max(0.0f, ud.wingDrag));
ud.wingAngle = udTable.GetFloat("wingAngle", 0.08f); // angle between front and the wing plane
ud.frontToSpeed = udTable.GetFloat("frontToSpeed", 0.1f); // fudge factor for lining up speed and front of plane
ud.speedToFront = udTable.GetFloat("speedToFront", 0.07f); // fudge factor for lining up speed and front of plane
ud.myGravity = udTable.GetFloat("myGravity", 0.4f); // planes are slower than real airplanes so lower gravity to compensate
ud.crashDrag = udTable.GetFloat("crashDrag",0.005f); // drag used when crashing
ud.crashDrag = std::min(1.0f, std::max(0.0f, ud.crashDrag));
ud.maxBank = udTable.GetFloat("maxBank", 0.8f); // max roll
ud.maxPitch = udTable.GetFloat("maxPitch", 0.45f); // max pitch this plane tries to keep
ud.turnRadius = udTable.GetFloat("turnRadius", 500.0f); // hint to the ai about how large turn radius this plane needs
ud.verticalSpeed = udTable.GetFloat("verticalSpeed", 3.0f); // speed of takeoff and landing, at least for gunships
ud.maxAileron = udTable.GetFloat("maxAileron", 0.015f); // turn speed around roll axis
ud.maxElevator = udTable.GetFloat("maxElevator", 0.01f); // turn speed around pitch axis
ud.maxRudder = udTable.GetFloat("maxRudder", 0.004f); // turn speed around yaw axis
ud.maxFuel = udTable.GetFloat("maxFuel", 0.0f); //max flight time in seconds before aircraft must return to base
ud.refuelTime = udTable.GetFloat("refuelTime", 5.0f);
ud.minAirBasePower = udTable.GetFloat("minAirBasePower", 0.0f);
ud.maxThisUnit = udTable.GetInt("unitRestricted", MAX_UNITS);
string lname = StringToLower(ud.name);
if (gameSetup->restrictedUnits.find(lname) != gameSetup->restrictedUnits.end()) {
ud.maxThisUnit = std::min(ud.maxThisUnit, gameSetup->restrictedUnits.find(lname)->second);
}
ud.categoryString = udTable.GetString("category", "");
ud.category = CCategoryHandler::Instance()->GetCategories(udTable.GetString("category", ""));
ud.noChaseCategory = CCategoryHandler::Instance()->GetCategories(udTable.GetString("noChaseCategory", ""));
// logOutput.Print("Unit %s has cat %i",ud.humanName.c_str(),ud.category);
const string iconName = udTable.GetString("iconType", "default");
ud.iconType = iconHandler->GetIcon(iconName);
ud.shieldWeaponDef = NULL;
ud.stockpileWeaponDef = NULL;
ud.maxWeaponRange = 0.0f;
ud.maxCoverage = 0.0f;
const WeaponDef* noWeaponDef = weaponDefHandler->GetWeapon("NOWEAPON");
LuaTable weaponsTable = udTable.SubTable("weapons");
for (int w = 0; w < COB_MaxWeapons; w++) {
LuaTable wTable;
string name = weaponsTable.GetString(w + 1, "");
if (name.empty()) {
wTable = weaponsTable.SubTable(w + 1);
name = wTable.GetString("name", "");
}
const WeaponDef* wd = NULL;
if (!name.empty()) {
wd = weaponDefHandler->GetWeapon(name);
}
if (wd == NULL) {
if (w <= 3) {
continue; // allow empty weapons among the first 3
} else {
break;
}
}
while (ud.weapons.size() < w) {
if (!noWeaponDef) {
logOutput.Print("Error: Spring requires a NOWEAPON weapon type "
"to be present as a placeholder for missing weapons");
break;
} else {
ud.weapons.push_back(UnitDef::UnitDefWeapon());
ud.weapons.back().def = noWeaponDef;
}
}
const string badTarget = wTable.GetString("badTargetCategory", "");
unsigned int btc = CCategoryHandler::Instance()->GetCategories(badTarget);
const string onlyTarget = wTable.GetString("onlyTargetCategory", "");
unsigned int otc;
if (onlyTarget.empty()) {
otc = 0xffffffff;
} else {
otc = CCategoryHandler::Instance()->GetCategories(onlyTarget);
}
const unsigned int slaveTo = wTable.GetInt("slaveTo", 0);
float3 mainDir = wTable.GetFloat3("mainDir", float3(1.0f, 0.0f, 0.0f));
mainDir.SafeNormalize();
const float angleDif = cos(wTable.GetFloat("maxAngleDif", 360.0f) * (PI / 360.0f));
const float fuelUse = wTable.GetFloat("fuelUsage", 0.0f);
ud.weapons.push_back(UnitDef::UnitDefWeapon(name, wd, slaveTo, mainDir,
angleDif, btc, otc, fuelUse));
if (wd->range > ud.maxWeaponRange) {
ud.maxWeaponRange = wd->range;
}
if (wd->interceptor && wd->coverageRange > ud.maxCoverage) {
ud.maxCoverage = wd->coverageRange;
}
if (wd->isShield) {
if (!ud.shieldWeaponDef || // use the biggest shield
(ud.shieldWeaponDef->shieldRadius < wd->shieldRadius)) {
ud.shieldWeaponDef = wd;
}
}
if (wd->stockpile) {
// interceptors have priority
if (wd->interceptor ||
!ud.stockpileWeaponDef ||
!ud.stockpileWeaponDef->interceptor) {
ud.stockpileWeaponDef = wd;
}
}
}
ud.canDGun = udTable.GetBool("canDGun", false);
string TEDClass = udTable.GetString("TEDClass", "0");
ud.TEDClassString = TEDClass;
ud.extractRange = 0.0f;
ud.extractSquare = udTable.GetBool("extractSquare", false);
if (ud.extractsMetal) {
ud.extractRange = mapInfo->map.extractorRadius;
ud.type = "MetalExtractor";
}
else if (ud.transportCapacity) {
ud.type = "Transport";
}
else if (ud.builder) {
if (TEDClass != "PLANT") {
ud.type = "Builder";
} else {
ud.type = "Factory";
}
}
else if (ud.canfly && !ud.hoverAttack) {
if (!ud.weapons.empty() && (ud.weapons[0].def != 0) &&
(ud.weapons[0].def->type=="AircraftBomb" || ud.weapons[0].def->type=="TorpedoLauncher")) {
ud.type = "Bomber";
if (ud.turnRadius == 500) { // only reset it if user hasnt set it explicitly
ud.turnRadius = 1000; // hint to the ai about how large turn radius this plane needs
}
} else {
ud.type = "Fighter";
}
ud.maxAcc = udTable.GetFloat("maxAcc", 0.065f); // engine power
}
else if (ud.canmove) {
ud.type = "GroundUnit";
}
else {
ud.type = "Building";
}
ud.movedata = 0;
if (ud.canmove && !ud.canfly && (ud.type != "Factory")) {
string moveclass = StringToLower(udTable.GetString("movementClass", ""));
ud.movedata = moveinfo->GetMoveDataFromName(moveclass);
if (!ud.movedata) {
const string errmsg = "WARNING: Couldn't find a MoveClass named " + moveclass + " (used in UnitDef: " + unitName + ")";
logOutput.Print(errmsg);
// remove the UnitDef
throw content_error(errmsg);
}
if ((ud.movedata->moveType == MoveData::Hover_Move) ||
(ud.movedata->moveType == MoveData::Ship_Move)) {
ud.upright = true;
}
if (ud.canhover) {
if (ud.movedata->moveType != MoveData::Hover_Move) {
logOutput.Print("Inconsistent movedata %i for %s (moveclass %s): canhover, but not a hovercraft movetype",
ud.movedata->pathType, ud.name.c_str(), moveclass.c_str());
}
} else if (ud.floater) {
if (ud.movedata->moveType != MoveData::Ship_Move) {
logOutput.Print("Inconsistent movedata %i for %s (moveclass %s): floater, but not a ship movetype",
ud.movedata->pathType, ud.name.c_str(), moveclass.c_str());
}
} else {
if (ud.movedata->moveType != MoveData::Ground_Move) {
logOutput.Print("Inconsistent movedata %i for %s (moveclass %s): neither canhover nor floater, but not a ground movetype",
ud.movedata->pathType, ud.name.c_str(), moveclass.c_str());
}
}
}
if ((ud.maxAcc != 0) && (ud.speed != 0)) {
//meant to set the drag such that the maxspeed becomes what it should be
ud.drag = 1.0f / (ud.speed/GAME_SPEED * 1.1f / ud.maxAcc)
- (ud.wingAngle * ud.wingAngle * ud.wingDrag);
ud.drag = std::min(1.0f, std::max(0.0f, ud.drag));
} else {
//shouldn't be needed since drag is only used in CAirMoveType anyway,
//and aircraft without acceleration or speed aren't common :)
//initializing it anyway just for safety
ud.drag = 0.005f;
}
std::string objectname = udTable.GetString("objectName", "");
if (objectname.find(".") == std::string::npos) {
objectname += ".3do";
}
ud.modelDef.modelpath = "objects3d/" + objectname;
ud.modelDef.modelname = objectname;
ud.scriptName = udTable.GetString("script", unitName + ".cob");
ud.scriptPath = "scripts/" + ud.scriptName;
ud.wreckName = udTable.GetString("corpse", "");
ud.deathExplosion = udTable.GetString("explodeAs", "");
ud.selfDExplosion = udTable.GetString("selfDestructAs", "");
ud.power = udTable.GetFloat("power", (ud.metalCost + (ud.energyCost / 60.0f)));
// Prevent a division by zero in experience calculations.
if (ud.power < 1.0e-3f) {
logOutput.Print("Unit %s is really cheap? %f", ud.humanName.c_str(), ud.power);
logOutput.Print("This can cause a division by zero in experience calculations.");
ud.power = 1.0e-3f;
}
ud.activateWhenBuilt = udTable.GetBool("activateWhenBuilt", false);
// TA has only half our res so multiply size with 2
ud.xsize = udTable.GetInt("footprintX", 1) * 2;
ud.zsize = udTable.GetInt("footprintZ", 1) * 2;
ud.needGeo = false;
if ((ud.type == "Building") || (ud.type == "Factory")) {
CreateYardMap(&ud, udTable.GetString("yardMap", "c"));
} else {
for (int u = 0; u < 4; u++) {
ud.yardmaps[u] = 0;
}
}
ud.leaveTracks = udTable.GetBool("leaveTracks", false);
ud.trackWidth = udTable.GetFloat("trackWidth", 32.0f);
ud.trackOffset = udTable.GetFloat("trackOffset", 0.0f);
ud.trackStrength = udTable.GetFloat("trackStrength", 0.0f);
ud.trackStretch = udTable.GetFloat("trackStretch", 1.0f);
if (ud.leaveTracks && groundDecals) {
ud.trackType = groundDecals->GetTrackType(udTable.GetString("trackType", "StdTank"));
}
ud.useBuildingGroundDecal = udTable.GetBool("useBuildingGroundDecal", false);
ud.buildingDecalSizeX = udTable.GetInt("buildingGroundDecalSizeX", 4);
ud.buildingDecalSizeY = udTable.GetInt("buildingGroundDecalSizeY", 4);
ud.buildingDecalDecaySpeed = udTable.GetFloat("buildingGroundDecalDecaySpeed", 0.1f);
if (ud.useBuildingGroundDecal && groundDecals) {
ud.buildingDecalType = groundDecals->GetBuildingDecalType(udTable.GetString("buildingGroundDecalType", ""));
}
ud.canDropFlare = udTable.GetBool("canDropFlare", false);
ud.flareReloadTime = udTable.GetFloat("flareReload", 5.0f);
ud.flareDelay = udTable.GetFloat("flareDelay", 0.3f);
ud.flareEfficiency = udTable.GetFloat("flareEfficiency", 0.5f);
ud.flareDropVector = udTable.GetFloat3("flareDropVector", ZeroVector);
ud.flareTime = udTable.GetInt("flareTime", 3) * GAME_SPEED;
ud.flareSalvoSize = udTable.GetInt("flareSalvoSize", 4);
ud.flareSalvoDelay = udTable.GetInt("flareSalvoDelay", 0) * GAME_SPEED;
ud.smoothAnim = udTable.GetBool("smoothAnim", false);
ud.canLoopbackAttack = udTable.GetBool("canLoopbackAttack", false);
ud.canCrash = udTable.GetBool("canCrash", true);
ud.levelGround = udTable.GetBool("levelGround", true);
ud.strafeToAttack = udTable.GetBool("strafeToAttack", false);
ud.modelCenterOffset = udTable.GetFloat3("modelCenterOffset", ZeroVector);
ud.collisionVolumeTypeStr = udTable.GetString("collisionVolumeType", "");
ud.collisionVolumeScales = udTable.GetFloat3("collisionVolumeScales", ZeroVector);
ud.collisionVolumeOffsets = udTable.GetFloat3("collisionVolumeOffsets", ZeroVector);
ud.collisionVolumeTest = udTable.GetInt("collisionVolumeTest", COLVOL_TEST_DISC);
ud.usePieceCollisionVolumes = udTable.GetBool("usePieceCollisionVolumes", false);
// initialize the (per-unitdef) collision-volume
// all CUnit instances hold a copy of this object
ud.collisionVolume = new CollisionVolume(
ud.collisionVolumeTypeStr,
ud.collisionVolumeScales,
ud.collisionVolumeOffsets,
ud.collisionVolumeTest
);
if (ud.usePieceCollisionVolumes) {
ud.collisionVolume->Disable();
}
ud.seismicRadius = udTable.GetInt("seismicDistance", 0);
ud.seismicSignature = udTable.GetFloat("seismicSignature", -1.0f);
if (ud.seismicSignature == -1.0f) {
if (!ud.floater && !ud.canhover && !ud.canfly) {
ud.seismicSignature = sqrt(ud.mass / 100.0f);
} else {
ud.seismicSignature = 0.0f;
}
}
LuaTable buildsTable = udTable.SubTable("buildOptions");
if (buildsTable.IsValid()) {
for (int bo = 1; true; bo++) {
const string order = buildsTable.GetString(bo, "");
if (order.empty()) {
break;
}
ud.buildOptions[bo] = order;
}
}
LuaTable sfxTable = udTable.SubTable("SFXTypes");
LuaTable expTable = sfxTable.SubTable("explosionGenerators");
for (int expNum = 1; expNum <= 1024; expNum++) {
string expsfx = expTable.GetString(expNum, "");
if (expsfx == "") {
break;
} else {
ud.sfxExplGens.push_back(explGenHandler->LoadGenerator(expsfx));
}
}
// we use range in a modulo operation, so it needs to be >= 1
ud.pieceTrailCEGTag = udTable.GetString("pieceTrailCEGTag", "");
ud.pieceTrailCEGRange = udTable.GetInt("pieceTrailCEGRange", 1);
ud.pieceTrailCEGRange = std::max(ud.pieceTrailCEGRange, 1);
LuaTable soundsTable = udTable.SubTable("sounds");
LoadSounds(soundsTable, ud.sounds.ok, "ok"); // eg. "ok1", "ok2", ...
LoadSounds(soundsTable, ud.sounds.select, "select"); // eg. "select1", "select2", ...
LoadSounds(soundsTable, ud.sounds.arrived, "arrived"); // eg. "arrived1", "arrived2", ...
LoadSounds(soundsTable, ud.sounds.build, "build");
LoadSounds(soundsTable, ud.sounds.activate, "activate");
LoadSounds(soundsTable, ud.sounds.deactivate, "deactivate");
LoadSounds(soundsTable, ud.sounds.cant, "cant");
LoadSounds(soundsTable, ud.sounds.underattack, "underattack");
// custom parameters table
udTable.SubTable("customParams").GetMap(ud.customParams);
}
void CMapInfo::ReadWater()
{
const LuaTable wt = mapRoot->SubTable("water");
water.repeatX = wt.GetFloat("repeatX", 0.0f);
water.repeatY = wt.GetFloat("repeatY", 0.0f);
water.damage = wt.GetFloat("damage", 0.0f) * (16.0f / 30.0f);
water.absorb = wt.GetFloat3("absorb", float3(0.0f, 0.0f, 0.0f));
water.baseColor = wt.GetFloat3("baseColor", float3(0.0f, 0.0f, 0.0f));
water.minColor = wt.GetFloat3("minColor", float3(0.0f, 0.0f, 0.0f));
water.surfaceColor = wt.GetFloat3("surfaceColor", float3(0.75f, 0.8f, 0.85f));
water.surfaceAlpha = wt.GetFloat("surfaceAlpha", 0.55f);
water.planeColor = wt.GetFloat3("planeColor", float3(0.0f, 0.4f, 0.0f));
hasWaterPlane = wt.KeyExists("planeColor");
water.specularColor = wt.GetFloat3("specularColor", light.groundSunColor);
water.specularFactor = wt.GetFloat("specularFactor", 20.0f);
water.fresnelMin = wt.GetFloat("fresnelMin", 0.2f);
water.fresnelMax = wt.GetFloat("fresnelMax", 0.3f);
water.fresnelPower = wt.GetFloat("fresnelPower", 4.0f);
water.texture = wt.GetString("texture", "");
water.foamTexture = wt.GetString("foamTexture", "");
water.normalTexture = wt.GetString("normalTexture", "");
// use 'resources.lua' for missing fields (our the engine defaults)
const LuaTable resGfxMaps = resRoot->SubTable("graphics").SubTable("maps");
if (!water.texture.empty()) {
water.texture = "maps/" + water.texture;
} else {
water.texture = "bitmaps/" + resGfxMaps.GetString("watertex", "ocean.jpg");
}
if (!water.foamTexture.empty()) {
water.foamTexture = "maps/" + water.foamTexture;
} else {
water.foamTexture = "bitmaps/" + resGfxMaps.GetString("waterfoamtex", "foam.jpg");
}
if (!water.normalTexture.empty()) {
water.normalTexture = "maps/" + water.normalTexture;
} else {
water.normalTexture = "bitmaps/" + resGfxMaps.GetString("waternormaltex", "waterbump.png");
}
// water caustic textures
LuaTable caustics = wt.SubTable("caustics");
string causticPrefix = "maps/";
if (!caustics.IsValid()) {
caustics = resRoot->SubTable("graphics").SubTable("caustics");
causticPrefix = "bitmaps/";
}
if (caustics.IsValid()) {
for (int i = 1; true; i++) {
const string texName = caustics.GetString(i, "");
if (texName.empty()) {
break;
}
water.causticTextures.push_back(causticPrefix + texName);
}
} else {
// load the default 32 textures
for (int i = 0; i < 32; i++) {
char defTex[256];
sprintf(defTex, "bitmaps/caustics/caustic%02i.jpg", i);
water.causticTextures.push_back(defTex);
}
}
}
