phew

engine/shared/library/sharedTemplate/src/shared/template/ServerBuildingObjectTemplate.cpp

@@ -20,62 +20,56 @@
 #include <stdio.h>
 
 
-
 /**
  * Class constructor.
  */
-ServerBuildingObjectTemplate::ServerBuildingObjectTemplate(const std::string & filename)
+ServerBuildingObjectTemplate::ServerBuildingObjectTemplate(const std::string &filename)
 //@BEGIN TFD INIT
-	: ServerTangibleObjectTemplate(filename)
+        : ServerTangibleObjectTemplate(filename)
 //@END TFD INIT
 {
-}	// ServerBuildingObjectTemplate::ServerBuildingObjectTemplate
+}    // ServerBuildingObjectTemplate::ServerBuildingObjectTemplate
 
 /**
  * Class destructor.
  */
-ServerBuildingObjectTemplate::~ServerBuildingObjectTemplate()
-{
+ServerBuildingObjectTemplate::~ServerBuildingObjectTemplate() {
 //@BEGIN TFD CLEANUP
 //@END TFD CLEANUP
-}	// ServerBuildingObjectTemplate::~ServerBuildingObjectTemplate
+}    // ServerBuildingObjectTemplate::~ServerBuildingObjectTemplate
 
 /**
  * Static function used to register this template.
  */
-void ServerBuildingObjectTemplate::registerMe(void)
-{
-	ObjectTemplateList::registerTemplate(ServerBuildingObjectTemplate_tag, create);
-}	// ServerBuildingObjectTemplate::registerMe
+void ServerBuildingObjectTemplate::registerMe(void) {
+    ObjectTemplateList::registerTemplate(ServerBuildingObjectTemplate_tag, create);
+}    // ServerBuildingObjectTemplate::registerMe
 
 /**
  * Creates a ServerBuildingObjectTemplate template.
  *
  * @return a new instance of the template
  */
-ObjectTemplate * ServerBuildingObjectTemplate::create(const std::string & filename)
-{
-	return new ServerBuildingObjectTemplate(filename);
-}	// ServerBuildingObjectTemplate::create
+ObjectTemplate *ServerBuildingObjectTemplate::create(const std::string &filename) {
+    return new ServerBuildingObjectTemplate(filename);
+}    // ServerBuildingObjectTemplate::create
 
 /**
  * Returns the template id.
  *
  * @return the template id
  */
-Tag ServerBuildingObjectTemplate::getId(void) const
-{
-	return ServerBuildingObjectTemplate_tag;
-}	// ServerBuildingObjectTemplate::getId
+Tag ServerBuildingObjectTemplate::getId(void) const {
+    return ServerBuildingObjectTemplate_tag;
+}    // ServerBuildingObjectTemplate::getId
 
 /**
  * Returns this template's version.
  *
  * @return the version
  */
-Tag ServerBuildingObjectTemplate::getTemplateVersion(void) const
-{
-	return m_templateVersion;
+Tag ServerBuildingObjectTemplate::getTemplateVersion(void) const {
+    return m_templateVersion;
 } // ServerBuildingObjectTemplate::getTemplateVersion
 
 /**
@@ -83,121 +77,100 @@ Tag ServerBuildingObjectTemplate::getTemplateVersion(void) const
  *
  * @return the highest version
  */
-Tag ServerBuildingObjectTemplate::getHighestTemplateVersion(void) const
-{
-	if (m_baseData == NULL)
-		return m_templateVersion;
-	const ServerBuildingObjectTemplate * base = dynamic_cast<const ServerBuildingObjectTemplate *>(m_baseData);
-	if (base == NULL)
-		return m_templateVersion;
-	return std::max(m_templateVersion, base->getHighestTemplateVersion());
+Tag ServerBuildingObjectTemplate::getHighestTemplateVersion(void) const {
+    if (m_baseData == NULL)
+        return m_templateVersion;
+    const ServerBuildingObjectTemplate *base = dynamic_cast<const ServerBuildingObjectTemplate *>(m_baseData);
+    if (base == NULL)
+        return m_templateVersion;
+    return std::max(m_templateVersion, base->getHighestTemplateVersion());
 } // ServerBuildingObjectTemplate::getHighestTemplateVersion
 
 //@BEGIN TFD
-CompilerIntegerParam * ServerBuildingObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "maintenanceCost") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_maintenanceCost;
-		}
-		fprintf(stderr, "trying to access single-parameter \"maintenanceCost\" as an array\n");
-	}
-	else
-		return ServerTangibleObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerBuildingObjectTemplate::getCompilerIntegerParam
+CompilerIntegerParam *
+ServerBuildingObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index) {
+    if (strcmp(name, "maintenanceCost") == 0) {
+        if (index == 0) {
+            if (deepCheck && !isParamLoaded(name, false, 0)) {
+                if (getBaseTemplate() != nullptr)
+                    return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                return nullptr;
+            }
+            return &m_maintenanceCost;
+        }
+        fprintf(stderr, "trying to access single-parameter \"maintenanceCost\" as an array\n");
+    } else
+        return ServerTangibleObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
+    return nullptr;
+}    //ServerBuildingObjectTemplate::getCompilerIntegerParam
 
-FloatParam * ServerBuildingObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getFloatParam(name, deepCheck, index);
-}	//ServerBuildingObjectTemplate::getFloatParam
+FloatParam *ServerBuildingObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getFloatParam(name, deepCheck, index);
+}    //ServerBuildingObjectTemplate::getFloatParam
 
-BoolParam * ServerBuildingObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "isPublic") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getBoolParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_isPublic;
-		}
-		fprintf(stderr, "trying to access single-parameter \"isPublic\" as an array\n");
-	}
-	else
-		return ServerTangibleObjectTemplate::getBoolParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerBuildingObjectTemplate::getBoolParam
+BoolParam *ServerBuildingObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index) {
+    if (strcmp(name, "isPublic") == 0) {
+        if (index == 0) {
+            if (deepCheck && !isParamLoaded(name, false, 0)) {
+                if (getBaseTemplate() != nullptr)
+                    return getBaseTemplate()->getBoolParam(name, deepCheck, index);
+                return nullptr;
+            }
+            return &m_isPublic;
+        }
+        fprintf(stderr, "trying to access single-parameter \"isPublic\" as an array\n");
+    } else
+        return ServerTangibleObjectTemplate::getBoolParam(name, deepCheck, index);
+    return nullptr;
+}    //ServerBuildingObjectTemplate::getBoolParam
 
-StringParam * ServerBuildingObjectTemplate::getStringParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getStringParam(name, deepCheck, index);
-}	//ServerBuildingObjectTemplate::getStringParam
+StringParam *ServerBuildingObjectTemplate::getStringParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getStringParam(name, deepCheck, index);
+}    //ServerBuildingObjectTemplate::getStringParam
 
-StringIdParam * ServerBuildingObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getStringIdParam(name, deepCheck, index);
-}	//ServerBuildingObjectTemplate::getStringIdParam
+StringIdParam *ServerBuildingObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getStringIdParam(name, deepCheck, index);
+}    //ServerBuildingObjectTemplate::getStringIdParam
 
-VectorParam * ServerBuildingObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getVectorParam(name, deepCheck, index);
-}	//ServerBuildingObjectTemplate::getVectorParam
+VectorParam *ServerBuildingObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getVectorParam(name, deepCheck, index);
+}    //ServerBuildingObjectTemplate::getVectorParam
 
-DynamicVariableParam * ServerBuildingObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
-}	//ServerBuildingObjectTemplate::getDynamicVariableParam
+DynamicVariableParam *
+ServerBuildingObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
+}    //ServerBuildingObjectTemplate::getDynamicVariableParam
 
-StructParamOT * ServerBuildingObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getStructParamOT(name, deepCheck, index);
-}	//ServerBuildingObjectTemplate::getStructParamOT
+StructParamOT *ServerBuildingObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getStructParamOT(name, deepCheck, index);
+}    //ServerBuildingObjectTemplate::getStructParamOT
 
-TriggerVolumeParam * ServerBuildingObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
-}	//ServerBuildingObjectTemplate::getTriggerVolumeParam
+TriggerVolumeParam *ServerBuildingObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
+}    //ServerBuildingObjectTemplate::getTriggerVolumeParam
 
-void ServerBuildingObjectTemplate::initStructParamOT(StructParamOT &param, const char *name)
-{
-	if (param.isInitialized())
-		return;
-	ServerTangibleObjectTemplate::initStructParamOT(param, name);
-}	// ServerBuildingObjectTemplate::initStructParamOT
+void ServerBuildingObjectTemplate::initStructParamOT(StructParamOT &param, const char *name) {
+    if (param.isInitialized())
+        return;
+    ServerTangibleObjectTemplate::initStructParamOT(param, name);
+}    // ServerBuildingObjectTemplate::initStructParamOT
 
-void ServerBuildingObjectTemplate::setAsEmptyList(const char *name)
-{
-	ServerTangibleObjectTemplate::setAsEmptyList(name);
-}	// ServerBuildingObjectTemplate::setAsEmptyList
+void ServerBuildingObjectTemplate::setAsEmptyList(const char *name) {
+    ServerTangibleObjectTemplate::setAsEmptyList(name);
+}    // ServerBuildingObjectTemplate::setAsEmptyList
 
-void ServerBuildingObjectTemplate::setAppend(const char *name)
-{
-	ServerTangibleObjectTemplate::setAppend(name);
-}	// ServerBuildingObjectTemplate::setAppend
+void ServerBuildingObjectTemplate::setAppend(const char *name) {
+    ServerTangibleObjectTemplate::setAppend(name);
+}    // ServerBuildingObjectTemplate::setAppend
 
-bool ServerBuildingObjectTemplate::isAppend(const char *name) const
-{
-	return ServerTangibleObjectTemplate::isAppend(name);
-}	// ServerBuildingObjectTemplate::isAppend
+bool ServerBuildingObjectTemplate::isAppend(const char *name) const {
+    return ServerTangibleObjectTemplate::isAppend(name);
+}    // ServerBuildingObjectTemplate::isAppend
 
 
-int ServerBuildingObjectTemplate::getListLength(const char *name) const
-{
-	return ServerTangibleObjectTemplate::getListLength(name);
-}	// ServerBuildingObjectTemplate::getListLength
+int ServerBuildingObjectTemplate::getListLength(const char *name) const {
+    return ServerTangibleObjectTemplate::getListLength(name);
+}    // ServerBuildingObjectTemplate::getListLength
 
 /**
  * Loads the template data from an iff file. We should already be in the form
@@ -205,66 +178,60 @@ int ServerBuildingObjectTemplate::getListLength(const char *name) const
  *
  * @param file		file to load from
  */
-void ServerBuildingObjectTemplate::load(Iff &file)
-{
-static const int MAX_NAME_SIZE = 256;
-char paramName[MAX_NAME_SIZE];
+void ServerBuildingObjectTemplate::load(Iff &file) {
+    static const int MAX_NAME_SIZE = 256;
+    char paramName[MAX_NAME_SIZE];
 
-	if (file.getCurrentName() != ServerBuildingObjectTemplate_tag)
-	{
-		ServerTangibleObjectTemplate::load(file);
-		return;
-	}
+    if (file.getCurrentName() != ServerBuildingObjectTemplate_tag) {
+        ServerTangibleObjectTemplate::load(file);
+        return;
+    }
 
-	file.enterForm();
-	m_templateVersion = file.getCurrentName();
-	if (m_templateVersion == TAG(D,E,R,V))
-	{
-		file.enterForm();
-		file.enterChunk();
-		std::string baseFilename;
-		file.read_string(baseFilename);
-		file.exitChunk();
-		const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
-		DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
-		if (m_baseData == base && base != nullptr)
-			base->releaseReference();
-		else
-		{
-			if (m_baseData != nullptr)
-				m_baseData->releaseReference();
-			m_baseData = base;
-		}
-		file.exitForm();
-		m_templateVersion = file.getCurrentName();
-	}
-	if (getHighestTemplateVersion() != TAG(0,0,0,1))
-	{
-		if (DataLint::isEnabled())
-			DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
-	}
+    file.enterForm();
+    m_templateVersion = file.getCurrentName();
+    if (m_templateVersion == TAG(D, E, R, V)) {
+        file.enterForm();
+        file.enterChunk();
+        std::string baseFilename;
+        file.read_string(baseFilename);
+        file.exitChunk();
+        const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
+        DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
+        if (m_baseData == base && base != nullptr)
+            base->releaseReference();
+        else {
+            if (m_baseData != nullptr)
+                m_baseData->releaseReference();
+            m_baseData = base;
+        }
+        file.exitForm();
+        m_templateVersion = file.getCurrentName();
+    }
+    if (getHighestTemplateVersion() != TAG(0, 0, 0, 1)) {
+        if (DataLint::isEnabled())
+            DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
+    }
 
-	file.enterForm();
+    file.enterForm();
 
-	file.enterChunk();
-	int paramCount = file.read_int32();
-	file.exitChunk();
-	for (int i = 0; i < paramCount; ++i)
-	{
-		file.enterChunk();
-		file.read_string(paramName, MAX_NAME_SIZE);
-		if (strcmp(paramName, "maintenanceCost") == 0)
-			m_maintenanceCost.loadFromIff(file);
-		else if (strcmp(paramName, "isPublic") == 0)
-			m_isPublic.loadFromIff(file);
-		file.exitChunk(true);
-	}
+    file.enterChunk();
+    int paramCount = file.read_int32();
+    file.exitChunk();
+    for (int i = 0; i < paramCount; ++i) {
+        file.enterChunk();
+        file.read_string(paramName, MAX_NAME_SIZE);
+        if (strcmp(paramName, "isPublic") == 0)
+            m_isPublic.loadFromIff(file);
+        else if (strcmp(paramName, "maintenanceCost") == 0)
+            m_maintenanceCost.loadFromIff(file);
+        file.exitChunk(true);
+    }
 
-	file.exitForm();
-	ServerTangibleObjectTemplate::load(file);
-	file.exitForm();
-	return;
-}	// ServerBuildingObjectTemplate::load
+    file.exitForm();
+    ServerTangibleObjectTemplate::load(file);
+    file.exitForm();
+    return;
+}    // ServerBuildingObjectTemplate::load
 
 /**
  * Saves the template data to an iff file.
@@ -272,47 +239,45 @@ char paramName[MAX_NAME_SIZE];
  * @param file			file to save to
  * @param location		file type (client or server)
  */
-void ServerBuildingObjectTemplate::save(Iff &file)
-{
-int count;
+void ServerBuildingObjectTemplate::save(Iff &file) {
+    int count;
 
-	file.insertForm(ServerBuildingObjectTemplate_tag);
-	if (m_baseTemplateName.size() != 0)
-	{
-		file.insertForm(TAG(D,E,R,V));
-		file.insertChunk(TAG(X, X, X, X));
-		file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
-		file.exitChunk();
-		file.exitForm();
-	}
-	file.insertForm(TAG(0,0,0,1));
-	file.allowNonlinearFunctions();
+    file.insertForm(ServerBuildingObjectTemplate_tag);
+    if (m_baseTemplateName.size() != 0) {
+        file.insertForm(TAG(D, E, R, V));
+        file.insertChunk(TAG(X, X, X, X));
+        file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
+        file.exitChunk();
+        file.exitForm();
+    }
+    file.insertForm(TAG(0, 0, 0, 1));
+    file.allowNonlinearFunctions();
 
-	int paramCount = 0;
+    int paramCount = 0;
 
-	// save maintenanceCost
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("maintenanceCost");
-	m_maintenanceCost.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save isPublic
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("isPublic");
-	m_isPublic.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
+    // save maintenanceCost
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("maintenanceCost");
+    m_maintenanceCost.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save isPublic
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("isPublic");
+    m_isPublic.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
 
-	// write number of parameters
-	file.goToTopOfForm();
-	file.insertChunk(TAG(P, C, N, T));
-	file.insertChunkData(&paramCount, sizeof(paramCount));
-	file.exitChunk();
+    // write number of parameters
+    file.goToTopOfForm();
+    file.insertChunk(TAG(P, C, N, T));
+    file.insertChunkData(&paramCount, sizeof(paramCount));
+    file.exitChunk();
 
-	file.exitForm(true);
-	ServerTangibleObjectTemplate::save(file);
-	file.exitForm();
-	UNREF(count);
-}	// ServerBuildingObjectTemplate::save
+    file.exitForm(true);
+    ServerTangibleObjectTemplate::save(file);
+    file.exitForm();
+    UNREF(count);
+}    // ServerBuildingObjectTemplate::save
 
 //@END TFD

