Using C++ Component System

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

// include the header file of the Component System
#include <UnigineComponentSystem.h>

using namespace Unigine;
using namespace Math;

// derive our class from the ComponentBase
class Pawn : public ComponentBase
{
public:
	// declare constructor and destructor for our class and define a property name. The Pawn.prop file containing all parameters listed below will be saved in your project's data folder
	COMPONENT_DEFINE(Pawn, ComponentBase)
	// declare methods to be called at the corresponding stages of the execution sequence
	COMPONENT_INIT(init);
	COMPONENT_UPDATE(update);
	COMPONENT_SHUTDOWN(shutdown);



	// parameters
	PROP_PARAM(String, name, "Pawn1");		// Pawn's name
	PROP_PARAM(Int, health, 200);			// health points
	PROP_PARAM(Float, move_speed, 4.0f);	// move speed (meters/s)
	PROP_PARAM(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();
	void update();
	void shutdown();

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 <UnigineComponentSystem.h>

using namespace Unigine;
using namespace Math;

class Spinner : public ComponentBase
{
public:
	// declare constructor and destructor for the Spinner class
	COMPONENT_DEFINE(Spinner, ComponentBase);
	
	// declare methods to be called at the corresponding stages of the execution sequence
	COMPONENT_INIT(init);
	COMPONENT_UPDATE(update);
	
	

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

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

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 <UnigineComponentSystem.h>

using namespace Unigine;

class Projectile : public ComponentBase
{
public:
	// declare constructor and destructor for the Projectile class
	COMPONENT(Projectile, ComponentBase);
	
	// declare methods to be called at the corresponding stages of the execution sequence
	COMPONENT_UPDATE(update);
	
	

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

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

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

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

#include <UnigineComponentSystem.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()
	{
		// initialize ComponentSystem and register all components
		Unigine::ComponentSystem::get()->initialize();

		// run in background
		App::setBackgroundUpdate(1);

		// load world
		World::loadWorld("cs");

		return 1;
	}
};

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

class AppWorldLogic : public WorldLogic
{
public:
	AppWorldLogic() {}
	virtual ~AppWorldLogic() {}
	virtual int init()
	{
		// create static camera
		player = PlayerDummy::create();

		player->setPosition(Vec3(17.0f));
		player->setDirection(vec3(-1.0f), vec3(0.0f, 0.0f, 1.0f));
		Game::setPlayer(player);

		// create light
		sun = LightWorld::create(vec4_one);

		sun->setName("Sun");
		sun->setWorldRotation(Math::quat(45.0f, 30.0f, 300.0f));

		// Note: objects are added to the world when created
		
		// 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]);
		ComponentSystem::get()->addComponent<Spinner>(obj[1]);

		// 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])->spawn_node = projectile_obj;

		// 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);
		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, Gui::ALIGN_OVERLAP);

		return 1;
	}

	virtual int update()
	{
		// increase time while player is alive
		if (my_pawn)
			time += Game::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);

		return object;
	}
};

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

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

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

	return 0;
}