Using Custom Component System

#pragma once
#include <UnigineGame.h>
#include <UnigineControls.h>

// include the header file of the Component System
#include "ComponentSystem/ComponentSystem.h"

// derive our class from the ComponentBase
class Pawn : public ComponentBase
{
public:
	// declare constructor and destructor for our class
	Pawn(const NodePtr &node, int num) : ComponentBase(node, num) {}
	virtual ~Pawn() {}

	// property name. A pawn.prop file containing all parameters listed below will be saved in your project's data folder
	static const char* getPropertyName() { return "pawn"; }

	// parameters
	PROPERTY_PARAMETER(String, name, "Pawn1");		// Pawn's name
	PROPERTY_PARAMETER(Int, health, 200);			// health points
	PROPERTY_PARAMETER(Float, move_speed, 4.0f);	// move speed (meters/s)
	PROPERTY_PARAMETER(Float, turn_speed, 90.0f);	// turn speed (deg/s)

	// methods
	void hit(int damage);	// decrease Pawn's HP 

protected:
	// world main loop overrides
	void init() override;
	void update() override;
	void shutdown() override;

private:
	// auxiliary parameters and functions
	ControlsPtr controls;
	PlayerPtr player;
	
	float damage_effect_timer = 0;
	Mat4 default_model_view;

	void show_damage_effect();
};

#pragma once
#include <UnigineMaterial.h>
#include "ComponentSystem/ComponentSystem.h"

class Spinner : public ComponentBase
{
public:
	Spinner(const NodePtr &node, int num) : ComponentBase(node, num) { }
	virtual ~Spinner() {}

	// property name
	static const char* getPropertyName() { return "spinner"; }

	// parameters
	PROPERTY_PARAMETER(Float, turn_speed, 30.0f);
	PROPERTY_PARAMETER(Float, acceleration, 5.0f);
	
	PROPERTY_PARAMETER(Node, spawn_node);
	PROPERTY_PARAMETER(Float, min_spawn_delay, 1.0f);
	PROPERTY_PARAMETER(Float, max_spawn_delay, 4.0f);

protected:
	// world main loop
	void init() override;
	void update() override;

private:
	float start_turn_speed = 0;
	float color_offset = 0;
	float time_to_spawn = 0;
	MaterialPtr material;

	// converter from HSV to RGB color model
	vec3 hsv2rgb(float h, float s, float v);
};

#pragma once
#include <UnigineMaterial.h>
#include "ComponentSystem/ComponentSystem.h"

class Projectile :
	public ComponentBase
{
public:
	Projectile(const NodePtr &node, int num) : ComponentBase(node, num) {}
	virtual ~Projectile() {}

	// property name
	static const char* getPropertyName() { return "projectile"; }

	// parameters
	PROPERTY_PARAMETER(Float, speed, 5.0f);
	PROPERTY_PARAMETER(Float, lifetime, 5.0f);	// life time of the projectile (declaration with a default value)
	PROPERTY_PARAMETER(Int, damage);			// damage caused by the projectile (declaration with no default value)

	// methods
	void setMaterial(const MaterialPtr &mat);

protected:
	// world main loop
	void update() override;
};

#include <UnigineApp.h>
#include <UnigineConsole.h>
#include <UnigineEngine.h>
#include <UnigineGame.h>
#include <UnigineLights.h>
#include <UnigineLogic.h>
#include <UnigineWorld.h>
#include <UnigineGui.h>
#include <UnigineWidgets.h>

#include "ComponentSystem/ComponentSystem.h"
#include "Spinner.h"
#include "Projectile.h"
#include "Pawn.h"

using namespace Unigine;
using namespace Math;

//////////////////////////////////////////////////////////////////////////
// System logic class
//////////////////////////////////////////////////////////////////////////

class AppSystemLogic : public SystemLogic
{
public:
	AppSystemLogic() {}
	virtual ~AppSystemLogic() {}
	virtual int init()
	{
		// register user components
		ComponentSystem::get()->registerComponent<Spinner>();
		ComponentSystem::get()->registerComponent<Projectile>();
		ComponentSystem::get()->registerComponent<Pawn>();

		// run in background
		App::get()->setUpdate(1);

		// load world
		Console::get()->run("world_load data/cs");

		return 1;
	}
};

//////////////////////////////////////////////////////////////////////////
// World logic class
//////////////////////////////////////////////////////////////////////////