engine/shared/library/sharedTemplate/src/shared/template/ServerHarvesterInstallationObjectTemplate.cpp

@@ -19,63 +19,59 @@
 #include "sharedTemplateDefinition/ObjectTemplate.h"
 #include <stdio.h>
 
+#include "sharedFoundation/CrcConstexpr.hpp"
 
 
 /**
  * Class constructor.
  */
-ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate(const std::string & filename)
+ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate(const std::string &filename)
 //@BEGIN TFD INIT
-	: ServerInstallationObjectTemplate(filename)
+        : ServerInstallationObjectTemplate(filename)
 //@END TFD INIT
 {
-}	// ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate
+}    // ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate
 
 /**
  * Class destructor.
  */
-ServerHarvesterInstallationObjectTemplate::~ServerHarvesterInstallationObjectTemplate()
-{
+ServerHarvesterInstallationObjectTemplate::~ServerHarvesterInstallationObjectTemplate() {
 //@BEGIN TFD CLEANUP
 //@END TFD CLEANUP
-}	// ServerHarvesterInstallationObjectTemplate::~ServerHarvesterInstallationObjectTemplate
+}    // ServerHarvesterInstallationObjectTemplate::~ServerHarvesterInstallationObjectTemplate
 
 /**
  * Static function used to register this template.
  */
-void ServerHarvesterInstallationObjectTemplate::registerMe(void)
-{
-	ObjectTemplateList::registerTemplate(ServerHarvesterInstallationObjectTemplate_tag, create);
-}	// ServerHarvesterInstallationObjectTemplate::registerMe
+void ServerHarvesterInstallationObjectTemplate::registerMe(void) {
+    ObjectTemplateList::registerTemplate(ServerHarvesterInstallationObjectTemplate_tag, create);
+}    // ServerHarvesterInstallationObjectTemplate::registerMe
 
 /**
  * Creates a ServerHarvesterInstallationObjectTemplate template.
  *
  * @return a new instance of the template
  */
-ObjectTemplate * ServerHarvesterInstallationObjectTemplate::create(const std::string & filename)
-{
-	return new ServerHarvesterInstallationObjectTemplate(filename);
-}	// ServerHarvesterInstallationObjectTemplate::create
+ObjectTemplate *ServerHarvesterInstallationObjectTemplate::create(const std::string &filename) {
+    return new ServerHarvesterInstallationObjectTemplate(filename);
+}    // ServerHarvesterInstallationObjectTemplate::create
 
 /**
  * Returns the template id.
  *
  * @return the template id
  */
-Tag ServerHarvesterInstallationObjectTemplate::getId(void) const
-{
-	return ServerHarvesterInstallationObjectTemplate_tag;
-}	// ServerHarvesterInstallationObjectTemplate::getId
+Tag ServerHarvesterInstallationObjectTemplate::getId(void) const {
+    return ServerHarvesterInstallationObjectTemplate_tag;
+}    // ServerHarvesterInstallationObjectTemplate::getId
 
 /**
  * Returns this template's version.
  *
  * @return the version
  */
-Tag ServerHarvesterInstallationObjectTemplate::getTemplateVersion(void) const
-{
-	return m_templateVersion;
+Tag ServerHarvesterInstallationObjectTemplate::getTemplateVersion(void) const {
+    return m_templateVersion;
 } // ServerHarvesterInstallationObjectTemplate::getTemplateVersion
 
 /**
@@ -83,149 +79,132 @@ Tag ServerHarvesterInstallationObjectTemplate::getTemplateVersion(void) const
  *
  * @return the highest version
  */
-Tag ServerHarvesterInstallationObjectTemplate::getHighestTemplateVersion(void) const
-{
-	if (m_baseData == NULL)
-		return m_templateVersion;
-	const ServerHarvesterInstallationObjectTemplate * base = dynamic_cast<const ServerHarvesterInstallationObjectTemplate *>(m_baseData);
-	if (base == NULL)
-		return m_templateVersion;
-	return std::max(m_templateVersion, base->getHighestTemplateVersion());
+Tag ServerHarvesterInstallationObjectTemplate::getHighestTemplateVersion(void) const {
+    if (m_baseData == NULL)
+        return m_templateVersion;
+    const ServerHarvesterInstallationObjectTemplate *base = dynamic_cast<const ServerHarvesterInstallationObjectTemplate *>(m_baseData);
+    if (base == NULL)
+        return m_templateVersion;
+    return std::max(m_templateVersion, base->getHighestTemplateVersion());
 } // ServerHarvesterInstallationObjectTemplate::getHighestTemplateVersion
 
 //@BEGIN TFD
-CompilerIntegerParam * ServerHarvesterInstallationObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "maxExtractionRate") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_maxExtractionRate;
-		}
-		fprintf(stderr, "trying to access single-parameter \"maxExtractionRate\" as an array\n");
-	}
-	else if (strcmp(name, "currentExtractionRate") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_currentExtractionRate;
-		}
-		fprintf(stderr, "trying to access single-parameter \"currentExtractionRate\" as an array\n");
-	}
-	else if (strcmp(name, "maxHopperSize") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_maxHopperSize;
-		}
-		fprintf(stderr, "trying to access single-parameter \"maxHopperSize\" as an array\n");
-	}
-	else
-		return ServerInstallationObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerHarvesterInstallationObjectTemplate::getCompilerIntegerParam
+CompilerIntegerParam *
+ServerHarvesterInstallationObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index) {
+    switch (runtimeCrc(name)) {
+        case constcrc("maxExtractionRate"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_maxExtractionRate;
+            }
+            fprintf(stderr, "trying to access single-parameter \"maxExtractionRate\" as an array\n");
+        }
+            break;
+        case constcrc("currentExtractionRate"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_currentExtractionRate;
+            }
+            fprintf(stderr, "trying to access single-parameter \"currentExtractionRate\" as an array\n");
+        }
+            break;
+        case constcrc("maxHopperSize"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_maxHopperSize;
+            }
+            fprintf(stderr, "trying to access single-parameter \"maxHopperSize\" as an array\n");
+        }
+            break;
+        default:
+            return ServerInstallationObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
+            break;
+    }
+    return nullptr;
+}    //ServerHarvesterInstallationObjectTemplate::getCompilerIntegerParam
 
-FloatParam * ServerHarvesterInstallationObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index)
-{
-	return ServerInstallationObjectTemplate::getFloatParam(name, deepCheck, index);
-}	//ServerHarvesterInstallationObjectTemplate::getFloatParam
+FloatParam *ServerHarvesterInstallationObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index) {
+    return ServerInstallationObjectTemplate::getFloatParam(name, deepCheck, index);
+}    //ServerHarvesterInstallationObjectTemplate::getFloatParam
 
-BoolParam * ServerHarvesterInstallationObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index)
-{
-	return ServerInstallationObjectTemplate::getBoolParam(name, deepCheck, index);
-}	//ServerHarvesterInstallationObjectTemplate::getBoolParam
+BoolParam *ServerHarvesterInstallationObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index) {
+    return ServerInstallationObjectTemplate::getBoolParam(name, deepCheck, index);
+}    //ServerHarvesterInstallationObjectTemplate::getBoolParam
 
-StringParam * ServerHarvesterInstallationObjectTemplate::getStringParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "masterClassName") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getStringParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_masterClassName;
-		}
-		fprintf(stderr, "trying to access single-parameter \"masterClassName\" as an array\n");
-	}
-	else
-		return ServerInstallationObjectTemplate::getStringParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerHarvesterInstallationObjectTemplate::getStringParam
+StringParam *ServerHarvesterInstallationObjectTemplate::getStringParam(const char *name, bool deepCheck, int index) {
+    if (strcmp(name, "masterClassName") == 0) {
+        if (index == 0) {
+            if (deepCheck && !isParamLoaded(name, false, 0)) {
+                if (getBaseTemplate() != nullptr)
+                    return getBaseTemplate()->getStringParam(name, deepCheck, index);
+                return nullptr;
+            }
+            return &m_masterClassName;
+        }
+        fprintf(stderr, "trying to access single-parameter \"masterClassName\" as an array\n");
+    } else
+        return ServerInstallationObjectTemplate::getStringParam(name, deepCheck, index);
+    return nullptr;
+}    //ServerHarvesterInstallationObjectTemplate::getStringParam
 
-StringIdParam * ServerHarvesterInstallationObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index)
-{
-	return ServerInstallationObjectTemplate::getStringIdParam(name, deepCheck, index);
-}	//ServerHarvesterInstallationObjectTemplate::getStringIdParam
+StringIdParam *
+ServerHarvesterInstallationObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index) {
+    return ServerInstallationObjectTemplate::getStringIdParam(name, deepCheck, index);
+}    //ServerHarvesterInstallationObjectTemplate::getStringIdParam
 
-VectorParam * ServerHarvesterInstallationObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index)
-{
-	return ServerInstallationObjectTemplate::getVectorParam(name, deepCheck, index);
-}	//ServerHarvesterInstallationObjectTemplate::getVectorParam
+VectorParam *ServerHarvesterInstallationObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index) {
+    return ServerInstallationObjectTemplate::getVectorParam(name, deepCheck, index);
+}    //ServerHarvesterInstallationObjectTemplate::getVectorParam
 
-DynamicVariableParam * ServerHarvesterInstallationObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index)
-{
-	return ServerInstallationObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
-}	//ServerHarvesterInstallationObjectTemplate::getDynamicVariableParam
+DynamicVariableParam *
+ServerHarvesterInstallationObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index) {
+    return ServerInstallationObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
+}    //ServerHarvesterInstallationObjectTemplate::getDynamicVariableParam
 
-StructParamOT * ServerHarvesterInstallationObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index)
-{
-	return ServerInstallationObjectTemplate::getStructParamOT(name, deepCheck, index);
-}	//ServerHarvesterInstallationObjectTemplate::getStructParamOT
+StructParamOT *
+ServerHarvesterInstallationObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index) {
+    return ServerInstallationObjectTemplate::getStructParamOT(name, deepCheck, index);
+}    //ServerHarvesterInstallationObjectTemplate::getStructParamOT
 
-TriggerVolumeParam * ServerHarvesterInstallationObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index)
-{
-	return ServerInstallationObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
-}	//ServerHarvesterInstallationObjectTemplate::getTriggerVolumeParam
+TriggerVolumeParam *
+ServerHarvesterInstallationObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index) {
+    return ServerInstallationObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
+}    //ServerHarvesterInstallationObjectTemplate::getTriggerVolumeParam
 
-void ServerHarvesterInstallationObjectTemplate::initStructParamOT(StructParamOT &param, const char *name)
-{
-	if (param.isInitialized())
-		return;
-	ServerInstallationObjectTemplate::initStructParamOT(param, name);
-}	// ServerHarvesterInstallationObjectTemplate::initStructParamOT
+void ServerHarvesterInstallationObjectTemplate::initStructParamOT(StructParamOT &param, const char *name) {
+    if (param.isInitialized())
+        return;
+    ServerInstallationObjectTemplate::initStructParamOT(param, name);
+}    // ServerHarvesterInstallationObjectTemplate::initStructParamOT
 
-void ServerHarvesterInstallationObjectTemplate::setAsEmptyList(const char *name)
-{
-	ServerInstallationObjectTemplate::setAsEmptyList(name);
-}	// ServerHarvesterInstallationObjectTemplate::setAsEmptyList
+void ServerHarvesterInstallationObjectTemplate::setAsEmptyList(const char *name) {
+    ServerInstallationObjectTemplate::setAsEmptyList(name);
+}    // ServerHarvesterInstallationObjectTemplate::setAsEmptyList
 
-void ServerHarvesterInstallationObjectTemplate::setAppend(const char *name)
-{
-	ServerInstallationObjectTemplate::setAppend(name);
-}	// ServerHarvesterInstallationObjectTemplate::setAppend
+void ServerHarvesterInstallationObjectTemplate::setAppend(const char *name) {
+    ServerInstallationObjectTemplate::setAppend(name);
+}    // ServerHarvesterInstallationObjectTemplate::setAppend
 
-bool ServerHarvesterInstallationObjectTemplate::isAppend(const char *name) const
-{
-	return ServerInstallationObjectTemplate::isAppend(name);
-}	// ServerHarvesterInstallationObjectTemplate::isAppend
+bool ServerHarvesterInstallationObjectTemplate::isAppend(const char *name) const {
+    return ServerInstallationObjectTemplate::isAppend(name);
+}    // ServerHarvesterInstallationObjectTemplate::isAppend
 
 
-int ServerHarvesterInstallationObjectTemplate::getListLength(const char *name) const
-{
-	return ServerInstallationObjectTemplate::getListLength(name);
-}	// ServerHarvesterInstallationObjectTemplate::getListLength
+int ServerHarvesterInstallationObjectTemplate::getListLength(const char *name) const {
+    return ServerInstallationObjectTemplate::getListLength(name);
+}    // ServerHarvesterInstallationObjectTemplate::getListLength
 
 /**
  * Loads the template data from an iff file. We should already be in the form
@@ -233,70 +212,64 @@ int ServerHarvesterInstallationObjectTemplate::getListLength(const char *name) c
  *
  * @param file		file to load from
  */
