Je ne sais pas vraiment comment expliquer cela.C++ n'est pas un espace de noms
J'ai 2 classes du monde et des entités dans l'espace de noms:
artemis::system;
et un composant de classe dans
artemis::component;
j'avais déjà du mal avec World et entité, en essayant de le compiler dit l'un d'entre eux n'était pas un type déclaré. (ils s'incluent tous les deux) Donc dans les deux classes, dans l'espace de noms, j'ai ajouté une déclaration forward. Cela semble résoudre le problème.
Maintenant, quand j'essaie d'inclure « monde » dans mon Component.h il me donne l'erreur suivante:
component is not a namespace-name
Ma classe de composants réside dans l'espace de noms artemis :: composant.
Cela me rend fou. Je ne comprends vraiment pas ce qui cause cette erreur.
tête Component.h
#ifndef _COMPONENT_H_
#define _COMPONENT_H_
#include <bitset>
#include "BitSize.h"
#include "World.h"
#include <unordered_map>
#include <typeinfo>
#include <string>
#include <iostream>
#include <assert.h>
//#include "EntityManager.h"
using namespace std;
using namespace artemis::system;
namespace artemis {
namespace component {
class Component {
public:
virtual ~Component() = 0;
protected:
Component(){};
};
/**
* Identifies a bitset and id for a component object
* Do not instantiate a ComponentType, instead use the ComponentTypeManager.
* */
class ComponentType {
public:
ComponentType();
bitset<BITSIZE> getBit() const;
int getId() const;
private:
static bitset<BITSIZE> nextBit;
static int nextId;
bitset<BITSIZE> bit;
int id;
void init();
};
//Surpress unused variable warnning. Might need to rewrite it
//#pragma GCC diagnostic push
//#pragma GCC diagnostic ignored "-Wunused-variable"
/**
* Manages the id and bitset for every component based on their type.
* */
class ComponentTypeManager {
private:
ComponentTypeManager();
static unordered_map<size_t,ComponentType*> componentTypes;
public:
/**
*
**/
static ComponentType & getTypeFor(const type_info &t);
/**
* Gets the component type object
**/
template<typename c>
static ComponentType & getTypeFor() {
//Check if we are being legal with components and shizzle
//Component * c = (component*)0;
assert((std::is_base_of< Component, c >::value == true));
return getTypeFor(typeid(c));
}
/**
* Gets the bit set of a component
**/
template<typename c>
static bitset<BITSIZE> getBit() {
//Check if we are being legal with components and shizzle
//Component * c = (component*)0;
assert((std::is_base_of< Component, c >::value == true));
ComponentType & type = getTypeFor(typeid(c));
return type.getBit();
}
/**
* Gets the component id
**/
template<typename c>
static int getId() {
//Check if we are being legal with components and shizzle
assert((std::is_base_of< Component, c >::value == true));
ComponentType & type = getTypeFor(typeid(c));
return type.getId();
};
//typedef getCompBit bitset<BITSIZE>(*getBit<Component>)();
};
//#pragma GCC diagnostic pop
/*template<typename T>
class ComponentMapper {
private:
//ComponentType * type;
EntityManager * em;
public:
ComponentMapper(World &world) {
em = world.getEntityManager();
//type = ComponentTypeManager::getTypeFor<T>();
}
~ComponentType() {
type = nullptr;
em = nullptr;
}
T & get(Entity * e) {
return &(T)em->getComponent<T>(e);
}
};*/
};
};
#endif
tête Entity.h
#ifndef _ENTITY_H
#define _ENTITY_H
#include <bitset>
#include <string>
#include <cstddef>
#include <typeinfo>
#include "BitSize.h"
#include "Component.h"
#include "ImmutableBag.h"
#include "World.h"
//#include "EntityManager.h"
using namespace artemis::util;
using namespace artemis::component;
//using namespace artemis;
using namespace std;
namespace artemis {
namespace system {
class World;
class Entity {
private:
int id;
long int uniqueId;
bitset<BITSIZE> typeBits;
bitset<BITSIZE> systemBits;
World * world;
//EntityManager * entityManager;
protected:
public:
Entity(World * world, int id);
~Entity();
int getID();
void setUniqueId(long int uniqueId);
long int getUniqueID();
bitset<BITSIZE> getTypeBits();
void addTypeBit(bitset<BITSIZE> bit);
void removeTypeBit(bitset<BITSIZE> bit);
bitset<BITSIZE> getSystemBits();
void addSystemBit(bitset<BITSIZE> bit);
void removeSystemBit(bitset<BITSIZE> bit);
void setSystemBits(bitset<BITSIZE> systemBits);
void setTypeBits(bitset<BITSIZE> typeBits);
void reset();
string toString();
void addComponent(Component * c);
//Might change to non template
template<typename c>
void removeComponent() {
//entityManager->removeComponent(this,ComponentTypeManager::getTypeFor<c>());
}
void removeComponent(ComponentType & type);
bool isActive();
Component * getComponent(ComponentType & type);
/*template<typename c>
Component * getComponent() {
return (c)entityManager->getComponent(ComponentTypeManager.getTypeFor<c>());
}*/
ImmutableBag<Component*> * getComponents();
void refresh();
void remove();
void setGroup(string group);
void setTag(string tag);
};
};
};
#endif // $(Guard token)
tête World.h
#ifndef _WORLD_H_
#define _WORLD_H_
//#include "SystemManager.h"
//#include "EntityManager.h"
#include "ImmutableBag.h"
#include "Entity.h"
using namespace artemis::util;
namespace artemis {
namespace system {
class Entity;
class World {
public:
World();
~World();
//SystemManager * getSystemManager();
//EntityManager * getEntityManager();
//TagManager * getTagManager();
//GroupManager * getGroupManager();
int getDelta();
void setDetla(int delta);
void deleteEntity(Entity *e);
void refreshEntity(Entity *e);
//Entity* createEntity();
//Entity* getEntity(int entityID);
void loopStart();
private:
//SystemManager * systemManager;
//EntityManager * entityManager;
//TagManager * tagManager;
//GroupManager * grouManager;
int delta;
Bag<Entity*> refreshed;
Bag<Entity*> deleted;
};
};
};
#endif // $(Guard token)
Testcase, s'il vous plaît ... – Griwes
Que voulez-vous dire par testcase? – Sidar
Vous semble confondre un espace de nom avec le nom du type. Le composant * effectivement * est-il un espace de noms ou est-ce un type? –