mmo-ref/cyphesis
1
0
Fork 0
mirror of https://github.com/worldforge/cyphesis synced 2026-08-13 12:26:04 -04:00
Code Issues Projects Releases Packages Wiki Activity
cyphesis/server/ArchetypeRuleHandler.cpp

252 lines
8.8 KiB
C++
Raw Permalink Normal View History

Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
// Cyphesis Online RPG Server and AI Engine
// Copyright (C) 2009 Alistair Riddoch
// Copyright (C) 2013 Erik Ogenvik
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software Foundation,
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#include "ArchetypeRuleHandler.h"
#include "EntityBuilder.h"
#include "Player.h"
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
#include "ArchetypeFactory.h"
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
#include "common/log.h"
#include "common/debug.h"
#include "common/compose.hpp"
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
#include <Atlas/Objects/objectFactory.h>
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
#include <iostream>
using Atlas::Message::Element;
using Atlas::Message::MapType;
using Atlas::Message::ListType;
using Atlas::Objects::Root;
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
using Atlas::Objects::Entity::RootEntity;
using Atlas::Objects::smart_dynamic_cast;
using Atlas::Objects::Factories;
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
using String::compose;
static const bool debug_flag = false;
int ArchetypeRuleHandler::installArchetypeClass(const std::string & class_name,
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
const std::string & parent, const Root & class_desc,
std::string & dependent, std::string & reason)
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
{
assert(class_name == class_desc->getId());
// Get the new factory for this rule
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
auto* parent_factory = dynamic_cast<ArchetypeFactory*>(m_builder->getClassFactory(parent));
if (parent_factory == nullptr) {
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
debug(
std::cout << "class \"" << class_name
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
<< "\" has non existant parent \"" << parent
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
<< "\". Waiting." << std::endl << std::flush
;);
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
dependent = parent;
reason = compose("Entity rule \"%1\" has parent \"%2\" which does "
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
"not exist.", class_name, parent);
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
return 1;
}
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
ArchetypeFactory * factory = parent_factory->duplicateFactory();
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
if (factory == nullptr) {
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
log(ERROR,
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
compose(
"Attempt to install rule \"%1\" which has parent \"%2\" "
"which cannot be instantiated", class_name,
parent));
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
return -1;
}
assert(factory->m_parent == parent_factory);
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
if (populateArchetypeFactory(class_name, factory, class_desc->asMessage(),
dependent, reason) != 0) {
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
delete factory;
return -1;
}
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
debug(
std::cout << "INSTALLING " << class_name << ":" << parent
<< std::endl << std::flush
;);
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
// Install the factory in place.
if (m_builder->installFactory(class_name, class_desc, factory) != 0) {
delete factory;
return -1;
}
factory->addProperties();
// Add it as a child to its parent.
parent_factory->m_children.insert(factory);
return 0;
}
int ArchetypeRuleHandler::modifyArchetypeClass(const std::string & class_name,
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
const Root & class_desc, std::map<const TypeNode*, TypeNode::PropertiesUpdate>& changes)
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
{
assert(class_name == class_desc->getId());
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
auto factory =
dynamic_cast<ArchetypeFactory*>(m_builder->getClassFactory(class_name));
if (factory == nullptr) {
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
log(ERROR, compose("Could not find factory for existing entity class "
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
"\"%1\".", class_name));
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
return -1;
}
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
assert(factory != nullptr);
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
auto backup_entities = factory->m_entities;
auto backup_thoughts = factory->m_thoughts;
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
// Copy the defaults from the parent. In populateArchetypeFactory this may be
Fix typos Courtesy of lintian
2016-09-06 22:29:36 -04:00
// overridden with the defaults for this class.
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
if (factory->m_parent != nullptr) {
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
factory->m_entities = factory->m_parent->m_entities;
factory->m_thoughts = factory->m_parent->m_thoughts;
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
} else {
// This is non fatal, but nice to know it has happened.
// This should only happen if the client attempted to modify the
// type data for a core hard coded type.
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
log(ERROR,
compose(
"ArchetypeRuleHandler::modifyEntityClass: \"%1\" modified "
"by client, but has no parent factory.",
class_name));
factory->m_entities.clear();
factory->m_thoughts.clear();
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
}
Implement archetype inheritance.
2013-10-25 15:00:54 +02:00
factory->m_classEntities.clear();
factory->m_classThoughts.clear();
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
std::string dependent, reason;
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
if (populateArchetypeFactory(class_name, factory, class_desc->asMessage(),
dependent, reason) != 0) {
factory->m_entities = backup_entities;
factory->m_thoughts = backup_thoughts;
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
return -1;
}
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
factory->updateProperties(changes);
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
return 0;
}
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
int ArchetypeRuleHandler::populateArchetypeFactory(
const std::string & class_name, ArchetypeFactory * factory,
const MapType & class_desc, std::string & dependent,
std::string & reason)
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
{
// assert(class_name == class_desc->getId());
// Establish whether this rule has an associated script, and
// if so, use it.
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
// MapType::const_iterator J = class_desc.find("script");
// MapType::const_iterator Jend = class_desc.end();
// if (J != Jend && J->second.isMap()) {
// const MapType & script = J->second.asMap();
// std::string script_package;
// std::string script_class;
// if (getScriptDetails(script, class_name, "Archetype",
// script_package, script_class) != 0) {
// return -1;
// }
// if (factory->m_scriptFactory == 0 ||
// factory->m_scriptFactory->package() != script_package) {
// PythonScriptFactory<LocatedEntity> * psf =
// new PythonScriptFactory<LocatedEntity>(script_package,
// script_class);
// if (psf->setup() == 0) {
// delete factory->m_scriptFactory;
// factory->m_scriptFactory = psf;
// } else {
// log(ERROR, compose("Python class \"%1.%2\" failed to load",
// script_package, script_class));
// delete psf;
// return -1;
// }
// } else {
// // FIXME If this fails, that's bad.
// factory->m_scriptFactory->refreshClass();
// }
// }
//
Implement archetype inheritance.
2013-10-25 15:00:54 +02:00
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
auto entitiesI = class_desc.find("entities");
if (entitiesI != class_desc.end() && entitiesI->second.isList()) {
for (auto& I : entitiesI->second.asList()) {
if (I.isMap()) {
Implement archetype inheritance.
2013-10-25 15:00:54 +02:00
const MapType& map = I.asMap();
std::string id;
auto idI = map.find("id");
if (idI != map.end() && idI->second.isString()) {
id = idI->second.asString();
}
MapType& entity = factory->m_entities[id];
MapType& classEntity = factory->m_classEntities[id];
for (auto& entry : map) {
entity[entry.first] = entry.second;
classEntity[entry.first] = entry.second;
}
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
}
}
}
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
auto thoughtsI = class_desc.find("thoughts");
if (thoughtsI != class_desc.end() && thoughtsI->second.isList()) {
Implement archetype inheritance.
2013-10-25 15:00:54 +02:00
const ListType& thoughts = thoughtsI->second.asList();
factory->m_thoughts.insert(factory->m_thoughts.end(), thoughts.begin(),
thoughts.end());
factory->m_classThoughts.insert(factory->m_classThoughts.end(),
thoughts.begin(), thoughts.end());
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
}
// Check whether it should be available to players as a playable character.
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
auto playableI = class_desc.find("playable");
if (playableI != class_desc.end() && playableI->second.isInt()) {
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
Player::playableTypes.insert(class_name);
}
return 0;
}
int ArchetypeRuleHandler::check(const Atlas::Objects::Root & desc)
{
Replace "parents" with "parent".
2017-07-24 13:39:22 +02:00
assert(!desc->getParent().empty());
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
if (desc->getObjtype() != "archetype") {
return -1;
}
return 0;
}
int ArchetypeRuleHandler::install(const std::string & name,
Use custom format for archetypes. This required the EntityKit to be refactored, so that most fields are pushed into EntityFactory. Due to the nature of how the rule handlers and the factories interact the code is pretty messy. It works, but it's tangled and not really clean.
2013-10-07 23:01:30 +02:00
const std::string & parent, const Atlas::Objects::Root & description,
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
std::string & dependent, std::string & reason,
std::map<const TypeNode*, TypeNode::PropertiesUpdate>& changes)
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
{
return installArchetypeClass(name, parent, description, dependent, reason);
}
int ArchetypeRuleHandler::update(const std::string & name,
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
const Atlas::Objects::Root & desc,
std::map<const TypeNode*, TypeNode::PropertiesUpdate>& changes)
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
{
Improve on how updated types are handled. By installing and changing some types, other types might update. This is now handled.
2018-05-08 14:32:02 +02:00
return modifyArchetypeClass(name, desc, changes);
Add "archetype" as new type. An archetype is used for creating new entities. It contains one or many definitions for entities, along with relationship between them. It also contains any extra data needed for a world simultion, such as thoughts and knowledge. Archetypes should be seen as blueprints for entity types, as they describe how new one should be composed. They are created just as regular entities, using the existing Create op functionality. As an example, there should be one "human" entity type, with archetypes such as "settler", "merchant", "soldier" etc. This differs from the current setup where each of these are separate entity types.
2013-10-04 14:26:16 +02:00
}
Reference in a new issue Copy permalink