-void ServerHarvesterInstallationObjectTemplate::load(Iff &file)
-{
-static const int MAX_NAME_SIZE = 256;
-char paramName[MAX_NAME_SIZE];
+void ServerHarvesterInstallationObjectTemplate::load(Iff &file) {
+    static const int MAX_NAME_SIZE = 256;
+    char paramName[MAX_NAME_SIZE];
 
-	if (file.getCurrentName() != ServerHarvesterInstallationObjectTemplate_tag)
-	{
-		ServerInstallationObjectTemplate::load(file);
-		return;
-	}
+    if (file.getCurrentName() != ServerHarvesterInstallationObjectTemplate_tag) {
+        ServerInstallationObjectTemplate::load(file);
+        return;
+    }
 
-	file.enterForm();
-	m_templateVersion = file.getCurrentName();
-	if (m_templateVersion == TAG(D,E,R,V))
-	{
-		file.enterForm();
-		file.enterChunk();
-		std::string baseFilename;
-		file.read_string(baseFilename);
-		file.exitChunk();
-		const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
-		DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
-		if (m_baseData == base && base != nullptr)
-			base->releaseReference();
-		else
-		{
-			if (m_baseData != nullptr)
-				m_baseData->releaseReference();
-			m_baseData = base;
-		}
-		file.exitForm();
-		m_templateVersion = file.getCurrentName();
-	}
-	if (getHighestTemplateVersion() != TAG(0,0,0,0))
-	{
-		if (DataLint::isEnabled())
-			DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
-	}
+    file.enterForm();
+    m_templateVersion = file.getCurrentName();
+    if (m_templateVersion == TAG(D, E, R, V)) {
+        file.enterForm();
+        file.enterChunk();
+        std::string baseFilename;
+        file.read_string(baseFilename);
+        file.exitChunk();
+        const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
+        DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
+        if (m_baseData == base && base != nullptr)
+            base->releaseReference();
+        else {
+            if (m_baseData != nullptr)
+                m_baseData->releaseReference();
+            m_baseData = base;
+        }
+        file.exitForm();
+        m_templateVersion = file.getCurrentName();
+    }
+    if (getHighestTemplateVersion() != TAG(0, 0, 0, 0)) {
+        if (DataLint::isEnabled())
+            DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
+    }
 
-	file.enterForm();
+    file.enterForm();
 
-	file.enterChunk();
-	int paramCount = file.read_int32();
-	file.exitChunk();
-	for (int i = 0; i < paramCount; ++i)
-	{
-		file.enterChunk();
-		file.read_string(paramName, MAX_NAME_SIZE);
-		if (strcmp(paramName, "maxExtractionRate") == 0)
-			m_maxExtractionRate.loadFromIff(file);
-		else if (strcmp(paramName, "currentExtractionRate") == 0)
-			m_currentExtractionRate.loadFromIff(file);
-		else if (strcmp(paramName, "maxHopperSize") == 0)
-			m_maxHopperSize.loadFromIff(file);
-		else if (strcmp(paramName, "masterClassName") == 0)
-			m_masterClassName.loadFromIff(file);
-		file.exitChunk(true);
-	}
+    file.enterChunk();
+    int paramCount = file.read_int32();
+    file.exitChunk();
+    for (int i = 0; i < paramCount; ++i) {
+        file.enterChunk();
+        file.read_string(paramName, MAX_NAME_SIZE);
+        if (strcmp(paramName, "maxExtractionRate") == 0)
+            m_maxExtractionRate.loadFromIff(file);
+        else if (strcmp(paramName, "currentExtractionRate") == 0)
+            m_currentExtractionRate.loadFromIff(file);
+        else if (strcmp(paramName, "maxHopperSize") == 0)
+            m_maxHopperSize.loadFromIff(file);
+        else if (strcmp(paramName, "masterClassName") == 0)
+            m_masterClassName.loadFromIff(file);
+        file.exitChunk(true);
+    }
 
-	file.exitForm();
-	ServerInstallationObjectTemplate::load(file);
-	file.exitForm();
-	return;
-}	// ServerHarvesterInstallationObjectTemplate::load
+    file.exitForm();
+    ServerInstallationObjectTemplate::load(file);
+    file.exitForm();
+    return;
+}    // ServerHarvesterInstallationObjectTemplate::load
 
 /**
  * Saves the template data to an iff file.
@@ -304,59 +277,57 @@ char paramName[MAX_NAME_SIZE];
  * @param file			file to save to
  * @param location		file type (client or server)
  */
-void ServerHarvesterInstallationObjectTemplate::save(Iff &file)
-{
-int count;
+void ServerHarvesterInstallationObjectTemplate::save(Iff &file) {
+    int count;
 
-	file.insertForm(ServerHarvesterInstallationObjectTemplate_tag);
-	if (m_baseTemplateName.size() != 0)
-	{
-		file.insertForm(TAG(D,E,R,V));
-		file.insertChunk(TAG(X, X, X, X));
-		file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
-		file.exitChunk();
-		file.exitForm();
-	}
-	file.insertForm(TAG(0,0,0,0));
-	file.allowNonlinearFunctions();
+    file.insertForm(ServerHarvesterInstallationObjectTemplate_tag);
+    if (m_baseTemplateName.size() != 0) {
+        file.insertForm(TAG(D, E, R, V));
+        file.insertChunk(TAG(X, X, X, X));
+        file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
+        file.exitChunk();
+        file.exitForm();
+    }
+    file.insertForm(TAG(0, 0, 0, 0));
+    file.allowNonlinearFunctions();
 
-	int paramCount = 0;
+    int paramCount = 0;
 
-	// save maxExtractionRate
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("maxExtractionRate");
-	m_maxExtractionRate.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save currentExtractionRate
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("currentExtractionRate");
-	m_currentExtractionRate.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save maxHopperSize
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("maxHopperSize");
-	m_maxHopperSize.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save masterClassName
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("masterClassName");
-	m_masterClassName.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
+    // save maxExtractionRate
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("maxExtractionRate");
+    m_maxExtractionRate.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save currentExtractionRate
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("currentExtractionRate");
+    m_currentExtractionRate.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save maxHopperSize
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("maxHopperSize");
+    m_maxHopperSize.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save masterClassName
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("masterClassName");
+    m_masterClassName.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
 
-	// write number of parameters
-	file.goToTopOfForm();
-	file.insertChunk(TAG(P, C, N, T));
-	file.insertChunkData(&paramCount, sizeof(paramCount));
-	file.exitChunk();
+    // write number of parameters
+    file.goToTopOfForm();
+    file.insertChunk(TAG(P, C, N, T));
+    file.insertChunkData(&paramCount, sizeof(paramCount));
+    file.exitChunk();
 
-	file.exitForm(true);
-	ServerInstallationObjectTemplate::save(file);
-	file.exitForm();
-	UNREF(count);
-}	// ServerHarvesterInstallationObjectTemplate::save
+    file.exitForm(true);
+    ServerInstallationObjectTemplate::save(file);
+    file.exitForm();
+    UNREF(count);
+}    // ServerHarvesterInstallationObjectTemplate::save
 
 //@END TFD

engine/shared/library/sharedTemplate/src/shared/template/ServerResourceClassObjectTemplate.cpp

@@ -19,63 +19,59 @@
 #include "sharedTemplateDefinition/ObjectTemplate.h"
 #include <stdio.h>
 
+#include "sharedFoundation/CrcConstexpr.hpp"
 
 
 /**
  * Class constructor.
  */
-ServerResourceClassObjectTemplate::ServerResourceClassObjectTemplate(const std::string & filename)
+ServerResourceClassObjectTemplate::ServerResourceClassObjectTemplate(const std::string &filename)
 //@BEGIN TFD INIT
-	: ServerUniverseObjectTemplate(filename)
+        : ServerUniverseObjectTemplate(filename)
 //@END TFD INIT
 {
-}	// ServerResourceClassObjectTemplate::ServerResourceClassObjectTemplate
+}    // ServerResourceClassObjectTemplate::ServerResourceClassObjectTemplate
 
 /**
  * Class destructor.
  */
-ServerResourceClassObjectTemplate::~ServerResourceClassObjectTemplate()
-{
+ServerResourceClassObjectTemplate::~ServerResourceClassObjectTemplate() {
 //@BEGIN TFD CLEANUP
 //@END TFD CLEANUP
-}	// ServerResourceClassObjectTemplate::~ServerResourceClassObjectTemplate
+}    // ServerResourceClassObjectTemplate::~ServerResourceClassObjectTemplate
 
 /**
  * Static function used to register this template.
  */
-void ServerResourceClassObjectTemplate::registerMe(void)
-{
-	ObjectTemplateList::registerTemplate(ServerResourceClassObjectTemplate_tag, create);
-}	// ServerResourceClassObjectTemplate::registerMe
+void ServerResourceClassObjectTemplate::registerMe(void) {
+    ObjectTemplateList::registerTemplate(ServerResourceClassObjectTemplate_tag, create);
+}    // ServerResourceClassObjectTemplate::registerMe
 
 /**
  * Creates a ServerResourceClassObjectTemplate template.
  *
  * @return a new instance of the template
  */
-ObjectTemplate * ServerResourceClassObjectTemplate::create(const std::string & filename)
-{
-	return new ServerResourceClassObjectTemplate(filename);
-}	// ServerResourceClassObjectTemplate::create
+ObjectTemplate *ServerResourceClassObjectTemplate::create(const std::string &filename) {
+    return new ServerResourceClassObjectTemplate(filename);
+}    // ServerResourceClassObjectTemplate::create
 
 /**
  * Returns the template id.
  *
  * @return the template id
  */
-Tag ServerResourceClassObjectTemplate::getId(void) const
-{
-	return ServerResourceClassObjectTemplate_tag;
-}	// ServerResourceClassObjectTemplate::getId
+Tag ServerResourceClassObjectTemplate::getId(void) const {
+    return ServerResourceClassObjectTemplate_tag;
+}    // ServerResourceClassObjectTemplate::getId
 
 /**
  * Returns this template's version.
  *
  * @return the version
  */
-Tag ServerResourceClassObjectTemplate::getTemplateVersion(void) const
-{
-	return m_templateVersion;
+Tag ServerResourceClassObjectTemplate::getTemplateVersion(void) const {
+    return m_templateVersion;
 } // ServerResourceClassObjectTemplate::getTemplateVersion
 
 /**
@@ -83,163 +79,147 @@ Tag ServerResourceClassObjectTemplate::getTemplateVersion(void) const
  *
  * @return the highest version
  */
-Tag ServerResourceClassObjectTemplate::getHighestTemplateVersion(void) const
-{
-	if (m_baseData == NULL)
-		return m_templateVersion;
-	const ServerResourceClassObjectTemplate * base = dynamic_cast<const ServerResourceClassObjectTemplate *>(m_baseData);
-	if (base == NULL)
-		return m_templateVersion;
-	return std::max(m_templateVersion, base->getHighestTemplateVersion());
+Tag ServerResourceClassObjectTemplate::getHighestTemplateVersion(void) const {
+    if (m_baseData == NULL)
+        return m_templateVersion;
+    const ServerResourceClassObjectTemplate *base = dynamic_cast<const ServerResourceClassObjectTemplate *>(m_baseData);
+    if (base == NULL)
+        return m_templateVersion;
+    return std::max(m_templateVersion, base->getHighestTemplateVersion());
 } // ServerResourceClassObjectTemplate::getHighestTemplateVersion
 
 //@BEGIN TFD
-CompilerIntegerParam * ServerResourceClassObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "numTypes") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != NULL)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return NULL;
-			}
-			return &m_numTypes;
-		}
-		fprintf(stderr, "trying to access single-parameter \"numTypes\" as an array\n");
-	}
-	else if (strcmp(name, "minTypes") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != NULL)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return NULL;
-			}
-			return &m_minTypes;
-		}
-		fprintf(stderr, "trying to access single-parameter \"minTypes\" as an array\n");
-	}
-	else if (strcmp(name, "maxTypes") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != NULL)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return NULL;
-			}
-			return &m_maxTypes;
-		}
-		fprintf(stderr, "trying to access single-parameter \"maxTypes\" as an array\n");
-	}
-	else
-		return ServerUniverseObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
-	return NULL;
-}	//ServerResourceClassObjectTemplate::getCompilerIntegerParam
+CompilerIntegerParam *
+ServerResourceClassObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index) {
+    switch (runtimeCrc(name)) {
+        case constcrc("numTypes"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != NULL)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return NULL;
+                }
+                return &m_numTypes;
+            }
+            fprintf(stderr, "trying to access single-parameter \"numTypes\" as an array\n");
+        }
+            break;
+        case constcrc("minTypes"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != NULL)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return NULL;
+                }
+                return &m_minTypes;
+            }
+            fprintf(stderr, "trying to access single-parameter \"minTypes\" as an array\n");
+        }
+            break;
+        case constcrc("maxTypes"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != NULL)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return NULL;
+                }
+                return &m_maxTypes;
+            }
+            fprintf(stderr, "trying to access single-parameter \"maxTypes\" as an array\n");
+        }
+            break;
+        default:
+            return ServerUniverseObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
+            break;
+    }
+    return NULL;
+}    //ServerResourceClassObjectTemplate::getCompilerIntegerParam
 
-FloatParam * ServerResourceClassObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index)
-{
-	return ServerUniverseObjectTemplate::getFloatParam(name, deepCheck, index);
-}	//ServerResourceClassObjectTemplate::getFloatParam
+FloatParam *ServerResourceClassObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index) {
+    return ServerUniverseObjectTemplate::getFloatParam(name, deepCheck, index);
+}    //ServerResourceClassObjectTemplate::getFloatParam
 
-BoolParam * ServerResourceClassObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index)
-{
-	return ServerUniverseObjectTemplate::getBoolParam(name, deepCheck, index);
-}	//ServerResourceClassObjectTemplate::getBoolParam
+BoolParam *ServerResourceClassObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index) {
+    return ServerUniverseObjectTemplate::getBoolParam(name, deepCheck, index);
+}    //ServerResourceClassObjectTemplate::getBoolParam
 
-StringParam * ServerResourceClassObjectTemplate::getStringParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "resourceClassName") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != NULL)
-					return getBaseTemplate()->getStringParam(name, deepCheck, index);
-				return NULL;
-			}
-			return &m_resourceClassName;
-		}
-		fprintf(stderr, "trying to access single-parameter \"resourceClassName\" as an array\n");
-	}
-	else if (strcmp(name, "parentClass") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != NULL)
-					return getBaseTemplate()->getStringParam(name, deepCheck, index);
-				return NULL;
-			}
-			return &m_parentClass;
-		}
-		fprintf(stderr, "trying to access single-parameter \"parentClass\" as an array\n");
-	}
-	else
-		return ServerUniverseObjectTemplate::getStringParam(name, deepCheck, index);
-	return NULL;
-}	//ServerResourceClassObjectTemplate::getStringParam
+StringParam *ServerResourceClassObjectTemplate::getStringParam(const char *name, bool deepCheck, int index) {
+    switch (runtimeCrc(name)) {
+        case constcrc("resourceClassName"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != NULL)
+                        return getBaseTemplate()->getStringParam(name, deepCheck, index);
+                    return NULL;
+                }
+                return &m_resourceClassName;
+            }
+            fprintf(stderr, "trying to access single-parameter \"resourceClassName\" as an array\n");
+        }
+            break;
+        case constcrc("parentClass"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != NULL)
+                        return getBaseTemplate()->getStringParam(name, deepCheck, index);
+                    return NULL;
+                }
+                return &m_parentClass;
+            }
+            fprintf(stderr, "trying to access single-parameter \"parentClass\" as an array\n");
+        }
+            break;
+        default:
+            return ServerUniverseObjectTemplate::getStringParam(name, deepCheck, index);
+            break;
+    }
+    return NULL;
+}    //ServerResourceClassObjectTemplate::getStringParam
 
-StringIdParam * ServerResourceClassObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index)
-{
-	return ServerUniverseObjectTemplate::getStringIdParam(name, deepCheck, index);
-}	//ServerResourceClassObjectTemplate::getStringIdParam
+StringIdParam *ServerResourceClassObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index) {
+    return ServerUniverseObjectTemplate::getStringIdParam(name, deepCheck, index);
+}    //ServerResourceClassObjectTemplate::getStringIdParam
 
-VectorParam * ServerResourceClassObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index)
-{
-	return ServerUniverseObjectTemplate::getVectorParam(name, deepCheck, index);
-}	//ServerResourceClassObjectTemplate::getVectorParam
+VectorParam *ServerResourceClassObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index) {
+    return ServerUniverseObjectTemplate::getVectorParam(name, deepCheck, index);
+}    //ServerResourceClassObjectTemplate::getVectorParam
 
-DynamicVariableParam * ServerResourceClassObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index)
-{
-	return ServerUniverseObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
-}	//ServerResourceClassObjectTemplate::getDynamicVariableParam
+DynamicVariableParam *
+ServerResourceClassObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index) {
+    return ServerUniverseObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
+}    //ServerResourceClassObjectTemplate::getDynamicVariableParam
 
