mirror of
https://gitea.wildfiregames.com/0ad/0ad.git
synced 2026-06-22 14:26:34 +00:00
elexis
e0c30745f9
Move an early return to the top of the function. Add an early return in case an error was determined. Remove unneeded variables ok and templatePath. Replace includeSubdirectories boolean with a flags int to merge duplicate vfs::ForEachFile calls. This was SVN commit r18696.
559 lines
22 KiB
C++
559 lines
22 KiB
C++
/* Copyright (C) 2016 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#include "TemplateLoader.h"
|
|
|
|
#include "lib/utf8.h"
|
|
#include "ps/CLogger.h"
|
|
#include "ps/Filesystem.h"
|
|
#include "ps/XML/Xeromyces.h"
|
|
|
|
static const wchar_t TEMPLATE_ROOT[] = L"simulation/templates/";
|
|
static const wchar_t ACTOR_ROOT[] = L"art/actors/";
|
|
|
|
static CParamNode NULL_NODE(false);
|
|
|
|
bool CTemplateLoader::LoadTemplateFile(const std::string& templateName, int depth)
|
|
{
|
|
// If this file was already loaded, we don't need to do anything
|
|
if (m_TemplateFileData.find(templateName) != m_TemplateFileData.end())
|
|
return true;
|
|
|
|
// Handle infinite loops more gracefully than running out of stack space and crashing
|
|
if (depth > 100)
|
|
{
|
|
LOGERROR("Probable infinite inheritance loop in entity template '%s'", templateName.c_str());
|
|
return false;
|
|
}
|
|
|
|
// Handle special case "actor|foo"
|
|
if (templateName.find("actor|") == 0)
|
|
{
|
|
ConstructTemplateActor(templateName.substr(6), m_TemplateFileData[templateName]);
|
|
return true;
|
|
}
|
|
|
|
// Handle special case "preview|foo"
|
|
if (templateName.find("preview|") == 0)
|
|
{
|
|
// Load the base entity template, if it wasn't already loaded
|
|
std::string baseName = templateName.substr(8);
|
|
if (!LoadTemplateFile(baseName, depth+1))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", baseName.c_str());
|
|
return false;
|
|
}
|
|
// Copy a subset to the requested template
|
|
CopyPreviewSubset(m_TemplateFileData[templateName], m_TemplateFileData[baseName], false);
|
|
return true;
|
|
}
|
|
|
|
// Handle special case "corpse|foo"
|
|
if (templateName.find("corpse|") == 0)
|
|
{
|
|
// Load the base entity template, if it wasn't already loaded
|
|
std::string baseName = templateName.substr(7);
|
|
if (!LoadTemplateFile(baseName, depth+1))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", baseName.c_str());
|
|
return false;
|
|
}
|
|
// Copy a subset to the requested template
|
|
CopyPreviewSubset(m_TemplateFileData[templateName], m_TemplateFileData[baseName], true);
|
|
return true;
|
|
}
|
|
|
|
// Handle special case "mirage|foo"
|
|
if (templateName.find("mirage|") == 0)
|
|
{
|
|
// Load the base entity template, if it wasn't already loaded
|
|
std::string baseName = templateName.substr(7);
|
|
if (!LoadTemplateFile(baseName, depth+1))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", baseName.c_str());
|
|
return false;
|
|
}
|
|
// Copy a subset to the requested template
|
|
CopyMirageSubset(m_TemplateFileData[templateName], m_TemplateFileData[baseName]);
|
|
return true;
|
|
}
|
|
|
|
// Handle special case "foundation|foo"
|
|
if (templateName.find("foundation|") == 0)
|
|
{
|
|
// Load the base entity template, if it wasn't already loaded
|
|
std::string baseName = templateName.substr(11);
|
|
if (!LoadTemplateFile(baseName, depth+1))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", baseName.c_str());
|
|
return false;
|
|
}
|
|
// Copy a subset to the requested template
|
|
CopyFoundationSubset(m_TemplateFileData[templateName], m_TemplateFileData[baseName]);
|
|
return true;
|
|
}
|
|
|
|
// Handle special case "construction|foo"
|
|
if (templateName.find("construction|") == 0)
|
|
{
|
|
// Load the base entity template, if it wasn't already loaded
|
|
std::string baseName = templateName.substr(13);
|
|
if (!LoadTemplateFile(baseName, depth+1))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", baseName.c_str());
|
|
return false;
|
|
}
|
|
// Copy a subset to the requested template
|
|
CopyConstructionSubset(m_TemplateFileData[templateName], m_TemplateFileData[baseName]);
|
|
return true;
|
|
}
|
|
|
|
// Handle special case "resource|foo"
|
|
if (templateName.find("resource|") == 0)
|
|
{
|
|
// Load the base entity template, if it wasn't already loaded
|
|
std::string baseName = templateName.substr(9);
|
|
if (!LoadTemplateFile(baseName, depth+1))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", baseName.c_str());
|
|
return false;
|
|
}
|
|
// Copy a subset to the requested template
|
|
CopyResourceSubset(m_TemplateFileData[templateName], m_TemplateFileData[baseName]);
|
|
return true;
|
|
}
|
|
|
|
// Normal case: templateName is an XML file:
|
|
|
|
VfsPath path = VfsPath(TEMPLATE_ROOT) / wstring_from_utf8(templateName + ".xml");
|
|
CXeromyces xero;
|
|
PSRETURN ok = xero.Load(g_VFS, path);
|
|
if (ok != PSRETURN_OK)
|
|
return false; // (Xeromyces already logged an error with the full filename)
|
|
|
|
int attr_parent = xero.GetAttributeID("parent");
|
|
CStr parentName = xero.GetRoot().GetAttributes().GetNamedItem(attr_parent);
|
|
if (!parentName.empty())
|
|
{
|
|
// To prevent needless complexity in template design, we don't allow |-separated strings as parents
|
|
if (parentName.find('|') != parentName.npos)
|
|
{
|
|
LOGERROR("Invalid parent '%s' in entity template '%s'", parentName.c_str(), templateName.c_str());
|
|
return false;
|
|
}
|
|
|
|
// Ensure the parent is loaded
|
|
if (!LoadTemplateFile(parentName, depth+1))
|
|
{
|
|
LOGERROR("Failed to load parent '%s' of entity template '%s'", parentName.c_str(), templateName.c_str());
|
|
return false;
|
|
}
|
|
|
|
CParamNode& parentData = m_TemplateFileData[parentName];
|
|
|
|
// Initialise this template with its parent
|
|
m_TemplateFileData[templateName] = parentData;
|
|
}
|
|
|
|
// Load the new file into the template data (overriding parent values)
|
|
CParamNode::LoadXML(m_TemplateFileData[templateName], xero, wstring_from_utf8(templateName).c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
static Status AddToTemplates(const VfsPath& pathname, const CFileInfo& UNUSED(fileInfo), const uintptr_t cbData)
|
|
{
|
|
std::vector<std::string>& templates = *(std::vector<std::string>*)cbData;
|
|
|
|
// Strip the .xml extension
|
|
VfsPath pathstem = pathname.ChangeExtension(L"");
|
|
// Strip the root from the path
|
|
std::wstring name = pathstem.string().substr(ARRAY_SIZE(TEMPLATE_ROOT)-1);
|
|
|
|
// We want to ignore template_*.xml templates, since they should never be built in the editor
|
|
if (name.substr(0, 9) == L"template_")
|
|
return INFO::OK;
|
|
|
|
templates.push_back(std::string(name.begin(), name.end()));
|
|
return INFO::OK;
|
|
}
|
|
|
|
static Status AddActorToTemplates(const VfsPath& pathname, const CFileInfo& UNUSED(fileInfo), const uintptr_t cbData)
|
|
{
|
|
std::vector<std::string>& templates = *(std::vector<std::string>*)cbData;
|
|
|
|
// Strip the root from the path
|
|
std::wstring name = pathname.string().substr(ARRAY_SIZE(ACTOR_ROOT)-1);
|
|
|
|
templates.push_back("actor|" + std::string(name.begin(), name.end()));
|
|
return INFO::OK;
|
|
}
|
|
|
|
bool CTemplateLoader::TemplateExists(const std::string& templateName) const
|
|
{
|
|
size_t pos = templateName.rfind('|');
|
|
std::string baseName(pos != std::string::npos ? templateName.substr(pos+1) : templateName);
|
|
return VfsFileExists(VfsPath(TEMPLATE_ROOT) / wstring_from_utf8(baseName + ".xml"));
|
|
}
|
|
|
|
std::vector<std::string> CTemplateLoader::FindPlaceableTemplates(const std::string& path, bool includeSubdirectories, ETemplatesType templatesType, ScriptInterface& scriptInterface)
|
|
{
|
|
if (templatesType != SIMULATION_TEMPLATES && templatesType != ACTOR_TEMPLATES && templatesType != ALL_TEMPLATES)
|
|
{
|
|
LOGERROR("Undefined template type (valid: all, simulation, actor)");
|
|
return std::vector<std::string>();
|
|
}
|
|
|
|
JSContext* cx = scriptInterface.GetContext();
|
|
JSAutoRequest rq(cx);
|
|
|
|
std::vector<std::string> templates;
|
|
Status ok;
|
|
VfsPath templatePath;
|
|
|
|
if (templatesType == SIMULATION_TEMPLATES || templatesType == ALL_TEMPLATES)
|
|
{
|
|
JS::RootedValue placeablesFilter(cx);
|
|
scriptInterface.ReadJSONFile("simulation/data/placeablesFilter.json", &placeablesFilter);
|
|
|
|
JS::RootedObject folders(cx);
|
|
if (scriptInterface.GetProperty(placeablesFilter, "templates", &folders))
|
|
{
|
|
if (!(JS_IsArrayObject(cx, folders)))
|
|
{
|
|
LOGERROR("FindPlaceableTemplates: Argument must be an array!");
|
|
return templates;
|
|
}
|
|
|
|
u32 length;
|
|
if (!JS_GetArrayLength(cx, folders, &length))
|
|
{
|
|
LOGERROR("FindPlaceableTemplates: Failed to get array length!");
|
|
return templates;
|
|
}
|
|
|
|
templatePath = VfsPath(TEMPLATE_ROOT) / path;
|
|
//I have every object inside, just run for each
|
|
for (u32 i=0; i<length; ++i)
|
|
{
|
|
JS::RootedValue val(cx);
|
|
if (!JS_GetElement(cx, folders, i, &val))
|
|
{
|
|
LOGERROR("FindPlaceableTemplates: Failed to read array element!");
|
|
return templates;
|
|
}
|
|
|
|
std::string directoryPath;
|
|
std::wstring fileFilter;
|
|
scriptInterface.GetProperty(val, "directory", directoryPath);
|
|
scriptInterface.GetProperty(val, "file", fileFilter);
|
|
|
|
VfsPaths filenames;
|
|
if (vfs::GetPathnames(g_VFS, templatePath / (directoryPath + "/"), fileFilter.c_str(), filenames) != INFO::OK)
|
|
continue;
|
|
|
|
for (const VfsPath& filename : filenames)
|
|
{
|
|
// Strip the .xml extension
|
|
VfsPath pathstem = filename.ChangeExtension(L"");
|
|
// Strip the root from the path
|
|
std::wstring name = pathstem.string().substr(ARRAY_SIZE(TEMPLATE_ROOT) - 1);
|
|
|
|
templates.emplace_back(name.begin(), name.end());
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if (templatesType == ACTOR_TEMPLATES || templatesType == ALL_TEMPLATES)
|
|
{
|
|
templatePath = VfsPath(ACTOR_ROOT) / path;
|
|
if (includeSubdirectories)
|
|
ok = vfs::ForEachFile(g_VFS, templatePath, AddActorToTemplates, (uintptr_t)&templates, L"*.xml", vfs::DIR_RECURSIVE);
|
|
else
|
|
ok = vfs::ForEachFile(g_VFS, templatePath, AddActorToTemplates, (uintptr_t)&templates, L"*.xml");
|
|
WARN_IF_ERR(ok);
|
|
}
|
|
|
|
return templates;
|
|
}
|
|
|
|
std::vector<std::string> CTemplateLoader::FindTemplates(const std::string& path, bool includeSubdirectories, ETemplatesType templatesType)
|
|
{
|
|
std::vector<std::string> templates;
|
|
|
|
if (templatesType != SIMULATION_TEMPLATES && templatesType != ACTOR_TEMPLATES && templatesType != ALL_TEMPLATES)
|
|
{
|
|
LOGERROR("Undefined template type (valid: all, simulation, actor)");
|
|
return templates;
|
|
}
|
|
|
|
size_t flags = includeSubdirectories ? vfs::DIR_RECURSIVE : 0;
|
|
|
|
if (templatesType == SIMULATION_TEMPLATES || templatesType == ALL_TEMPLATES)
|
|
WARN_IF_ERR(vfs::ForEachFile(g_VFS, VfsPath(TEMPLATE_ROOT) / path, AddToTemplates, (uintptr_t)&templates, L"*.xml", flags));
|
|
|
|
if (templatesType == ACTOR_TEMPLATES || templatesType == ALL_TEMPLATES)
|
|
WARN_IF_ERR(vfs::ForEachFile(g_VFS, VfsPath(ACTOR_ROOT) / path, AddActorToTemplates, (uintptr_t)&templates, L"*.xml", flags));
|
|
|
|
return templates;
|
|
}
|
|
|
|
const CParamNode& CTemplateLoader::GetTemplateFileData(const std::string& templateName)
|
|
{
|
|
// Load the template if necessary
|
|
if (!LoadTemplateFile(templateName, 0))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", templateName.c_str());
|
|
return NULL_NODE;
|
|
}
|
|
|
|
return m_TemplateFileData[templateName];
|
|
}
|
|
|
|
void CTemplateLoader::ConstructTemplateActor(const std::string& actorName, CParamNode& out)
|
|
{
|
|
// Load the base actor template if necessary
|
|
const char* templateName = "special/actor";
|
|
if (!LoadTemplateFile(templateName, 0))
|
|
{
|
|
LOGERROR("Failed to load entity template '%s'", templateName);
|
|
return;
|
|
}
|
|
|
|
// Copy the actor template
|
|
out = m_TemplateFileData[templateName];
|
|
|
|
// Initialise the actor's name and make it an Atlas selectable entity.
|
|
std::wstring actorNameW = wstring_from_utf8(actorName);
|
|
std::string name = utf8_from_wstring(CParamNode::EscapeXMLString(actorNameW));
|
|
std::string xml = "<Entity>"
|
|
"<VisualActor><Actor>" + name + "</Actor><ActorOnly/></VisualActor>"
|
|
// arbitrary-sized Footprint definition to make actors' selection outlines show up in Atlas
|
|
"<Footprint><Circle radius='2.0'/><Height>1.0</Height></Footprint>"
|
|
"<Selectable>"
|
|
"<EditorOnly/>"
|
|
"<Overlay><Texture><MainTexture>actor.png</MainTexture><MainTextureMask>actor_mask.png</MainTextureMask></Texture></Overlay>"
|
|
"</Selectable>"
|
|
"</Entity>";
|
|
|
|
CParamNode::LoadXMLString(out, xml.c_str(), actorNameW.c_str());
|
|
}
|
|
|
|
void CTemplateLoader::CopyPreviewSubset(CParamNode& out, const CParamNode& in, bool corpse)
|
|
{
|
|
// We only want to include components which are necessary (for the visual previewing of an entity)
|
|
// and safe (i.e. won't do anything that affects the synchronised simulation state), so additions
|
|
// to this list should be carefully considered
|
|
std::set<std::string> permittedComponentTypes;
|
|
permittedComponentTypes.insert("Identity");
|
|
permittedComponentTypes.insert("Ownership");
|
|
permittedComponentTypes.insert("Position");
|
|
permittedComponentTypes.insert("Visibility");
|
|
permittedComponentTypes.insert("VisualActor");
|
|
permittedComponentTypes.insert("Footprint");
|
|
permittedComponentTypes.insert("Obstruction");
|
|
permittedComponentTypes.insert("Decay");
|
|
permittedComponentTypes.insert("BuildRestrictions");
|
|
|
|
// Need these for the Actor Viewer:
|
|
permittedComponentTypes.insert("Attack");
|
|
permittedComponentTypes.insert("UnitMotion");
|
|
permittedComponentTypes.insert("Sound");
|
|
|
|
// (This set could be initialised once and reused, but it's not worth the effort)
|
|
|
|
CParamNode::LoadXMLString(out, "<Entity/>");
|
|
out.CopyFilteredChildrenOfChild(in, "Entity", permittedComponentTypes);
|
|
|
|
// Disable the Obstruction component (if there is one) so it doesn't affect pathfinding
|
|
// (but can still be used for testing this entity for collisions against others)
|
|
if (out.GetChild("Entity").GetChild("Obstruction").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><Obstruction><Active>false</Active></Obstruction></Entity>");
|
|
|
|
if (!corpse)
|
|
{
|
|
// Previews should not cast shadows
|
|
if (out.GetChild("Entity").GetChild("VisualActor").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><VisualActor><DisableShadows/></VisualActor></Entity>");
|
|
|
|
// Previews should always be visible in fog-of-war/etc
|
|
CParamNode::LoadXMLString(out, "<Entity><Visibility><AlwaysVisible>true</AlwaysVisible><Preview>true</Preview></Visibility></Entity>");
|
|
}
|
|
|
|
if (corpse)
|
|
{
|
|
// Corpses should include decay components and activate them
|
|
if (out.GetChild("Entity").GetChild("Decay").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><Decay><Active>true</Active></Decay></Entity>");
|
|
|
|
// Corpses shouldn't display silhouettes (especially since they're often half underground)
|
|
if (out.GetChild("Entity").GetChild("VisualActor").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><VisualActor><SilhouetteDisplay>false</SilhouetteDisplay></VisualActor></Entity>");
|
|
|
|
// Corpses should remain visible in fog-of-war (for the owner only)
|
|
CParamNode::LoadXMLString(out, "<Entity><Visibility><Corpse>true</Corpse></Visibility></Entity>");
|
|
}
|
|
}
|
|
|
|
void CTemplateLoader::CopyMirageSubset(CParamNode& out, const CParamNode& in)
|
|
{
|
|
// Currently used for mirage entities replacing real ones in fog-of-war
|
|
|
|
std::set<std::string> permittedComponentTypes;
|
|
permittedComponentTypes.insert("Footprint");
|
|
permittedComponentTypes.insert("Minimap");
|
|
permittedComponentTypes.insert("Obstruction");
|
|
permittedComponentTypes.insert("Ownership");
|
|
permittedComponentTypes.insert("OverlayRenderer");
|
|
permittedComponentTypes.insert("Position");
|
|
permittedComponentTypes.insert("Selectable");
|
|
permittedComponentTypes.insert("StatusBars");
|
|
permittedComponentTypes.insert("Visibility");
|
|
permittedComponentTypes.insert("VisualActor");
|
|
|
|
CParamNode::LoadXMLString(out, "<Entity/>");
|
|
out.CopyFilteredChildrenOfChild(in, "Entity", permittedComponentTypes);
|
|
|
|
// Select a subset of identity data. We don't want to have, for example, a CC mirage
|
|
// that has also the CC class and then prevents construction of other CCs
|
|
std::set<std::string> identitySubset;
|
|
identitySubset.insert("Civ");
|
|
identitySubset.insert("GenericName");
|
|
identitySubset.insert("SpecificName");
|
|
identitySubset.insert("Tooltip");
|
|
identitySubset.insert("History");
|
|
identitySubset.insert("Icon");
|
|
CParamNode identity;
|
|
CParamNode::LoadXMLString(identity, "<Identity/>");
|
|
identity.CopyFilteredChildrenOfChild(in.GetChild("Entity"), "Identity", identitySubset);
|
|
CParamNode::LoadXMLString(out, ("<Entity>"+utf8_from_wstring(identity.ToXML())+"</Entity>").c_str());
|
|
|
|
// Mirages obstruction shouldn't block anything
|
|
if (out.GetChild("Entity").GetChild("Obstruction").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><Obstruction><BlockMovement>false</BlockMovement><BlockPathfinding>false</BlockPathfinding><BlockFoundation>false</BlockFoundation><BlockConstruction>false</BlockConstruction></Obstruction></Entity>");
|
|
|
|
// Set the entity as mirage entity
|
|
CParamNode::LoadXMLString(out, "<Entity><Mirage/></Entity>");
|
|
}
|
|
|
|
void CTemplateLoader::CopyFoundationSubset(CParamNode& out, const CParamNode& in)
|
|
{
|
|
// TODO: this is all kind of yucky and hard-coded; it'd be nice to have a more generic
|
|
// extensible scriptable way to define these subsets
|
|
|
|
std::set<std::string> permittedComponentTypes;
|
|
permittedComponentTypes.insert("Ownership");
|
|
permittedComponentTypes.insert("Position");
|
|
permittedComponentTypes.insert("VisualActor");
|
|
permittedComponentTypes.insert("Identity");
|
|
permittedComponentTypes.insert("BuildRestrictions");
|
|
permittedComponentTypes.insert("Obstruction");
|
|
permittedComponentTypes.insert("Selectable");
|
|
permittedComponentTypes.insert("Footprint");
|
|
permittedComponentTypes.insert("Fogging");
|
|
permittedComponentTypes.insert("Armour");
|
|
permittedComponentTypes.insert("Health");
|
|
permittedComponentTypes.insert("Market");
|
|
permittedComponentTypes.insert("StatusBars");
|
|
permittedComponentTypes.insert("OverlayRenderer");
|
|
permittedComponentTypes.insert("Decay");
|
|
permittedComponentTypes.insert("Cost");
|
|
permittedComponentTypes.insert("Sound");
|
|
permittedComponentTypes.insert("Visibility");
|
|
permittedComponentTypes.insert("Vision");
|
|
permittedComponentTypes.insert("AIProxy");
|
|
permittedComponentTypes.insert("RallyPoint");
|
|
permittedComponentTypes.insert("RallyPointRenderer");
|
|
|
|
CParamNode::LoadXMLString(out, "<Entity/>");
|
|
out.CopyFilteredChildrenOfChild(in, "Entity", permittedComponentTypes);
|
|
|
|
// Switch the actor to foundation mode
|
|
CParamNode::LoadXMLString(out, "<Entity><VisualActor><Foundation/></VisualActor></Entity>");
|
|
|
|
// Add the Foundation component, to deal with the construction process
|
|
CParamNode::LoadXMLString(out, "<Entity><Foundation/></Entity>");
|
|
|
|
// Initialise health to 1
|
|
CParamNode::LoadXMLString(out, "<Entity><Health><Initial>1</Initial></Health></Entity>");
|
|
|
|
// Foundations shouldn't initially block unit movement
|
|
if (out.GetChild("Entity").GetChild("Obstruction").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><Obstruction><DisableBlockMovement>true</DisableBlockMovement><DisableBlockPathfinding>true</DisableBlockPathfinding></Obstruction></Entity>");
|
|
|
|
// Don't provide population bonuses yet (but still do take up population cost)
|
|
if (out.GetChild("Entity").GetChild("Cost").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><Cost><PopulationBonus>0</PopulationBonus></Cost></Entity>");
|
|
|
|
// Foundations should be visible themselves in fog-of-war if their base template is,
|
|
// but shouldn't have any vision range
|
|
if (out.GetChild("Entity").GetChild("Vision").IsOk())
|
|
{
|
|
CParamNode::LoadXMLString(out, "<Entity><Vision><Range>0</Range></Vision></Entity>");
|
|
// Foundations should not have special vision capabilities either
|
|
if (out.GetChild("Entity").GetChild("Vision").GetChild("RevealShore").IsOk())
|
|
CParamNode::LoadXMLString(out, "<Entity><Vision><RevealShore>false</RevealShore></Vision></Entity>");
|
|
}
|
|
}
|
|
|
|
void CTemplateLoader::CopyConstructionSubset(CParamNode& out, const CParamNode& in)
|
|
{
|
|
// Currently used for buildings rising during construction
|
|
// Mostly serves to filter out components like Vision, UnitAI, etc.
|
|
std::set<std::string> permittedComponentTypes;
|
|
permittedComponentTypes.insert("Footprint");
|
|
permittedComponentTypes.insert("Ownership");
|
|
permittedComponentTypes.insert("Position");
|
|
permittedComponentTypes.insert("VisualActor");
|
|
|
|
CParamNode::LoadXMLString(out, "<Entity/>");
|
|
out.CopyFilteredChildrenOfChild(in, "Entity", permittedComponentTypes);
|
|
}
|
|
|
|
void CTemplateLoader::CopyResourceSubset(CParamNode& out, const CParamNode& in)
|
|
{
|
|
// Currently used for animals which die and leave a gatherable corpse.
|
|
// Mostly serves to filter out components like Vision, UnitAI, etc.
|
|
// Don't emit sound as our samples only apply to living animals.
|
|
std::set<std::string> permittedComponentTypes;
|
|
permittedComponentTypes.insert("Ownership");
|
|
permittedComponentTypes.insert("Position");
|
|
permittedComponentTypes.insert("VisualActor");
|
|
permittedComponentTypes.insert("Identity");
|
|
permittedComponentTypes.insert("Minimap");
|
|
permittedComponentTypes.insert("ResourceSupply");
|
|
permittedComponentTypes.insert("Selectable");
|
|
permittedComponentTypes.insert("Footprint");
|
|
permittedComponentTypes.insert("StatusBars");
|
|
permittedComponentTypes.insert("OverlayRenderer");
|
|
permittedComponentTypes.insert("AIProxy");
|
|
|
|
CParamNode::LoadXMLString(out, "<Entity/>");
|
|
out.CopyFilteredChildrenOfChild(in, "Entity", permittedComponentTypes);
|
|
|
|
// When dying, resources lose the unitMotion component
|
|
// This causes them to have no clearance. Since unit obstructions no longer have a radius,
|
|
// this makes them unreachable in some cases (see #3530).
|
|
// Instead, create a static, unblocking (see #3530 for why) static obstruction.
|
|
// TODO: this should probably be generalized as a parameter on entity death or something.
|
|
CParamNode::LoadXMLString(out, "<Entity><Obstruction><Active>true</Active><BlockMovement>false</BlockMovement><BlockPathfinding>false</BlockPathfinding><BlockFoundation>false</BlockFoundation><BlockConstruction>false</BlockConstruction><DisableBlockMovement>false</DisableBlockMovement><DisableBlockPathfinding>false</DisableBlockPathfinding><Static width=\"2.0\" depth=\"2.0\"/></Obstruction></Entity>");
|
|
}
|