Some progress on transitioning from MapBlockObject to ActiveObject.

src/clientobject.cpp

@@ -23,6 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "constants.h"
 #include "utility.h"
 
+core::map<u16, ClientActiveObject::Factory> ClientActiveObject::m_types;
+
 ClientActiveObject::ClientActiveObject(u16 id):
 	ActiveObject(id)
 {
@@ -35,41 +37,55 @@ ClientActiveObject::~ClientActiveObject()
 
 ClientActiveObject* ClientActiveObject::create(u8 type)
 {
-	if(type == ACTIVEOBJECT_TYPE_INVALID)
+	// Find factory function
+	core::map<u16, Factory>::Node *n;
+	n = m_types.find(type);
+	if(n == NULL)
 	{
-		dstream<<"ClientActiveObject::create(): passed "
-				<<"ACTIVEOBJECT_TYPE_INVALID"<<std::endl;
-		return NULL;
-	}
-	else if(type == ACTIVEOBJECT_TYPE_TEST)
-	{
-		dstream<<"ClientActiveObject::create(): passed "
-				<<"ACTIVEOBJECT_TYPE_TEST"<<std::endl;
-		return new TestCAO(0);
-	}
-	else
-	{
-		dstream<<"ClientActiveObject::create(): passed "
-				<<"unknown type="<<type<<std::endl;
+		// If factory is not found, just return.
+		dstream<<"WARNING: ClientActiveObject: No factory for type="
+				<<type<<std::endl;
 		return NULL;
 	}
+
+	Factory f = n->getValue();
+	ClientActiveObject *object = (*f)();
+	return object;
+}
+
+void ClientActiveObject::registerType(u16 type, Factory f)
+{
+	core::map<u16, Factory>::Node *n;
+	n = m_types.find(type);
+	if(n)
+		return;
+	m_types.insert(type, f);
 }
 
 /*
 	TestCAO
 */
 
-TestCAO::TestCAO(u16 id):
-	ClientActiveObject(id),
+// Prototype
+TestCAO proto_TestCAO;
+
+TestCAO::TestCAO():
+	ClientActiveObject(0),
 	m_node(NULL),
 	m_position(v3f(0,10*BS,0))
 {
+	ClientActiveObject::registerType(getType(), create);
 }
 
 TestCAO::~TestCAO()
 {
 }
 
+ClientActiveObject* TestCAO::create()
+{
+	return new TestCAO();
+}
+
 void TestCAO::addToScene(scene::ISceneManager *smgr)
 {
 	if(m_node != NULL)
@@ -160,4 +176,184 @@ void TestCAO::processMessage(const std::string &data)
 	}
 }
 