-StructParamOT * ServerResourceClassObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index)
-{
-	return ServerUniverseObjectTemplate::getStructParamOT(name, deepCheck, index);
-}	//ServerResourceClassObjectTemplate::getStructParamOT
+StructParamOT *ServerResourceClassObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index) {
+    return ServerUniverseObjectTemplate::getStructParamOT(name, deepCheck, index);
+}    //ServerResourceClassObjectTemplate::getStructParamOT
 
-TriggerVolumeParam * ServerResourceClassObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index)
-{
-	return ServerUniverseObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
-}	//ServerResourceClassObjectTemplate::getTriggerVolumeParam
+TriggerVolumeParam *
+ServerResourceClassObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index) {
+    return ServerUniverseObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
+}    //ServerResourceClassObjectTemplate::getTriggerVolumeParam
 
-void ServerResourceClassObjectTemplate::initStructParamOT(StructParamOT &param, const char *name)
-{
-	if (param.isInitialized())
-		return;
-	ServerUniverseObjectTemplate::initStructParamOT(param, name);
-}	// ServerResourceClassObjectTemplate::initStructParamOT
+void ServerResourceClassObjectTemplate::initStructParamOT(StructParamOT &param, const char *name) {
+    if (param.isInitialized())
+        return;
+    ServerUniverseObjectTemplate::initStructParamOT(param, name);
+}    // ServerResourceClassObjectTemplate::initStructParamOT
 
-void ServerResourceClassObjectTemplate::setAsEmptyList(const char *name)
-{
-	ServerUniverseObjectTemplate::setAsEmptyList(name);
-}	// ServerResourceClassObjectTemplate::setAsEmptyList
+void ServerResourceClassObjectTemplate::setAsEmptyList(const char *name) {
+    ServerUniverseObjectTemplate::setAsEmptyList(name);
+}    // ServerResourceClassObjectTemplate::setAsEmptyList
 
-void ServerResourceClassObjectTemplate::setAppend(const char *name)
-{
-	ServerUniverseObjectTemplate::setAppend(name);
-}	// ServerResourceClassObjectTemplate::setAppend
+void ServerResourceClassObjectTemplate::setAppend(const char *name) {
+    ServerUniverseObjectTemplate::setAppend(name);
+}    // ServerResourceClassObjectTemplate::setAppend
 
-bool ServerResourceClassObjectTemplate::isAppend(const char *name) const
-{
-	return ServerUniverseObjectTemplate::isAppend(name);
-}	// ServerResourceClassObjectTemplate::isAppend
+bool ServerResourceClassObjectTemplate::isAppend(const char *name) const {
+    return ServerUniverseObjectTemplate::isAppend(name);
+}    // ServerResourceClassObjectTemplate::isAppend
 
 
-int ServerResourceClassObjectTemplate::getListLength(const char *name) const
-{
-	return ServerUniverseObjectTemplate::getListLength(name);
-}	// ServerResourceClassObjectTemplate::getListLength
+int ServerResourceClassObjectTemplate::getListLength(const char *name) const {
+    return ServerUniverseObjectTemplate::getListLength(name);
+}    // ServerResourceClassObjectTemplate::getListLength
 
 /**
  * Loads the template data from an iff file. We should already be in the form
@@ -247,72 +227,74 @@ int ServerResourceClassObjectTemplate::getListLength(const char *name) const
  *
  * @param file		file to load from
  */
-void ServerResourceClassObjectTemplate::load(Iff &file)
-{
-static const int MAX_NAME_SIZE = 256;
-char paramName[MAX_NAME_SIZE];
+void ServerResourceClassObjectTemplate::load(Iff &file) {
+    static const int MAX_NAME_SIZE = 256;
+    char paramName[MAX_NAME_SIZE];
 
-	if (file.getCurrentName() != ServerResourceClassObjectTemplate_tag)
-	{
-		ServerUniverseObjectTemplate::load(file);
-		return;
-	}
+    if (file.getCurrentName() != ServerResourceClassObjectTemplate_tag) {
+        ServerUniverseObjectTemplate::load(file);
+        return;
+    }
 
-	file.enterForm();
-	m_templateVersion = file.getCurrentName();
-	if (m_templateVersion == TAG(D,E,R,V))
-	{
-		file.enterForm();
-		file.enterChunk();
-		std::string baseFilename;
-		file.read_string(baseFilename);
-		file.exitChunk();
-		const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
-		DEBUG_WARNING(base == NULL, ("was unable to load base template %s", baseFilename.c_str()));
-		if (m_baseData == base && base != NULL)
-			base->releaseReference();
-		else
-		{
-			if (m_baseData != NULL)
-				m_baseData->releaseReference();
-			m_baseData = base;
-		}
-		file.exitForm();
-		m_templateVersion = file.getCurrentName();
-	}
-	if (getHighestTemplateVersion() != TAG(0,0,0,0))
-	{
-		if (DataLint::isEnabled())
-			DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
-	}
+    file.enterForm();
+    m_templateVersion = file.getCurrentName();
+    if (m_templateVersion == TAG(D, E, R, V)) {
+        file.enterForm();
+        file.enterChunk();
+        std::string baseFilename;
+        file.read_string(baseFilename);
+        file.exitChunk();
+        const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
+        DEBUG_WARNING(base == NULL, ("was unable to load base template %s", baseFilename.c_str()));
+        if (m_baseData == base && base != NULL)
+            base->releaseReference();
+        else {
+            if (m_baseData != NULL)
+                m_baseData->releaseReference();
+            m_baseData = base;
+        }
+        file.exitForm();
+        m_templateVersion = file.getCurrentName();
+    }
+    if (getHighestTemplateVersion() != TAG(0, 0, 0, 0)) {
+        if (DataLint::isEnabled())
+            DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
+    }
 
-	file.enterForm();
+    file.enterForm();
 
-	file.enterChunk();
-	int paramCount = file.read_int32();
-	file.exitChunk();
-	for (int i = 0; i < paramCount; ++i)
-	{
-		file.enterChunk();
-		file.read_string(paramName, MAX_NAME_SIZE);
-		if (strcmp(paramName, "resourceClassName") == 0)
-			m_resourceClassName.loadFromIff(file);
-		else if (strcmp(paramName, "numTypes") == 0)
-			m_numTypes.loadFromIff(file);
-		else if (strcmp(paramName, "minTypes") == 0)
-			m_minTypes.loadFromIff(file);
-		else if (strcmp(paramName, "maxTypes") == 0)
-			m_maxTypes.loadFromIff(file);
-		else if (strcmp(paramName, "parentClass") == 0)
-			m_parentClass.loadFromIff(file);
-		file.exitChunk(true);
-	}
+    file.enterChunk();
+    int paramCount = file.read_int32();
+    file.exitChunk();
+    for (int i = 0; i < paramCount; ++i) {
+        file.enterChunk();
+        file.read_string(paramName, MAX_NAME_SIZE);
 
-	file.exitForm();
-	ServerUniverseObjectTemplate::load(file);
-	file.exitForm();
-	return;
-}	// ServerResourceClassObjectTemplate::load
+        switch (runtimeCrc(paramName)) {
+            case constcrc("resourceClassName"):
+                m_resourceClassName.loadFromIff(file);
+                break;
+            case constcrc("numTypes"):
+                m_numTypes.loadFromIff(file);
+                break;
+            case constcrc("minTypes") :
+                m_minTypes.loadFromIff(file);
+                break;
+            case constcrc("maxTypes") :
+                m_maxTypes.loadFromIff(file);
+                break;
+            case constcrc("parentClass") :
+                m_parentClass.loadFromIff(file);
+                break;
+        }
+        file.exitChunk(true);
+    }
+
+    file.exitForm();
+    ServerUniverseObjectTemplate::load(file);
+    file.exitForm();
+    return;
+}    // ServerResourceClassObjectTemplate::load
 
 /**
  * Saves the template data to an iff file.
@@ -320,65 +302,63 @@ char paramName[MAX_NAME_SIZE];
  * @param file			file to save to
  * @param location		file type (client or server)
  */
-void ServerResourceClassObjectTemplate::save(Iff &file)
-{
-int count;
+void ServerResourceClassObjectTemplate::save(Iff &file) {
+    int count;
 
-	file.insertForm(ServerResourceClassObjectTemplate_tag);
-	if (m_baseTemplateName.size() != 0)
-	{
-		file.insertForm(TAG(D,E,R,V));
-		file.insertChunk(TAG(X, X, X, X));
-		file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
-		file.exitChunk();
-		file.exitForm();
-	}
-	file.insertForm(TAG(0,0,0,0));
-	file.allowNonlinearFunctions();
+    file.insertForm(ServerResourceClassObjectTemplate_tag);
+    if (m_baseTemplateName.size() != 0) {
+        file.insertForm(TAG(D, E, R, V));
+        file.insertChunk(TAG(X, X, X, X));
+        file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
+        file.exitChunk();
+        file.exitForm();
+    }
+    file.insertForm(TAG(0, 0, 0, 0));
+    file.allowNonlinearFunctions();
 
-	int paramCount = 0;
+    int paramCount = 0;
 
-	// save resourceClassName
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("resourceClassName");
-	m_resourceClassName.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save numTypes
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("numTypes");
-	m_numTypes.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save minTypes
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("minTypes");
-	m_minTypes.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save maxTypes
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("maxTypes");
-	m_maxTypes.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save parentClass
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("parentClass");
-	m_parentClass.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
+    // save resourceClassName
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("resourceClassName");
+    m_resourceClassName.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save numTypes
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("numTypes");
+    m_numTypes.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save minTypes
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("minTypes");
+    m_minTypes.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save maxTypes
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("maxTypes");
+    m_maxTypes.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save parentClass
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("parentClass");
+    m_parentClass.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
 
-	// write number of parameters
-	file.goToTopOfForm();
-	file.insertChunk(TAG(P, C, N, T));
-	file.insertChunkData(&paramCount, sizeof(paramCount));
-	file.exitChunk();
+    // write number of parameters
+    file.goToTopOfForm();
+    file.insertChunk(TAG(P, C, N, T));
+    file.insertChunkData(&paramCount, sizeof(paramCount));
+    file.exitChunk();
 
-	file.exitForm(true);
-	ServerUniverseObjectTemplate::save(file);
-	file.exitForm();
-	UNREF(count);
-}	// ServerResourceClassObjectTemplate::save
+    file.exitForm(true);
+    ServerUniverseObjectTemplate::save(file);
+    file.exitForm();
+    UNREF(count);
+}    // ServerResourceClassObjectTemplate::save
 
 //@END TFD

engine/shared/library/sharedTemplate/src/shared/template/ServerTangibleObjectTemplate.cpp

@@ -19,74 +19,67 @@
 #include "sharedTemplateDefinition/ObjectTemplate.h"
 #include <stdio.h>
 
+#include "sharedFoundation/CrcConstexpr.hpp"
 
 
 /**
  * Class constructor.
  */
-ServerTangibleObjectTemplate::ServerTangibleObjectTemplate(const std::string & filename)
+ServerTangibleObjectTemplate::ServerTangibleObjectTemplate(const std::string &filename)
 //@BEGIN TFD INIT
-	: ServerObjectTemplate(filename)
-	,m_triggerVolumesLoaded(false)
-	,m_triggerVolumesAppend(false)
+        : ServerObjectTemplate(filename), m_triggerVolumesLoaded(false), m_triggerVolumesAppend(false)
 //@END TFD INIT
 {
-}	// ServerTangibleObjectTemplate::ServerTangibleObjectTemplate
+}    // ServerTangibleObjectTemplate::ServerTangibleObjectTemplate
 
 /**
  * Class destructor.
  */
-ServerTangibleObjectTemplate::~ServerTangibleObjectTemplate()
-{
+ServerTangibleObjectTemplate::~ServerTangibleObjectTemplate() {
 //@BEGIN TFD CLEANUP
-	{
-		std::vector<TriggerVolumeParam *>::iterator iter;
-		for (iter = m_triggerVolumes.begin(); iter != m_triggerVolumes.end(); ++iter)
-		{
-			delete *iter;
-			*iter = nullptr;
-		}
-		m_triggerVolumes.clear();
-	}
+    {
+        std::vector<TriggerVolumeParam *>::iterator iter;
+        for (iter = m_triggerVolumes.begin(); iter != m_triggerVolumes.end(); ++iter) {
+            delete *iter;
+            *iter = nullptr;
+        }
+        m_triggerVolumes.clear();
+    }
 //@END TFD CLEANUP
-}	// ServerTangibleObjectTemplate::~ServerTangibleObjectTemplate
+}    // ServerTangibleObjectTemplate::~ServerTangibleObjectTemplate
 
 /**
  * Static function used to register this template.
  */
-void ServerTangibleObjectTemplate::registerMe(void)
-{
-	ObjectTemplateList::registerTemplate(ServerTangibleObjectTemplate_tag, create);
-}	// ServerTangibleObjectTemplate::registerMe
+void ServerTangibleObjectTemplate::registerMe(void) {
+    ObjectTemplateList::registerTemplate(ServerTangibleObjectTemplate_tag, create);
+}    // ServerTangibleObjectTemplate::registerMe
 
 /**
  * Creates a ServerTangibleObjectTemplate template.
  *
  * @return a new instance of the template
  */
-ObjectTemplate * ServerTangibleObjectTemplate::create(const std::string & filename)
-{
-	return new ServerTangibleObjectTemplate(filename);
-}	// ServerTangibleObjectTemplate::create
+ObjectTemplate *ServerTangibleObjectTemplate::create(const std::string &filename) {
+    return new ServerTangibleObjectTemplate(filename);
+}    // ServerTangibleObjectTemplate::create
 
 /**
  * Returns the template id.
  *
  * @return the template id
  */
-Tag ServerTangibleObjectTemplate::getId(void) const
-{
-	return ServerTangibleObjectTemplate_tag;
-}	// ServerTangibleObjectTemplate::getId
+Tag ServerTangibleObjectTemplate::getId(void) const {
+    return ServerTangibleObjectTemplate_tag;
+}    // ServerTangibleObjectTemplate::getId
 
 /**
  * Returns this template's version.
  *
  * @return the version
  */