class AppWorldLogic : public WorldLogic
{
public:
	AppWorldLogic() {}
	virtual ~AppWorldLogic() {}
	virtual int init()
	{
		// create static camera
		player = PlayerDummy::create();
		player->release();
		player->setPosition(Vec3(17.0f));
		player->setDirection(vec3(-1.0f), vec3(0.0f, 0.0f, 1.0f));
		Game::get()->setPlayer(player->getPlayer());

		// create light
		sun = LightWorld::create(vec4::ONE);
		sun->release();
		sun->setName("Sun");
		sun->setWorldRotation(Math::quat(45.0f, 30.0f, 300.0f));

		// Note:
        // If you create objects without any components, you have to
        // declare their smart pointers (Ptr) outside the init() method
        // (just like the PlayerDummy and the LightWorld above).
        // Otherwise such objects will be destroyed right after
        // init() method is finished.
        
        // On the other hand, you can create objects within a local scope
        // (like ObjectMeshDynamics below) such objects won't be destroyed,
        // if you use the release() method and add some Components to them.
		
		// create objects
		ObjectMeshDynamicPtr obj[4];
		obj[0] = create_box(translate(Vec3(-16.0f, 0.0f, 0.0f)), vec3(1.0f));
		obj[1] = create_box(translate(Vec3(16.0f, 0.0f, 0.0f)), vec3(1.0f));
		obj[2] = create_box(translate(Vec3(0.0f, -16.0f, 0.0f)), vec3(1.0f));
		obj[3] = create_box(translate(Vec3(0.0f, 16.0f, 0.0f)), vec3(1.0f));

		// there are two ways to create components on nodes:
		// 1) via component system
		ComponentSystem::get()->addComponent<Spinner>(obj[0]->getNode());
		ComponentSystem::get()->addComponent<Spinner>(obj[1]->getNode());

		// 2) via property
		obj[2]->addProperty("spinner");
		obj[3]->setProperty(0, "spinner");

		// set up spinners (set "spawn_node" variable)
		ObjectMeshDynamicPtr projectile_obj = create_box(Mat4::IDENTITY, vec3(0.15f));
		projectile_obj->setEnabled(0);
		for (int i = 0; i < 4; i++)
			ComponentSystem::get()->getComponent<Spinner>(obj[i]->getNode())->spawn_node = projectile_obj->getNode();

		// create player
		ObjectMeshDynamicPtr my_pawn_object = create_box(translate(Vec3(1.0f, 1.0f, 0.0f)), vec3(1.3f, 1.3f, 0.3f));
		my_pawn = ComponentSystem::get()->addComponent<Pawn>(my_pawn_object->getNode());
		my_pawn->setDestroyCallback(MakeCallback(this, &AppWorldLogic::my_pawn_destroyed));
		time = 0;

		// create info label
		label = WidgetLabel::create(Gui::get());
		label->setPosition(10, 10);
		label->setFontSize(24);
		label->setFontOutline(1);
		Gui::get()->addChild(label->getWidget(), Gui::ALIGN_OVERLAP);

		return 1;
	}

	virtual int update()
	{
		// increase time while player is alive
		if (my_pawn)
			time += Game::get()->getIFps();

		// show game info
		label->setText(String::format(
			"Player:\n"
			"Health Points: %d\n"
			"Time: %.1f sec\n"
			"\n"
			"Statisics:\n"
			"Components: %d",
			(my_pawn ? my_pawn->health.get() : 0),
			time,
			ComponentSystem::get()->getNumComponents()).get());

		return 1;
	}

private:
	Pawn* my_pawn {nullptr};	// Pawn player
	float time = 0;
	WidgetLabelPtr label;
	PlayerDummyPtr player;
	LightWorldPtr sun;
	
	void my_pawn_destroyed()
	{
		my_pawn = nullptr;
	}
	// method creating a box
	ObjectMeshDynamicPtr create_box(const Mat4 &transform, const vec3 &size)
	{
		MeshPtr mesh = Mesh::create();
		mesh->addBoxSurface("box", size);

		ObjectMeshDynamicPtr object = ObjectMeshDynamic::create(1);
		object->setMesh(mesh);
		object->setWorldTransform(transform);
		object->setMaterial("mesh_base", "*");
		object->setSurfaceProperty("surface_base", "*");
		
		// note: if you plan to add some components to this object
        // you have to use release() method to transfer ownership of this
        // object to the Component System
		object->release();

		return object;
	}
};

//////////////////////////////////////////////////////////////////////////
// Main
//////////////////////////////////////////////////////////////////////////

int main(int argc, char **argv)
{
	// init engine
	EnginePtr engine(UNIGINE_VERSION, argc, argv);

	// enter main loop
	AppWorldLogic world_logic;
	AppSystemLogic system_logic;
	engine->main(&system_logic, &world_logic, NULL);

	return 0;
}