+/*
+	ItemCAO
+*/
+
+#include "inventory.h"
+
+// Prototype
+ItemCAO proto_ItemCAO;
+
+ItemCAO::ItemCAO():
+	ClientActiveObject(0),
+	m_selection_box(-BS*0.4,0.0,-BS*0.4, BS*0.4,BS*0.8,BS*0.4),
+	m_node(NULL),
+	m_position(v3f(0,10*BS,0))
+{
+	ClientActiveObject::registerType(getType(), create);
+}
+
+ItemCAO::~ItemCAO()
+{
+}
+
+ClientActiveObject* ItemCAO::create()
+{
+	return new ItemCAO();
+}
+
+void ItemCAO::addToScene(scene::ISceneManager *smgr)
+{
+	if(m_node != NULL)
+		return;
+	
+	video::IVideoDriver* driver = smgr->getVideoDriver();
+	
+	scene::SMesh *mesh = new scene::SMesh();
+	scene::IMeshBuffer *buf = new scene::SMeshBuffer();
+	video::SColor c(255,255,255,255);
+	video::S3DVertex vertices[4] =
+	{
+		/*video::S3DVertex(-BS/2,-BS/4,0, 0,0,0, c, 0,1),
+		video::S3DVertex(BS/2,-BS/4,0, 0,0,0, c, 1,1),
+		video::S3DVertex(BS/2,BS/4,0, 0,0,0, c, 1,0),
+		video::S3DVertex(-BS/2,BS/4,0, 0,0,0, c, 0,0),*/
+		video::S3DVertex(BS/3,0,0, 0,0,0, c, 0,1),
+		video::S3DVertex(-BS/3,0,0, 0,0,0, c, 1,1),
+		video::S3DVertex(-BS/3,0+BS*2/3,0, 0,0,0, c, 1,0),
+		video::S3DVertex(BS/3,0+BS*2/3,0, 0,0,0, c, 0,0),
+	};
+	u16 indices[] = {0,1,2,2,3,0};
+	buf->append(vertices, 4, indices, 6);
+	// Set material
+	buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
+	buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
+	//buf->getMaterial().setTexture(0, NULL);
+	buf->getMaterial().setTexture
+			(0, driver->getTexture(porting::getDataPath("rat.png").c_str()));
+	buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
+	buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
+	buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
+	// Add to mesh
+	mesh->addMeshBuffer(buf);
+	buf->drop();
+	m_node = smgr->addMeshSceneNode(mesh, NULL);
+	mesh->drop();
+	// Set it to use the materials of the meshbuffers directly.
+	// This is needed for changing the texture in the future
+	m_node->setReadOnlyMaterials(true);
+	updateNodePos();
+}
+
+void ItemCAO::removeFromScene()
+{
+	if(m_node == NULL)
+		return;
+
+	m_node->remove();
+	m_node = NULL;
+}
+
+void ItemCAO::updateLight(u8 light_at_pos)
+{
+}
+
+v3s16 ItemCAO::getLightPosition()
+{
+	return floatToInt(m_position, BS);
+}
+
+void ItemCAO::updateNodePos()
+{
+	if(m_node == NULL)
+		return;
+
+	m_node->setPosition(m_position);
+}
+
+void ItemCAO::step(float dtime)
+{
+	if(m_node)
+	{
+		v3f rot = m_node->getRotation();
+		rot.Y += dtime * 120;
+		m_node->setRotation(rot);
+	}
+}
+
+void ItemCAO::processMessage(const std::string &data)
+{
+	dstream<<"ItemCAO: Got data: "<<data<<std::endl;
+	std::istringstream is(data, std::ios::binary);
+	u16 cmd;
+	is>>cmd;
+	if(cmd == 0)
+	{
+		v3f newpos;
+		is>>newpos.X;
+		is>>newpos.Y;
+		is>>newpos.Z;
+		m_position = newpos;
+		updateNodePos();
+	}
+}
+
+void ItemCAO::initialize(const std::string &data)
+{
+	dstream<<"ItemCAO: Got init data: "<<data<<std::endl;
+	
+	Strfnd fn(data);
+
+	v3f newpos;
+	newpos.X = stoi(fn.next(","));
+	newpos.Y = stoi(fn.next(","));
+	newpos.Z = stoi(fn.next(":"));
+	m_position = newpos;
+	updateNodePos();
+
+	m_inventorystring = fn.next("");
+
+	if(m_node == NULL)
+		return;
+
+	scene::IMesh *mesh = m_node->getMesh();
+
+	if(mesh == NULL)
+		return;
+	
+	scene::IMeshBuffer *buf = mesh->getMeshBuffer(0);
+
+	if(buf == NULL)
+		return;
+
+	/*
+		Create an inventory item to see what is its image
+	*/
+	std::istringstream is(m_inventorystring, std::ios_base::binary);
+	video::ITexture *texture = NULL;
+	try{
+		InventoryItem *item = NULL;
+		item = InventoryItem::deSerialize(is);
+		dstream<<__FUNCTION_NAME<<": m_inventorystring=\""
+				<<m_inventorystring<<"\" -> item="<<item
+				<<std::endl;
+		if(item)
+		{
+			texture = item->getImage();
+			delete item;
+		}
+	}
+	catch(SerializationError &e)
+	{
+		dstream<<"WARNING: "<<__FUNCTION_NAME
+				<<": error deSerializing inventorystring \""
+				<<m_inventorystring<<"\""<<std::endl;
+	}
+	
+	// Set meshbuffer texture
+	buf->getMaterial().setTexture(0, texture);
+	
+}
+