-Tag ServerTangibleObjectTemplate::getTemplateVersion(void) const
-{
-	return m_templateVersion;
+Tag ServerTangibleObjectTemplate::getTemplateVersion(void) const {
+    return m_templateVersion;
 } // ServerTangibleObjectTemplate::getTemplateVersion
 
 /**
@@ -94,224 +87,189 @@ Tag ServerTangibleObjectTemplate::getTemplateVersion(void) const
  *
  * @return the highest version
  */
-Tag ServerTangibleObjectTemplate::getHighestTemplateVersion(void) const
-{
-	if (m_baseData == NULL)
-		return m_templateVersion;
-	const ServerTangibleObjectTemplate * base = dynamic_cast<const ServerTangibleObjectTemplate *>(m_baseData);
-	if (base == NULL)
-		return m_templateVersion;
-	return std::max(m_templateVersion, base->getHighestTemplateVersion());
+Tag ServerTangibleObjectTemplate::getHighestTemplateVersion(void) const {
+    if (m_baseData == NULL)
+        return m_templateVersion;
+    const ServerTangibleObjectTemplate *base = dynamic_cast<const ServerTangibleObjectTemplate *>(m_baseData);
+    if (base == NULL)
+        return m_templateVersion;
+    return std::max(m_templateVersion, base->getHighestTemplateVersion());
 } // ServerTangibleObjectTemplate::getHighestTemplateVersion
 
 //@BEGIN TFD
-CompilerIntegerParam * ServerTangibleObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "combatSkeleton") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_combatSkeleton;
-		}
-		fprintf(stderr, "trying to access single-parameter \"combatSkeleton\" as an array\n");
-	}
-	else if (strcmp(name, "maxHitPoints") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_maxHitPoints;
-		}
-		fprintf(stderr, "trying to access single-parameter \"maxHitPoints\" as an array\n");
-	}
-	else if (strcmp(name, "interestRadius") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_interestRadius;
-		}
-		fprintf(stderr, "trying to access single-parameter \"interestRadius\" as an array\n");
-	}
-	else if (strcmp(name, "count") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_count;
-		}
-		fprintf(stderr, "trying to access single-parameter \"count\" as an array\n");
-	}
-	else if (strcmp(name, "condition") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_condition;
-		}
-		fprintf(stderr, "trying to access single-parameter \"condition\" as an array\n");
-	}
-	else
-		return ServerObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerTangibleObjectTemplate::getCompilerIntegerParam
+CompilerIntegerParam *
+ServerTangibleObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index) {
+    switch (runtimeCrc(name)) {
+        case constcrc("combatSkeleton"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_combatSkeleton;
+            }
+            fprintf(stderr, "trying to access single-parameter \"combatSkeleton\" as an array\n");
+        }
+            break;
+        case constcrc("maxHitPoints"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_maxHitPoints;
+            }
+            fprintf(stderr, "trying to access single-parameter \"maxHitPoints\" as an array\n");
+        }
+            break;
+        case constcrc("interestRadius"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_interestRadius;
+            }
+            fprintf(stderr, "trying to access single-parameter \"interestRadius\" as an array\n");
+        }
+            break;
+        case constcrc("count"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_count;
+            }
+            fprintf(stderr, "trying to access single-parameter \"count\" as an array\n");
+        }
+            break;
+        case constcrc("condition"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getCompilerIntegerParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_condition;
+            }
+            fprintf(stderr, "trying to access single-parameter \"condition\" as an array\n");
+        }
+            break;
+        default:
+            return ServerObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
+            break;
+    }
+    return nullptr;
+}    //ServerTangibleObjectTemplate::getCompilerIntegerParam
 
-FloatParam * ServerTangibleObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index)
-{
-	return ServerObjectTemplate::getFloatParam(name, deepCheck, index);
-}	//ServerTangibleObjectTemplate::getFloatParam
+FloatParam *ServerTangibleObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index) {
+    return ServerObjectTemplate::getFloatParam(name, deepCheck, index);
+}    //ServerTangibleObjectTemplate::getFloatParam
 
-BoolParam * ServerTangibleObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "wantSawAttackTriggers") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getBoolParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_wantSawAttackTriggers;
-		}
-		fprintf(stderr, "trying to access single-parameter \"wantSawAttackTriggers\" as an array\n");
-	}
-	else
-		return ServerObjectTemplate::getBoolParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerTangibleObjectTemplate::getBoolParam
+BoolParam *ServerTangibleObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index) {
+    if (strcmp(name, "wantSawAttackTriggers") == 0) {
+        if (index == 0) {
+            if (deepCheck && !isParamLoaded(name, false, 0)) {
+                if (getBaseTemplate() != nullptr)
+                    return getBaseTemplate()->getBoolParam(name, deepCheck, index);
+                return nullptr;
+            }
+            return &m_wantSawAttackTriggers;
+        }
+        fprintf(stderr, "trying to access single-parameter \"wantSawAttackTriggers\" as an array\n");
+    } else
+        return ServerObjectTemplate::getBoolParam(name, deepCheck, index);
+    return nullptr;
+}    //ServerTangibleObjectTemplate::getBoolParam
 
-StringParam * ServerTangibleObjectTemplate::getStringParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "armor") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getStringParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_armor;
-		}
-		fprintf(stderr, "trying to access single-parameter \"armor\" as an array\n");
-	}
-	else
-		return ServerObjectTemplate::getStringParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerTangibleObjectTemplate::getStringParam
+StringParam *ServerTangibleObjectTemplate::getStringParam(const char *name, bool deepCheck, int index) {
+    if (strcmp(name, "armor") == 0) {
+        if (index == 0) {
+            if (deepCheck && !isParamLoaded(name, false, 0)) {
+                if (getBaseTemplate() != nullptr)
+                    return getBaseTemplate()->getStringParam(name, deepCheck, index);
+                return nullptr;
+            }
+            return &m_armor;
+        }
+        fprintf(stderr, "trying to access single-parameter \"armor\" as an array\n");
+    } else
+        return ServerObjectTemplate::getStringParam(name, deepCheck, index);
+    return nullptr;
+}    //ServerTangibleObjectTemplate::getStringParam
 
-StringIdParam * ServerTangibleObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index)
-{
-	return ServerObjectTemplate::getStringIdParam(name, deepCheck, index);
-}	//ServerTangibleObjectTemplate::getStringIdParam
+StringIdParam *ServerTangibleObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index) {
+    return ServerObjectTemplate::getStringIdParam(name, deepCheck, index);
+}    //ServerTangibleObjectTemplate::getStringIdParam
 
-VectorParam * ServerTangibleObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index)
-{
-	return ServerObjectTemplate::getVectorParam(name, deepCheck, index);
-}	//ServerTangibleObjectTemplate::getVectorParam
+VectorParam *ServerTangibleObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index) {
+    return ServerObjectTemplate::getVectorParam(name, deepCheck, index);
+}    //ServerTangibleObjectTemplate::getVectorParam
 
-DynamicVariableParam * ServerTangibleObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index)
-{
-	return ServerObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
-}	//ServerTangibleObjectTemplate::getDynamicVariableParam
+DynamicVariableParam *
+ServerTangibleObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index) {
+    return ServerObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
+}    //ServerTangibleObjectTemplate::getDynamicVariableParam
 
-StructParamOT * ServerTangibleObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index)
-{
-	return ServerObjectTemplate::getStructParamOT(name, deepCheck, index);
-}	//ServerTangibleObjectTemplate::getStructParamOT
+StructParamOT *ServerTangibleObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index) {
+    return ServerObjectTemplate::getStructParamOT(name, deepCheck, index);
+}    //ServerTangibleObjectTemplate::getStructParamOT
 
-TriggerVolumeParam * ServerTangibleObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "triggerVolumes") == 0)
-	{
-		if (index >= 0 && index < static_cast<int>(m_triggerVolumes.size()))
-			return m_triggerVolumes[index];
-		if (index == static_cast<int>(m_triggerVolumes.size()))
-		{
-			TriggerVolumeParam *temp = new TriggerVolumeParam();
-			m_triggerVolumes.push_back(temp);
-			return temp;
-		}
-		fprintf(stderr, "index for parameter \"triggerVolumes\" out of bounds\n");
-	}
-	else
-		return ServerObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerTangibleObjectTemplate::getTriggerVolumeParam
+TriggerVolumeParam *ServerTangibleObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index) {
+    if (strcmp(name, "triggerVolumes") == 0) {
+        if (index >= 0 && index < static_cast<int>(m_triggerVolumes.size()))
+            return m_triggerVolumes[index];
+        if (index == static_cast<int>(m_triggerVolumes.size())) {
+            TriggerVolumeParam *temp = new TriggerVolumeParam();
+            m_triggerVolumes.push_back(temp);
+            return temp;
+        }
+        fprintf(stderr, "index for parameter \"triggerVolumes\" out of bounds\n");
+    } else
+        return ServerObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
+    return nullptr;
+}    //ServerTangibleObjectTemplate::getTriggerVolumeParam
 
-void ServerTangibleObjectTemplate::initStructParamOT(StructParamOT &param, const char *name)
-{
-	if (param.isInitialized())
-		return;
-	ServerObjectTemplate::initStructParamOT(param, name);
-}	// ServerTangibleObjectTemplate::initStructParamOT
+void ServerTangibleObjectTemplate::initStructParamOT(StructParamOT &param, const char *name) {
+    if (param.isInitialized())
+        return;
+    ServerObjectTemplate::initStructParamOT(param, name);
+}    // ServerTangibleObjectTemplate::initStructParamOT
 
-void ServerTangibleObjectTemplate::setAsEmptyList(const char *name)
-{
-	if (strcmp(name, "triggerVolumes") == 0)
-	{
-		m_triggerVolumes.clear();
-		m_triggerVolumesLoaded = true;
-	}
-	else
-		ServerObjectTemplate::setAsEmptyList(name);
-}	// ServerTangibleObjectTemplate::setAsEmptyList
+void ServerTangibleObjectTemplate::setAsEmptyList(const char *name) {
+    if (strcmp(name, "triggerVolumes") == 0) {
+        m_triggerVolumes.clear();
+        m_triggerVolumesLoaded = true;
+    } else
+        ServerObjectTemplate::setAsEmptyList(name);
+}    // ServerTangibleObjectTemplate::setAsEmptyList
 
-void ServerTangibleObjectTemplate::setAppend(const char *name)
-{
-	if (strcmp(name, "triggerVolumes") == 0)
-		m_triggerVolumesAppend = true;
-	else
-		ServerObjectTemplate::setAppend(name);
-}	// ServerTangibleObjectTemplate::setAppend
+void ServerTangibleObjectTemplate::setAppend(const char *name) {
+    if (strcmp(name, "triggerVolumes") == 0)
+        m_triggerVolumesAppend = true;
+    else
+        ServerObjectTemplate::setAppend(name);
+}    // ServerTangibleObjectTemplate::setAppend
 
-bool ServerTangibleObjectTemplate::isAppend(const char *name) const
-{
-	if (strcmp(name, "triggerVolumes") == 0)
-		return m_triggerVolumesAppend;
-	else
-		return ServerObjectTemplate::isAppend(name);
-}	// ServerTangibleObjectTemplate::isAppend
+bool ServerTangibleObjectTemplate::isAppend(const char *name) const {
+    if (strcmp(name, "triggerVolumes") == 0)
+        return m_triggerVolumesAppend;
+    else
+        return ServerObjectTemplate::isAppend(name);
+}    // ServerTangibleObjectTemplate::isAppend
 
 
-int ServerTangibleObjectTemplate::getListLength(const char *name) const
-{
-	if (strcmp(name, "triggerVolumes") == 0)
-	{
-		return m_triggerVolumes.size();
-	}
-	else
-		return ServerObjectTemplate::getListLength(name);
-}	// ServerTangibleObjectTemplate::getListLength
+int ServerTangibleObjectTemplate::getListLength(const char *name) const {
+    if (strcmp(name, "triggerVolumes") == 0) {
+        return m_triggerVolumes.size();
+    } else
+        return ServerObjectTemplate::getListLength(name);
+}    // ServerTangibleObjectTemplate::getListLength
 
 /**
  * Loads the template data from an iff file. We should already be in the form
@@ -319,95 +277,97 @@ int ServerTangibleObjectTemplate::getListLength(const char *name) const
  *
  * @param file		file to load from
  */
-void ServerTangibleObjectTemplate::load(Iff &file)
-{
-static const int MAX_NAME_SIZE = 256;
-char paramName[MAX_NAME_SIZE];
+void ServerTangibleObjectTemplate::load(Iff &file) {
+    static const int MAX_NAME_SIZE = 256;
+    char paramName[MAX_NAME_SIZE];
 
-	if (file.getCurrentName() != ServerTangibleObjectTemplate_tag)
-	{
-		ServerObjectTemplate::load(file);
-		return;
-	}
+    if (file.getCurrentName() != ServerTangibleObjectTemplate_tag) {
+        ServerObjectTemplate::load(file);
+        return;
+    }
 
-	file.enterForm();
-	m_templateVersion = file.getCurrentName();
-	if (m_templateVersion == TAG(D,E,R,V))
-	{
-		file.enterForm();
-		file.enterChunk();
-		std::string baseFilename;
-		file.read_string(baseFilename);
-		file.exitChunk();
-		const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
-		DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
-		if (m_baseData == base && base != nullptr)
-			base->releaseReference();
-		else
-		{
-			if (m_baseData != nullptr)
-				m_baseData->releaseReference();
-			m_baseData = base;
-		}
-		file.exitForm();
-		m_templateVersion = file.getCurrentName();
-	}
-	if (getHighestTemplateVersion() != TAG(0,0,0,4))
-	{
-		if (DataLint::isEnabled())
-			DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
-	}
+    file.enterForm();
+    m_templateVersion = file.getCurrentName();
+    if (m_templateVersion == TAG(D, E, R, V)) {
+        file.enterForm();
+        file.enterChunk();
+        std::string baseFilename;
+        file.read_string(baseFilename);
+        file.exitChunk();
+        const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
+        DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
+        if (m_baseData == base && base != nullptr)
+            base->releaseReference();
+        else {
+            if (m_baseData != nullptr)
+                m_baseData->releaseReference();
+            m_baseData = base;
+        }
+        file.exitForm();
+        m_templateVersion = file.getCurrentName();
+    }
+    if (getHighestTemplateVersion() != TAG(0, 0, 0, 4)) {
+        if (DataLint::isEnabled())
+            DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
+    }
 
-	file.enterForm();
+    file.enterForm();
 
-	file.enterChunk();
-	int paramCount = file.read_int32();
-	file.exitChunk();
-	for (int i = 0; i < paramCount; ++i)
-	{
-		file.enterChunk();
-		file.read_string(paramName, MAX_NAME_SIZE);
-		if (strcmp(paramName, "triggerVolumes") == 0)
-		{
-			std::vector<TriggerVolumeParam *>::iterator iter;
-			for (iter = m_triggerVolumes.begin(); iter != m_triggerVolumes.end(); ++iter)
-			{
-				delete *iter;
-				*iter = nullptr;
-			}
-			m_triggerVolumes.clear();
-			m_triggerVolumesAppend = file.read_bool8();
-			int listCount = file.read_int32();
-			for (int j = 0; j < listCount; ++j)
-			{
-				TriggerVolumeParam * newData = new TriggerVolumeParam;
-				newData->loadFromIff(file);
-				m_triggerVolumes.push_back(newData);
-			}
-			m_triggerVolumesLoaded = true;
-		}
-		else if (strcmp(paramName, "combatSkeleton") == 0)
-			m_combatSkeleton.loadFromIff(file);
-		else if (strcmp(paramName, "maxHitPoints") == 0)
-			m_maxHitPoints.loadFromIff(file);
-		else if (strcmp(paramName, "armor") == 0)
-			m_armor.loadFromIff(file);
-		else if (strcmp(paramName, "interestRadius") == 0)
-			m_interestRadius.loadFromIff(file);
-		else if (strcmp(paramName, "count") == 0)
-			m_count.loadFromIff(file);
-		else if (strcmp(paramName, "condition") == 0)
-			m_condition.loadFromIff(file);
-		else if (strcmp(paramName, "wantSawAttackTriggers") == 0)
-			m_wantSawAttackTriggers.loadFromIff(file);
-		file.exitChunk(true);
-	}
+    file.enterChunk();
+    int paramCount = file.read_int32();
+    file.exitChunk();
+    for (int i = 0; i < paramCount; ++i) {
+        file.enterChunk();
+        file.read_string(paramName, MAX_NAME_SIZE);
 
-	file.exitForm();
-	ServerObjectTemplate::load(file);
-	file.exitForm();
-	return;
-}	// ServerTangibleObjectTemplate::load
+        switch (runtimeCrc(paramName)) {
+            case constcrc("triggerVolumes"): {
+                std::vector<TriggerVolumeParam *>::iterator iter;
+                for (iter = m_triggerVolumes.begin(); iter != m_triggerVolumes.end(); ++iter) {
+                    delete *iter;
+                    *iter = nullptr;
+                }
+                m_triggerVolumes.clear();
+                m_triggerVolumesAppend = file.read_bool8();
+                int listCount = file.read_int32();
+                for (int j = 0; j < listCount; ++j) {
+                    TriggerVolumeParam *newData = new TriggerVolumeParam;
+                    newData->loadFromIff(file);
+                    m_triggerVolumes.push_back(newData);
+                }
+                m_triggerVolumesLoaded = true;
+            }
+                break;
+            case constcrc("combatSkeleton"):
+                m_combatSkeleton.loadFromIff(file);
+                break;
+            case constcrc("maxHitPoints"):
+                m_maxHitPoints.loadFromIff(file);
+                break;
+            case constcrc("armor"):
+                m_armor.loadFromIff(file);
+                break;
+            case constcrc("interestRadius"):
+                m_interestRadius.loadFromIff(file);
+                break;
+            case constcrc("count"):
+                m_count.loadFromIff(file);
+                break;
+            case constcrc("condition"):
+                m_condition.loadFromIff(file);
+                break;
+            case constcrc("wantSawAttackTriggers"):
+                m_wantSawAttackTriggers.loadFromIff(file);
+                break;
+        }
+        file.exitChunk(true);
+    }
+
+    file.exitForm();
+    ServerObjectTemplate::load(file);
+    file.exitForm();
+    return;
+}    // ServerTangibleObjectTemplate::load
 
 /**
  * Saves the template data to an iff file.
@@ -415,91 +375,90 @@ char paramName[MAX_NAME_SIZE];
  * @param file			file to save to
  * @param location		file type (client or server)
  */
