void EntityDefinitionManager::load(const String& path) {
     Preferences::PreferenceManager& prefs = Preferences::PreferenceManager::preferences();
     const Color& defaultColor = prefs.getColor(Preferences::EntityBoundsColor);
     EntityDefinitionMap newDefinitions;
     
     IO::FileManager fileManager;
     IO::MappedFile::Ptr file = fileManager.mapFile(path);
     if (file.get() != NULL) {
         try {
             const String extension = fileManager.pathExtension(path);
             if (Utility::equalsString(extension, "def", false)) {
                 IO::DefParser parser(file->begin(), file->end(), defaultColor);
                 
                 EntityDefinition* definition = NULL;
                 while ((definition = parser.nextDefinition()) != NULL)
                     Utility::insertOrReplace(newDefinitions, definition->name(), definition);
             } else if (Utility::equalsString(extension, "fgd", false)) {
                 IO::FgdParser parser(file->begin(), file->end(), defaultColor);
                 
                 EntityDefinition* definition = NULL;
                 while ((definition = parser.nextDefinition()) != NULL)
                     Utility::insertOrReplace(newDefinitions, definition->name(), definition);
             }
             
             clear();
             m_entityDefinitions = newDefinitions;
             m_path = path;
         } catch (IO::ParserException e) {
             Utility::deleteAll(newDefinitions);
             m_console.error(e.what());
         }
     } else {
         m_console.error("Unable to open entity definition file %s", path.c_str());
     }
 }
Exemple #2
0
//---------------------------------------
Entity* MageGame::SpawnEntity( const std::string& name, const Vec2f& position )
{
	EntityDefinition* entityDef = EntityDefinition::GetDefinitionByName( name );
	if ( entityDef )
	{
		Entity& entity = entityDef->Create( position );
		entity.SetGameMap( &mGameMap );
		return &entity;
	}
	ConsolePrintf( CONSOLE_ERROR, "Failed to spawn Entity: No Entity found '%s'\n", name.c_str() );
	return NULL;
}
        void EntityDefinitionManager::updateGroups() {
            clearGroups();

            using GroupMap = std::map<String, EntityDefinitionList>;
            GroupMap groupMap;

            for (size_t i = 0; i < m_definitions.size(); ++i) {
                EntityDefinition* definition = m_definitions[i];
                const String groupName = definition->groupName();
                groupMap[groupName].push_back(definition);
            }

            for (const auto& entry : groupMap) {
                const String& groupName = entry.first;
                const EntityDefinitionList& definitions = entry.second;
                m_groups.push_back(EntityDefinitionGroup(groupName, definitions));
            }
        }
 EntityDefinitionManager::EntityDefinitionGroups EntityDefinitionManager::groups(EntityDefinition::Type type, SortOrder order) {
     EntityDefinitionGroups groups;
     EntityDefinitionList list = definitions(type, order);
     EntityDefinitionList ungrouped;
     
     EntityDefinitionList::const_iterator it, end;
     for (it = list.begin(), end = list.end(); it != end; ++it) {
         EntityDefinition* definition = *it;
         const String groupName = definition->groupName();
         if (groupName.empty())
             ungrouped.push_back(definition);
         else
             groups[groupName].push_back(definition);
     }
     
     for (it = ungrouped.begin(), end = ungrouped.end(); it != end; ++it) {
         EntityDefinition* definition = *it;
         const String shortName = Utility::capitalize(definition->shortName());
         EntityDefinitionGroups::iterator groupIt = groups.find(shortName);
         if (groupIt == groups.end())
             groups["Misc"].push_back(definition);
         else
             groupIt->second.push_back(definition);
     }
     
     EntityDefinitionGroups::iterator groupIt, groupEnd;
     for (groupIt = groups.begin(), groupEnd = groups.end(); groupIt != groupEnd; ++groupIt) {
         EntityDefinitionList& definitions = groupIt->second;
         if (order == Usage)
             std::sort(definitions.begin(), definitions.end(), CompareEntityDefinitionsByUsage());
         else
             std::sort(definitions.begin(), definitions.end(), CompareEntityDefinitionsByName(true));
     }
     
     return groups;
 }