-void ServerTangibleObjectTemplate::save(Iff &file)
-{
-int count;
+void ServerTangibleObjectTemplate::save(Iff &file) {
+    int count;
 
-	file.insertForm(ServerTangibleObjectTemplate_tag);
-	if (m_baseTemplateName.size() != 0)
-	{
-		file.insertForm(TAG(D,E,R,V));
-		file.insertChunk(TAG(X, X, X, X));
-		file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
-		file.exitChunk();
-		file.exitForm();
-	}
-	file.insertForm(TAG(0,0,0,4));
-	file.allowNonlinearFunctions();
+    file.insertForm(ServerTangibleObjectTemplate_tag);
+    if (m_baseTemplateName.size() != 0) {
+        file.insertForm(TAG(D, E, R, V));
+        file.insertChunk(TAG(X, X, X, X));
+        file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
+        file.exitChunk();
+        file.exitForm();
+    }
+    file.insertForm(TAG(0, 0, 0, 4));
+    file.allowNonlinearFunctions();
 
-	int paramCount = 0;
+    int paramCount = 0;
 
-	if (!m_triggerVolumesLoaded)
-	{
-		// mark the list as empty and extending the base list
-		m_triggerVolumesAppend = true;
-	}
-	// save triggerVolumes
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("triggerVolumes");
-	file.insertChunkData(&m_triggerVolumesAppend, sizeof(bool));
-	count = m_triggerVolumes.size();
-	file.insertChunkData(&count, sizeof(count));
-	{for (int i = 0; i < count; ++i)
-		m_triggerVolumes[i]->saveToIff(file);}
-	file.exitChunk();
-	++paramCount;
-	// save combatSkeleton
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("combatSkeleton");
-	m_combatSkeleton.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save maxHitPoints
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("maxHitPoints");
-	m_maxHitPoints.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save armor
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("armor");
-	m_armor.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save interestRadius
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("interestRadius");
-	m_interestRadius.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save count
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("count");
-	m_count.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save condition
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("condition");
-	m_condition.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save wantSawAttackTriggers
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("wantSawAttackTriggers");
-	m_wantSawAttackTriggers.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
+    if (!m_triggerVolumesLoaded) {
+        // mark the list as empty and extending the base list
+        m_triggerVolumesAppend = true;
+    }
+    // save triggerVolumes
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("triggerVolumes");
+    file.insertChunkData(&m_triggerVolumesAppend, sizeof(bool));
+    count = m_triggerVolumes.size();
+    file.insertChunkData(&count, sizeof(count));
+    {
+        for (int i = 0; i < count; ++i)
+            m_triggerVolumes[i]->saveToIff(file);
+    }
+    file.exitChunk();
+    ++paramCount;
+    // save combatSkeleton
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("combatSkeleton");
+    m_combatSkeleton.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save maxHitPoints
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("maxHitPoints");
+    m_maxHitPoints.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save armor
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("armor");
+    m_armor.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save interestRadius
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("interestRadius");
+    m_interestRadius.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save count
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("count");
+    m_count.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save condition
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("condition");
+    m_condition.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save wantSawAttackTriggers
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("wantSawAttackTriggers");
+    m_wantSawAttackTriggers.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
 
-	// write number of parameters
-	file.goToTopOfForm();
-	file.insertChunk(TAG(P, C, N, T));
-	file.insertChunkData(&paramCount, sizeof(paramCount));
-	file.exitChunk();
+    // write number of parameters
+    file.goToTopOfForm();
+    file.insertChunk(TAG(P, C, N, T));
+    file.insertChunkData(&paramCount, sizeof(paramCount));
+    file.exitChunk();
 
-	file.exitForm(true);
-	ServerObjectTemplate::save(file);
-	file.exitForm();
-}	// ServerTangibleObjectTemplate::save
+    file.exitForm(true);
+    ServerObjectTemplate::save(file);
+    file.exitForm();
+}    // ServerTangibleObjectTemplate::save
 
 //@END TFD

engine/shared/library/sharedTemplate/src/shared/template/ServerVehicleObjectTemplate.cpp

@@ -19,63 +19,59 @@
 #include "sharedTemplateDefinition/ObjectTemplate.h"
 #include <stdio.h>
 
+#include "sharedFoundation/CrcConstexpr.hpp"
 
 
 /**
  * Class constructor.
  */
-ServerVehicleObjectTemplate::ServerVehicleObjectTemplate(const std::string & filename)
+ServerVehicleObjectTemplate::ServerVehicleObjectTemplate(const std::string &filename)
 //@BEGIN TFD INIT
-	: ServerTangibleObjectTemplate(filename)
+        : ServerTangibleObjectTemplate(filename)
 //@END TFD INIT
 {
-}	// ServerVehicleObjectTemplate::ServerVehicleObjectTemplate
+}    // ServerVehicleObjectTemplate::ServerVehicleObjectTemplate
 
 /**
  * Class destructor.
  */
-ServerVehicleObjectTemplate::~ServerVehicleObjectTemplate()
-{
+ServerVehicleObjectTemplate::~ServerVehicleObjectTemplate() {
 //@BEGIN TFD CLEANUP
 //@END TFD CLEANUP
-}	// ServerVehicleObjectTemplate::~ServerVehicleObjectTemplate
+}    // ServerVehicleObjectTemplate::~ServerVehicleObjectTemplate
 
 /**
  * Static function used to register this template.
  */
-void ServerVehicleObjectTemplate::registerMe(void)
-{
-	ObjectTemplateList::registerTemplate(ServerVehicleObjectTemplate_tag, create);
-}	// ServerVehicleObjectTemplate::registerMe
+void ServerVehicleObjectTemplate::registerMe(void) {
+    ObjectTemplateList::registerTemplate(ServerVehicleObjectTemplate_tag, create);
+}    // ServerVehicleObjectTemplate::registerMe
 
 /**
  * Creates a ServerVehicleObjectTemplate template.
  *
  * @return a new instance of the template
  */
-ObjectTemplate * ServerVehicleObjectTemplate::create(const std::string & filename)
-{
-	return new ServerVehicleObjectTemplate(filename);
-}	// ServerVehicleObjectTemplate::create
+ObjectTemplate *ServerVehicleObjectTemplate::create(const std::string &filename) {
+    return new ServerVehicleObjectTemplate(filename);
+}    // ServerVehicleObjectTemplate::create
 
 /**
  * Returns the template id.
  *
  * @return the template id
  */
-Tag ServerVehicleObjectTemplate::getId(void) const
-{
-	return ServerVehicleObjectTemplate_tag;
-}	// ServerVehicleObjectTemplate::getId
+Tag ServerVehicleObjectTemplate::getId(void) const {
+    return ServerVehicleObjectTemplate_tag;
+}    // ServerVehicleObjectTemplate::getId
 
 /**
  * Returns this template's version.
  *
  * @return the version
  */
-Tag ServerVehicleObjectTemplate::getTemplateVersion(void) const
-{
-	return m_templateVersion;
+Tag ServerVehicleObjectTemplate::getTemplateVersion(void) const {
+    return m_templateVersion;
 } // ServerVehicleObjectTemplate::getTemplateVersion
 
 /**
@@ -83,149 +79,129 @@ Tag ServerVehicleObjectTemplate::getTemplateVersion(void) const
  *
  * @return the highest version
  */
-Tag ServerVehicleObjectTemplate::getHighestTemplateVersion(void) const
-{
-	if (m_baseData == NULL)
-		return m_templateVersion;
-	const ServerVehicleObjectTemplate * base = dynamic_cast<const ServerVehicleObjectTemplate *>(m_baseData);
-	if (base == NULL)
-		return m_templateVersion;
-	return std::max(m_templateVersion, base->getHighestTemplateVersion());
+Tag ServerVehicleObjectTemplate::getHighestTemplateVersion(void) const {
+    if (m_baseData == NULL)
+        return m_templateVersion;
+    const ServerVehicleObjectTemplate *base = dynamic_cast<const ServerVehicleObjectTemplate *>(m_baseData);
+    if (base == NULL)
+        return m_templateVersion;
+    return std::max(m_templateVersion, base->getHighestTemplateVersion());
 } // ServerVehicleObjectTemplate::getHighestTemplateVersion
 
 //@BEGIN TFD
-CompilerIntegerParam * ServerVehicleObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
-}	//ServerVehicleObjectTemplate::getCompilerIntegerParam
+CompilerIntegerParam *
+ServerVehicleObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
+}    //ServerVehicleObjectTemplate::getCompilerIntegerParam
 
-FloatParam * ServerVehicleObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "currentFuel") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_currentFuel;
-		}
-		fprintf(stderr, "trying to access single-parameter \"currentFuel\" as an array\n");
-	}
-	else if (strcmp(name, "maxFuel") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_maxFuel;
-		}
-		fprintf(stderr, "trying to access single-parameter \"maxFuel\" as an array\n");
-	}
-	else if (strcmp(name, "consumpsion") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_consumpsion;
-		}
-		fprintf(stderr, "trying to access single-parameter \"consumpsion\" as an array\n");
-	}
-	else
-		return ServerTangibleObjectTemplate::getFloatParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerVehicleObjectTemplate::getFloatParam
+FloatParam *ServerVehicleObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index) {
+    switch (runtimeCrc(name)) {
+        case constcrc("currentFuel"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_currentFuel;
+            }
+            fprintf(stderr, "trying to access single-parameter \"currentFuel\" as an array\n");
+        }
+            break;
+        case constcrc("maxFuel"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_maxFuel;
+            }
+            fprintf(stderr, "trying to access single-parameter \"maxFuel\" as an array\n");
+        }
+            break;
+        case constcrc("consumpsion"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_consumpsion;
+            }
+            fprintf(stderr, "trying to access single-parameter \"consumpsion\" as an array\n");
+        }
+            break;
+        default:
+            return ServerTangibleObjectTemplate::getFloatParam(name, deepCheck, index);
+            break;
+    }
+    return nullptr;
+}    //ServerVehicleObjectTemplate::getFloatParam
 
-BoolParam * ServerVehicleObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getBoolParam(name, deepCheck, index);
-}	//ServerVehicleObjectTemplate::getBoolParam
+BoolParam *ServerVehicleObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getBoolParam(name, deepCheck, index);
+}    //ServerVehicleObjectTemplate::getBoolParam
 
-StringParam * ServerVehicleObjectTemplate::getStringParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "fuelType") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getStringParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_fuelType;
-		}
-		fprintf(stderr, "trying to access single-parameter \"fuelType\" as an array\n");
-	}
-	else
-		return ServerTangibleObjectTemplate::getStringParam(name, deepCheck, index);
-	return nullptr;
-}	//ServerVehicleObjectTemplate::getStringParam
+StringParam *ServerVehicleObjectTemplate::getStringParam(const char *name, bool deepCheck, int index) {
+    if (strcmp(name, "fuelType") == 0) {
+        if (index == 0) {
+            if (deepCheck && !isParamLoaded(name, false, 0)) {
+                if (getBaseTemplate() != nullptr)
+                    return getBaseTemplate()->getStringParam(name, deepCheck, index);
+                return nullptr;
+            }
+            return &m_fuelType;
+        }
+        fprintf(stderr, "trying to access single-parameter \"fuelType\" as an array\n");
+    } else
+        return ServerTangibleObjectTemplate::getStringParam(name, deepCheck, index);
+    return nullptr;
+}    //ServerVehicleObjectTemplate::getStringParam
 
-StringIdParam * ServerVehicleObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getStringIdParam(name, deepCheck, index);
-}	//ServerVehicleObjectTemplate::getStringIdParam
+StringIdParam *ServerVehicleObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getStringIdParam(name, deepCheck, index);
+}    //ServerVehicleObjectTemplate::getStringIdParam
 
-VectorParam * ServerVehicleObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getVectorParam(name, deepCheck, index);
-}	//ServerVehicleObjectTemplate::getVectorParam
+VectorParam *ServerVehicleObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getVectorParam(name, deepCheck, index);
+}    //ServerVehicleObjectTemplate::getVectorParam
 
-DynamicVariableParam * ServerVehicleObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
-}	//ServerVehicleObjectTemplate::getDynamicVariableParam
+DynamicVariableParam *
+ServerVehicleObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
+}    //ServerVehicleObjectTemplate::getDynamicVariableParam
 
-StructParamOT * ServerVehicleObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getStructParamOT(name, deepCheck, index);
-}	//ServerVehicleObjectTemplate::getStructParamOT
+StructParamOT *ServerVehicleObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getStructParamOT(name, deepCheck, index);
+}    //ServerVehicleObjectTemplate::getStructParamOT
 
-TriggerVolumeParam * ServerVehicleObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index)
-{
-	return ServerTangibleObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
-}	//ServerVehicleObjectTemplate::getTriggerVolumeParam
+TriggerVolumeParam *ServerVehicleObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index) {
+    return ServerTangibleObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
+}    //ServerVehicleObjectTemplate::getTriggerVolumeParam
 
-void ServerVehicleObjectTemplate::initStructParamOT(StructParamOT &param, const char *name)
-{
-	if (param.isInitialized())
-		return;
-	ServerTangibleObjectTemplate::initStructParamOT(param, name);
-}	// ServerVehicleObjectTemplate::initStructParamOT
+void ServerVehicleObjectTemplate::initStructParamOT(StructParamOT &param, const char *name) {
+    if (param.isInitialized())
+        return;
+    ServerTangibleObjectTemplate::initStructParamOT(param, name);
+}    // ServerVehicleObjectTemplate::initStructParamOT
 
-void ServerVehicleObjectTemplate::setAsEmptyList(const char *name)
-{
-	ServerTangibleObjectTemplate::setAsEmptyList(name);
-}	// ServerVehicleObjectTemplate::setAsEmptyList
+void ServerVehicleObjectTemplate::setAsEmptyList(const char *name) {
+    ServerTangibleObjectTemplate::setAsEmptyList(name);
+}    // ServerVehicleObjectTemplate::setAsEmptyList
 
-void ServerVehicleObjectTemplate::setAppend(const char *name)
-{
-	ServerTangibleObjectTemplate::setAppend(name);
-}	// ServerVehicleObjectTemplate::setAppend
+void ServerVehicleObjectTemplate::setAppend(const char *name) {
+    ServerTangibleObjectTemplate::setAppend(name);
+}    // ServerVehicleObjectTemplate::setAppend
 
-bool ServerVehicleObjectTemplate::isAppend(const char *name) const
-{
-	return ServerTangibleObjectTemplate::isAppend(name);
-}	// ServerVehicleObjectTemplate::isAppend
+bool ServerVehicleObjectTemplate::isAppend(const char *name) const {
+    return ServerTangibleObjectTemplate::isAppend(name);
+}    // ServerVehicleObjectTemplate::isAppend
 
 
-int ServerVehicleObjectTemplate::getListLength(const char *name) const
-{
-	return ServerTangibleObjectTemplate::getListLength(name);
-}	// ServerVehicleObjectTemplate::getListLength
+int ServerVehicleObjectTemplate::getListLength(const char *name) const {
+    return ServerTangibleObjectTemplate::getListLength(name);
+}    // ServerVehicleObjectTemplate::getListLength
 
 /**
  * Loads the template data from an iff file. We should already be in the form
@@ -233,70 +209,71 @@ int ServerVehicleObjectTemplate::getListLength(const char *name) const
  *
  * @param file		file to load from
  */
-void ServerVehicleObjectTemplate::load(Iff &file)
-{
-static const int MAX_NAME_SIZE = 256;
-char paramName[MAX_NAME_SIZE];
+void ServerVehicleObjectTemplate::load(Iff &file) {
+    static const int MAX_NAME_SIZE = 256;
+    char paramName[MAX_NAME_SIZE];
 
-	if (file.getCurrentName() != ServerVehicleObjectTemplate_tag)
-	{
-		ServerTangibleObjectTemplate::load(file);
-		return;
-	}
+    if (file.getCurrentName() != ServerVehicleObjectTemplate_tag) {
+        ServerTangibleObjectTemplate::load(file);
+        return;
+    }
 
-	file.enterForm();
-	m_templateVersion = file.getCurrentName();
-	if (m_templateVersion == TAG(D,E,R,V))
-	{
-		file.enterForm();
-		file.enterChunk();
-		std::string baseFilename;
-		file.read_string(baseFilename);
-		file.exitChunk();
-		const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
-		DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
-		if (m_baseData == base && base != nullptr)
-			base->releaseReference();
-		else
-		{
-			if (m_baseData != nullptr)
-				m_baseData->releaseReference();
-			m_baseData = base;
-		}
-		file.exitForm();
-		m_templateVersion = file.getCurrentName();
-	}
-	if (getHighestTemplateVersion() != TAG(0,0,0,0))
-	{
-		if (DataLint::isEnabled())
-			DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
-	}
+    file.enterForm();
+    m_templateVersion = file.getCurrentName();
+    if (m_templateVersion == TAG(D, E, R, V)) {
+        file.enterForm();
+        file.enterChunk();
+        std::string baseFilename;
+        file.read_string(baseFilename);
+        file.exitChunk();
+        const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
+        DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
+        if (m_baseData == base && base != nullptr)
+            base->releaseReference();
+        else {
+            if (m_baseData != nullptr)
+                m_baseData->releaseReference();
+            m_baseData = base;
+        }
+        file.exitForm();
+        m_templateVersion = file.getCurrentName();
+    }
+    if (getHighestTemplateVersion() != TAG(0, 0, 0, 0)) {
+        if (DataLint::isEnabled())
+            DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
+    }
 
-	file.enterForm();
+    file.enterForm();
 
-	file.enterChunk();
-	int paramCount = file.read_int32();
-	file.exitChunk();
-	for (int i = 0; i < paramCount; ++i)
-	{
-		file.enterChunk();
-		file.read_string(paramName, MAX_NAME_SIZE);
-		if (strcmp(paramName, "fuelType") == 0)
-			m_fuelType.loadFromIff(file);
-		else if (strcmp(paramName, "currentFuel") == 0)
-			m_currentFuel.loadFromIff(file);
-		else if (strcmp(paramName, "maxFuel") == 0)
-			m_maxFuel.loadFromIff(file);
-		else if (strcmp(paramName, "consumpsion") == 0)
-			m_consumpsion.loadFromIff(file);
-		file.exitChunk(true);
-	}
+    file.enterChunk();
+    int paramCount = file.read_int32();
+    file.exitChunk();
+    for (int i = 0; i < paramCount; ++i) {
+        file.enterChunk();
+        file.read_string(paramName, MAX_NAME_SIZE);
 
-	file.exitForm();
-	ServerTangibleObjectTemplate::load(file);
-	file.exitForm();
-	return;
-}	// ServerVehicleObjectTemplate::load
+        switch (runtimeCrc(paramName)) {
+            case constcrc("fuelType"):
+                m_fuelType.loadFromIff(file);
+                break;
+            case constcrc("currentFuel"):
+                m_currentFuel.loadFromIff(file);
+                break;
+            case constcrc("maxFuel"):
+                m_maxFuel.loadFromIff(file);
+                break;
+            case constcrc("consumpsion"):
+                m_consumpsion.loadFromIff(file);
+                break;
+        }
+        file.exitChunk(true);
+    }
+
+    file.exitForm();
+    ServerTangibleObjectTemplate::load(file);
+    file.exitForm();
+    return;
+}    // ServerVehicleObjectTemplate::load
 
 /**
  * Saves the template data to an iff file.
@@ -304,59 +281,57 @@ char paramName[MAX_NAME_SIZE];
  * @param file			file to save to
  * @param location		file type (client or server)
  */
-void ServerVehicleObjectTemplate::save(Iff &file)
-{
-int count;
+void ServerVehicleObjectTemplate::save(Iff &file) {
+    int count;
 
-	file.insertForm(ServerVehicleObjectTemplate_tag);
-	if (m_baseTemplateName.size() != 0)
-	{
-		file.insertForm(TAG(D,E,R,V));
-		file.insertChunk(TAG(X, X, X, X));
-		file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
-		file.exitChunk();
-		file.exitForm();
-	}
-	file.insertForm(TAG(0,0,0,0));
-	file.allowNonlinearFunctions();
+    file.insertForm(ServerVehicleObjectTemplate_tag);
+    if (m_baseTemplateName.size() != 0) {
+        file.insertForm(TAG(D, E, R, V));
+        file.insertChunk(TAG(X, X, X, X));
+        file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
+        file.exitChunk();
+        file.exitForm();
+    }
+    file.insertForm(TAG(0, 0, 0, 0));
+    file.allowNonlinearFunctions();
 
-	int paramCount = 0;
+    int paramCount = 0;
 
-	// save fuelType
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("fuelType");
-	m_fuelType.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save currentFuel
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("currentFuel");
-	m_currentFuel.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save maxFuel
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("maxFuel");
-	m_maxFuel.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save consumpsion
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("consumpsion");
-	m_consumpsion.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
+    // save fuelType
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("fuelType");
+    m_fuelType.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save currentFuel
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("currentFuel");
+    m_currentFuel.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save maxFuel
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("maxFuel");
+    m_maxFuel.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save consumpsion
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("consumpsion");
+    m_consumpsion.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
 
-	// write number of parameters
-	file.goToTopOfForm();
-	file.insertChunk(TAG(P, C, N, T));
-	file.insertChunkData(&paramCount, sizeof(paramCount));
-	file.exitChunk();
+    // write number of parameters
+    file.goToTopOfForm();
+    file.insertChunk(TAG(P, C, N, T));
+    file.insertChunkData(&paramCount, sizeof(paramCount));
+    file.exitChunk();
 
-	file.exitForm(true);
-	ServerTangibleObjectTemplate::save(file);
-	file.exitForm();
-	UNREF(count);
-}	// ServerVehicleObjectTemplate::save
+    file.exitForm(true);
+    ServerTangibleObjectTemplate::save(file);
+    file.exitForm();
+    UNREF(count);
+}    // ServerVehicleObjectTemplate::save
 
 //@END TFD

engine/shared/library/sharedTemplate/src/shared/template/SharedShipObjectTemplate.cpp

@@ -19,7 +19,7 @@
 #include "sharedTemplateDefinition/ObjectTemplate.h"
 #include <stdio.h>
 
-
+#include "sharedFoundation/CrcConstexpr.hpp"
 
 /**
  * Class constructor.
@@ -281,14 +281,21 @@ char paramName[MAX_NAME_SIZE];
 	{
 		file.enterChunk();
 		file.read_string(paramName, MAX_NAME_SIZE);
-		if (strcmp(paramName, "cockpitFilename") == 0)
-			m_cockpitFilename.loadFromIff(file);
-		else if (strcmp(paramName, "hasWings") == 0)
-			m_hasWings.loadFromIff(file);
-		else if (strcmp(paramName, "playerControlled") == 0)
-			m_playerControlled.loadFromIff(file);
-		else if (strcmp(paramName, "interiorLayoutFileName") == 0)
-			m_interiorLayoutFileName.loadFromIff(file);
+
+		switch(runtimeCrc(paramName)) {
+			case constcrc("cockpitFilename"):
+				m_cockpitFilename.loadFromIff(file);
+				break;
+			case constcrc("hasWings"):
+				m_hasWings.loadFromIff(file);
+				break;
+			case constcrc("playerControlled"):
+				m_playerControlled.loadFromIff(file);
+				break;
+			case constcrc("interiorLayoutFileName"):
+				m_interiorLayoutFileName.loadFromIff(file);
+				break;
+		}
 		file.exitChunk(true);
 	}
 

engine/shared/library/sharedTemplate/src/shared/template/SharedVehicleObjectTemplate.cpp

@@ -19,63 +19,58 @@
 #include "sharedTemplateDefinition/ObjectTemplate.h"
 #include <stdio.h>
 
-
+#include "sharedFoundation/CrcConstexpr.hpp"
 
 /**
  * Class constructor.
  */
-SharedVehicleObjectTemplate::SharedVehicleObjectTemplate(const std::string & filename)
+SharedVehicleObjectTemplate::SharedVehicleObjectTemplate(const std::string &filename)
 //@BEGIN TFD INIT
-	: SharedTangibleObjectTemplate(filename)
+        : SharedTangibleObjectTemplate(filename)
 //@END TFD INIT
 {
-}	// SharedVehicleObjectTemplate::SharedVehicleObjectTemplate
+}    // SharedVehicleObjectTemplate::SharedVehicleObjectTemplate
 
 /**
  * Class destructor.
  */
-SharedVehicleObjectTemplate::~SharedVehicleObjectTemplate()
-{
+SharedVehicleObjectTemplate::~SharedVehicleObjectTemplate() {
 //@BEGIN TFD CLEANUP
 //@END TFD CLEANUP
-}	// SharedVehicleObjectTemplate::~SharedVehicleObjectTemplate
+}    // SharedVehicleObjectTemplate::~SharedVehicleObjectTemplate
 
 /**
  * Static function used to register this template.
  */
-void SharedVehicleObjectTemplate::registerMe(void)
-{
-	ObjectTemplateList::registerTemplate(SharedVehicleObjectTemplate_tag, create);
-}	// SharedVehicleObjectTemplate::registerMe
+void SharedVehicleObjectTemplate::registerMe(void) {
+    ObjectTemplateList::registerTemplate(SharedVehicleObjectTemplate_tag, create);
+}    // SharedVehicleObjectTemplate::registerMe
 
 /**
  * Creates a SharedVehicleObjectTemplate template.
  *
  * @return a new instance of the template
  */
-ObjectTemplate * SharedVehicleObjectTemplate::create(const std::string & filename)
-{
-	return new SharedVehicleObjectTemplate(filename);
-}	// SharedVehicleObjectTemplate::create
+ObjectTemplate *SharedVehicleObjectTemplate::create(const std::string &filename) {
+    return new SharedVehicleObjectTemplate(filename);
+}    // SharedVehicleObjectTemplate::create
 
 /**
  * Returns the template id.
  *
  * @return the template id
  */
-Tag SharedVehicleObjectTemplate::getId(void) const
-{
-	return SharedVehicleObjectTemplate_tag;
-}	// SharedVehicleObjectTemplate::getId
+Tag SharedVehicleObjectTemplate::getId(void) const {
+    return SharedVehicleObjectTemplate_tag;
+}    // SharedVehicleObjectTemplate::getId
 
 /**
  * Returns this template's version.
  *
  * @return the version
  */
-Tag SharedVehicleObjectTemplate::getTemplateVersion(void) const
-{
-	return m_templateVersion;
+Tag SharedVehicleObjectTemplate::getTemplateVersion(void) const {
+    return m_templateVersion;
 } // SharedVehicleObjectTemplate::getTemplateVersion
 
 /**
@@ -83,194 +78,168 @@ Tag SharedVehicleObjectTemplate::getTemplateVersion(void) const
  *
  * @return the highest version
  */
-Tag SharedVehicleObjectTemplate::getHighestTemplateVersion(void) const
-{
-	if (m_baseData == NULL)
-		return m_templateVersion;
-	const SharedVehicleObjectTemplate * base = dynamic_cast<const SharedVehicleObjectTemplate *>(m_baseData);
-	if (base == NULL)
-		return m_templateVersion;
-	return std::max(m_templateVersion, base->getHighestTemplateVersion());
+Tag SharedVehicleObjectTemplate::getHighestTemplateVersion(void) const {
+    if (m_baseData == NULL)
+        return m_templateVersion;
+    const SharedVehicleObjectTemplate *base = dynamic_cast<const SharedVehicleObjectTemplate *>(m_baseData);
+    if (base == NULL)
+        return m_templateVersion;
+    return std::max(m_templateVersion, base->getHighestTemplateVersion());
 } // SharedVehicleObjectTemplate::getHighestTemplateVersion
 
 //@BEGIN TFD
-CompilerIntegerParam * SharedVehicleObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getCompilerIntegerParam
+CompilerIntegerParam *
+SharedVehicleObjectTemplate::getCompilerIntegerParam(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getCompilerIntegerParam(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getCompilerIntegerParam
 
-FloatParam * SharedVehicleObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index)
-{
-	if (strcmp(name, "speed") == 0)
-	{
-		if (index >= 0 && index < 5)
-		{
-			if (deepCheck && !isParamLoaded(name, false, index))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_speed[index];
-		}
-		fprintf(stderr, "index for parameter \"speed\" out of bounds\n");
-	}
-	else if (strcmp(name, "slopeAversion") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_slopeAversion;
-		}
-		fprintf(stderr, "trying to access single-parameter \"slopeAversion\" as an array\n");
-	}
-	else if (strcmp(name, "hoverValue") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_hoverValue;
-		}
-		fprintf(stderr, "trying to access single-parameter \"hoverValue\" as an array\n");
-	}
-	else if (strcmp(name, "turnRate") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_turnRate;
-		}
-		fprintf(stderr, "trying to access single-parameter \"turnRate\" as an array\n");
-	}
-	else if (strcmp(name, "maxVelocity") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_maxVelocity;
-		}
-		fprintf(stderr, "trying to access single-parameter \"maxVelocity\" as an array\n");
-	}
-	else if (strcmp(name, "acceleration") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_acceleration;
-		}
-		fprintf(stderr, "trying to access single-parameter \"acceleration\" as an array\n");
-	}
-	else if (strcmp(name, "braking") == 0)
-	{
-		if (index == 0)
-		{
-			if (deepCheck && !isParamLoaded(name, false, 0))
-			{
-				if (getBaseTemplate() != nullptr)
-					return getBaseTemplate()->getFloatParam(name, deepCheck, index);
-				return nullptr;
-			}
-			return &m_braking;
-		}
-		fprintf(stderr, "trying to access single-parameter \"braking\" as an array\n");
-	}
-	else
-		return SharedTangibleObjectTemplate::getFloatParam(name, deepCheck, index);
-	return nullptr;
-}	//SharedVehicleObjectTemplate::getFloatParam
+FloatParam *SharedVehicleObjectTemplate::getFloatParam(const char *name, bool deepCheck, int index) {
+    switch (runtimeCrc(name)) {
+        case constcrc("speed"): {
+            if (index >= 0 && index < 5) {
+                if (deepCheck && !isParamLoaded(name, false, index)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_speed[index];
+            }
+            fprintf(stderr, "index for parameter \"speed\" out of bounds\n");
+        }
+            break;
+        case constcrc("slopeAversion"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_slopeAversion;
+            }
+            fprintf(stderr, "trying to access single-parameter \"slopeAversion\" as an array\n");
+        }
+            break;
+        case constcrc("hoverValue"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_hoverValue;
+            }
+            fprintf(stderr, "trying to access single-parameter \"hoverValue\" as an array\n");
+        }
+            break;
+        case constcrc("turnRate"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_turnRate;
+            }
+            fprintf(stderr, "trying to access single-parameter \"turnRate\" as an array\n");
+        }
+            break;
+        case constcrc("maxVelocity"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_maxVelocity;
+            }
+            fprintf(stderr, "trying to access single-parameter \"maxVelocity\" as an array\n");
+        }
+            break;
+        case constcrc("acceleration"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_acceleration;
+            }
+            fprintf(stderr, "trying to access single-parameter \"acceleration\" as an array\n");
+        }
+            break;
+        case constcrc("braking"): {
+            if (index == 0) {
+                if (deepCheck && !isParamLoaded(name, false, 0)) {
+                    if (getBaseTemplate() != nullptr)
+                        return getBaseTemplate()->getFloatParam(name, deepCheck, index);
+                    return nullptr;
+                }
+                return &m_braking;
+            }
+            fprintf(stderr, "trying to access single-parameter \"braking\" as an array\n");
+        }
+            break;
+        default:
+            return SharedTangibleObjectTemplate::getFloatParam(name, deepCheck, index);
+            break;
+    }
+    return nullptr;
+}    //SharedVehicleObjectTemplate::getFloatParam
 
-BoolParam * SharedVehicleObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getBoolParam(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getBoolParam
+BoolParam *SharedVehicleObjectTemplate::getBoolParam(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getBoolParam(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getBoolParam
 
-StringParam * SharedVehicleObjectTemplate::getStringParam(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getStringParam(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getStringParam
+StringParam *SharedVehicleObjectTemplate::getStringParam(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getStringParam(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getStringParam
 
-StringIdParam * SharedVehicleObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getStringIdParam(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getStringIdParam
+StringIdParam *SharedVehicleObjectTemplate::getStringIdParam(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getStringIdParam(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getStringIdParam
 
-VectorParam * SharedVehicleObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getVectorParam(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getVectorParam
+VectorParam *SharedVehicleObjectTemplate::getVectorParam(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getVectorParam(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getVectorParam
 
-DynamicVariableParam * SharedVehicleObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getDynamicVariableParam
+DynamicVariableParam *
+SharedVehicleObjectTemplate::getDynamicVariableParam(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getDynamicVariableParam(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getDynamicVariableParam
 
-StructParamOT * SharedVehicleObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getStructParamOT(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getStructParamOT
+StructParamOT *SharedVehicleObjectTemplate::getStructParamOT(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getStructParamOT(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getStructParamOT
 
-TriggerVolumeParam * SharedVehicleObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index)
-{
-	return SharedTangibleObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
-}	//SharedVehicleObjectTemplate::getTriggerVolumeParam
+TriggerVolumeParam *SharedVehicleObjectTemplate::getTriggerVolumeParam(const char *name, bool deepCheck, int index) {
+    return SharedTangibleObjectTemplate::getTriggerVolumeParam(name, deepCheck, index);
+}    //SharedVehicleObjectTemplate::getTriggerVolumeParam
 
-void SharedVehicleObjectTemplate::initStructParamOT(StructParamOT &param, const char *name)
-{
-	if (param.isInitialized())
-		return;
-	SharedTangibleObjectTemplate::initStructParamOT(param, name);
-}	// SharedVehicleObjectTemplate::initStructParamOT
+void SharedVehicleObjectTemplate::initStructParamOT(StructParamOT &param, const char *name) {
+    if (param.isInitialized())
+        return;
+    SharedTangibleObjectTemplate::initStructParamOT(param, name);
+}    // SharedVehicleObjectTemplate::initStructParamOT
 
-void SharedVehicleObjectTemplate::setAsEmptyList(const char *name)
-{
-	SharedTangibleObjectTemplate::setAsEmptyList(name);
-}	// SharedVehicleObjectTemplate::setAsEmptyList
+void SharedVehicleObjectTemplate::setAsEmptyList(const char *name) {
+    SharedTangibleObjectTemplate::setAsEmptyList(name);
+}    // SharedVehicleObjectTemplate::setAsEmptyList
 
-void SharedVehicleObjectTemplate::setAppend(const char *name)
-{
-	SharedTangibleObjectTemplate::setAppend(name);
-}	// SharedVehicleObjectTemplate::setAppend
+void SharedVehicleObjectTemplate::setAppend(const char *name) {
+    SharedTangibleObjectTemplate::setAppend(name);
+}    // SharedVehicleObjectTemplate::setAppend
 
-bool SharedVehicleObjectTemplate::isAppend(const char *name) const
-{
-	return SharedTangibleObjectTemplate::isAppend(name);
-}	// SharedVehicleObjectTemplate::isAppend
+bool SharedVehicleObjectTemplate::isAppend(const char *name) const {
+    return SharedTangibleObjectTemplate::isAppend(name);
+}    // SharedVehicleObjectTemplate::isAppend
 
 
-int SharedVehicleObjectTemplate::getListLength(const char *name) const
-{
-	if (strcmp(name, "speed") == 0)
-	{
-		return sizeof(m_speed) / sizeof(FloatParam);
-	}
-	else
-		return SharedTangibleObjectTemplate::getListLength(name);
-}	// SharedVehicleObjectTemplate::getListLength
+int SharedVehicleObjectTemplate::getListLength(const char *name) const {
+    if (strcmp(name, "speed") == 0) {
+        return sizeof(m_speed) / sizeof(FloatParam);
+    } else
+        return SharedTangibleObjectTemplate::getListLength(name);
+}    // SharedVehicleObjectTemplate::getListLength
 
 /**
  * Loads the template data from an iff file. We should already be in the form
@@ -278,88 +247,91 @@ int SharedVehicleObjectTemplate::getListLength(const char *name) const
  *
  * @param file		file to load from
  */
-void SharedVehicleObjectTemplate::load(Iff &file)
-{
-static const int MAX_NAME_SIZE = 256;
-char paramName[MAX_NAME_SIZE];
+void SharedVehicleObjectTemplate::load(Iff &file) {
+    static const int MAX_NAME_SIZE = 256;
+    char paramName[MAX_NAME_SIZE];
 
-	if (file.getCurrentName() != SharedVehicleObjectTemplate_tag)
-	{
-		SharedTangibleObjectTemplate::load(file);
-		return;
-	}
+    if (file.getCurrentName() != SharedVehicleObjectTemplate_tag) {
+        SharedTangibleObjectTemplate::load(file);
+        return;
+    }
 
-	file.enterForm();
-	m_templateVersion = file.getCurrentName();
-	if (m_templateVersion == TAG(D,E,R,V))
-	{
-		file.enterForm();
-		file.enterChunk();
-		std::string baseFilename;
-		file.read_string(baseFilename);
-		file.exitChunk();
-		const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
-		DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
-		if (m_baseData == base && base != nullptr)
-			base->releaseReference();
-		else
-		{
-			if (m_baseData != nullptr)
-				m_baseData->releaseReference();
-			m_baseData = base;
-		}
-		file.exitForm();
-		m_templateVersion = file.getCurrentName();
-	}
-	if (getHighestTemplateVersion() != TAG(0,0,0,0))
-	{
-		if (DataLint::isEnabled())
-			DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
-	}
+    file.enterForm();
+    m_templateVersion = file.getCurrentName();
+    if (m_templateVersion == TAG(D, E, R, V)) {
+        file.enterForm();
+        file.enterChunk();
+        std::string baseFilename;
+        file.read_string(baseFilename);
+        file.exitChunk();
+        const ObjectTemplate *base = ObjectTemplateList::fetch(baseFilename);
+        DEBUG_WARNING(base == nullptr, ("was unable to load base template %s", baseFilename.c_str()));
+        if (m_baseData == base && base != nullptr)
+            base->releaseReference();
+        else {
+            if (m_baseData != nullptr)
+                m_baseData->releaseReference();
+            m_baseData = base;
+        }
+        file.exitForm();
+        m_templateVersion = file.getCurrentName();
+    }
+    if (getHighestTemplateVersion() != TAG(0, 0, 0, 0)) {
+        if (DataLint::isEnabled())
+            DEBUG_WARNING(true, ("template %s version out of date", file.getFileName()));
+    }
 
-	file.enterForm();
+    file.enterForm();
 
-	file.enterChunk();
-	int paramCount = file.read_int32();
-	file.exitChunk();
-	for (int i = 0; i < paramCount; ++i)
-	{
-		file.enterChunk();
-		file.read_string(paramName, MAX_NAME_SIZE);
-		if (strcmp(paramName, "speed") == 0)
-		{
-			int listCount = file.read_int32();
-			DEBUG_WARNING(listCount != 5, ("Template %s: read array size of %d for array \"speed\" of size 5, reading values anyway", file.getFileName(), listCount));
-			int j;
-			for (j = 0; j < 5 && j < listCount; ++j)
-				m_speed[j].loadFromIff(file);
-			// if there are more params for speed read and dump them
-			for (; j < listCount; ++j)
-			{
-				FloatParam dummy;
-				dummy.loadFromIff(file);
-			}
-		}
-		else if (strcmp(paramName, "slopeAversion") == 0)
-			m_slopeAversion.loadFromIff(file);
-		else if (strcmp(paramName, "hoverValue") == 0)
-			m_hoverValue.loadFromIff(file);
-		else if (strcmp(paramName, "turnRate") == 0)
-			m_turnRate.loadFromIff(file);
-		else if (strcmp(paramName, "maxVelocity") == 0)
-			m_maxVelocity.loadFromIff(file);
-		else if (strcmp(paramName, "acceleration") == 0)
-			m_acceleration.loadFromIff(file);
-		else if (strcmp(paramName, "braking") == 0)
-			m_braking.loadFromIff(file);
-		file.exitChunk(true);
-	}
+    file.enterChunk();
+    int paramCount = file.read_int32();
+    file.exitChunk();
+    for (int i = 0; i < paramCount; ++i) {
+        file.enterChunk();
+        file.read_string(paramName, MAX_NAME_SIZE);
 
-	file.exitForm();
-	SharedTangibleObjectTemplate::load(file);
-	file.exitForm();
-	return;
-}	// SharedVehicleObjectTemplate::load
+        switch (runtimeCrc(paramName)) {
+            case constcrc("speed"): {
+                int listCount = file.read_int32();
+                DEBUG_WARNING(listCount != 5,
+                              ("Template %s: read array size of %d for array \"speed\" of size 5, reading values anyway", file.getFileName(), listCount));
+                int j;
+                for (j = 0; j < 5 && j < listCount; ++j)
+                    m_speed[j].loadFromIff(file);
+                // if there are more params for speed read and dump them
+                for (; j < listCount; ++j) {
+                    FloatParam dummy;
+                    dummy.loadFromIff(file);
+                }
+            }
+                break;
+            case constcrc("slopeAversion"):
+                m_slopeAversion.loadFromIff(file);
+                break;
+            case constcrc("hoverValue"):
+                m_hoverValue.loadFromIff(file);
+                break;
+            case constcrc("turnRate"):
+                m_turnRate.loadFromIff(file);
+                break;
+            case constcrc("maxVelocity"):
+                m_maxVelocity.loadFromIff(file);
+                break;
+            case constcrc("acceleration"):
+                m_acceleration.loadFromIff(file);
+                break;
+            case constcrc("braking"):
+                m_braking.loadFromIff(file);
+                break;
+        }
+        file.exitChunk(true);
+    }
+
+    file.exitForm();
+    SharedTangibleObjectTemplate::load(file);
+    file.exitForm();
+    return;
+}    // SharedVehicleObjectTemplate::load
 
 /**
  * Saves the template data to an iff file.
@@ -367,79 +339,79 @@ char paramName[MAX_NAME_SIZE];
  * @param file			file to save to
  * @param location		file type (client or server)
  */
-void SharedVehicleObjectTemplate::save(Iff &file)
-{
-int count;
+void SharedVehicleObjectTemplate::save(Iff &file) {
+    int count;
 
-	file.insertForm(SharedVehicleObjectTemplate_tag);
-	if (m_baseTemplateName.size() != 0)
-	{
-		file.insertForm(TAG(D,E,R,V));
-		file.insertChunk(TAG(X, X, X, X));
-		file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
-		file.exitChunk();
-		file.exitForm();
-	}
-	file.insertForm(TAG(0,0,0,0));
-	file.allowNonlinearFunctions();
+    file.insertForm(SharedVehicleObjectTemplate_tag);
+    if (m_baseTemplateName.size() != 0) {
+        file.insertForm(TAG(D, E, R, V));
+        file.insertChunk(TAG(X, X, X, X));
+        file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
+        file.exitChunk();
+        file.exitForm();
+    }
+    file.insertForm(TAG(0, 0, 0, 0));
+    file.allowNonlinearFunctions();
 
-	int paramCount = 0;
+    int paramCount = 0;
 
-	// save speed
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("speed");
-	count = 5;
-	file.insertChunkData(&count, sizeof(count));
-	{for (int i = 0; i < 5; ++i)
-		m_speed[i].saveToIff(file);}
-	file.exitChunk();
-	++paramCount;
-	// save slopeAversion
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("slopeAversion");
-	m_slopeAversion.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save hoverValue
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("hoverValue");
-	m_hoverValue.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save turnRate
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("turnRate");
-	m_turnRate.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save maxVelocity
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("maxVelocity");
-	m_maxVelocity.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save acceleration
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("acceleration");
-	m_acceleration.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
-	// save braking
-	file.insertChunk(TAG(X, X, X, X));
-	file.insertChunkString("braking");
-	m_braking.saveToIff(file);
-	file.exitChunk();
-	++paramCount;
+    // save speed
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("speed");
+    count = 5;
+    file.insertChunkData(&count, sizeof(count));
+    {
+        for (int i = 0; i < 5; ++i)
+            m_speed[i].saveToIff(file);
+    }
+    file.exitChunk();
+    ++paramCount;
+    // save slopeAversion
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("slopeAversion");
+    m_slopeAversion.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save hoverValue
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("hoverValue");
+    m_hoverValue.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save turnRate
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("turnRate");
+    m_turnRate.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save maxVelocity
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("maxVelocity");
+    m_maxVelocity.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save acceleration
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("acceleration");
+    m_acceleration.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
+    // save braking
+    file.insertChunk(TAG(X, X, X, X));
+    file.insertChunkString("braking");
+    m_braking.saveToIff(file);
+    file.exitChunk();
+    ++paramCount;
 
-	// write number of parameters
-	file.goToTopOfForm();
-	file.insertChunk(TAG(P, C, N, T));
-	file.insertChunkData(&paramCount, sizeof(paramCount));
-	file.exitChunk();
+    // write number of parameters
+    file.goToTopOfForm();
+    file.insertChunk(TAG(P, C, N, T));
+    file.insertChunkData(&paramCount, sizeof(paramCount));
+    file.exitChunk();
 
-	file.exitForm(true);
-	SharedTangibleObjectTemplate::save(file);
-	file.exitForm();
-}	// SharedVehicleObjectTemplate::save
+    file.exitForm(true);
+    SharedTangibleObjectTemplate::save(file);
+    file.exitForm();
+}    // SharedVehicleObjectTemplate::save
 
 //@END TFD