Scripting

Tsar uses C++ as scripting language to benefit from its unmatched speed and versatility as its the best OOP language.
Writing scripts is essential for creating immersive and complex games. All of your game logic will be modeled by your scripts.
For this reason our scripting interface is focused on simplicity.

Here's an example NPC logic script: Something that looks like C#

How to create a script

!!! Make sure you have a scripting project, if not generate it by executing this script:

TsarEd\assets\scripts\GenProject.py

You should now have a default Sandbox solution
All script classes must be created in TsarScript namespace.

Using Editor

Soon to be supported!

Using Visual Studio

1. Navigate your source folder and create .hxx and .cxx files with desired name
2. In the header file(.hxx) add your class following this pattern:

MyExampleClass.hxx

#include "ScriptEngine.hxx"

namespace TsarScript
{
   TClass()
   class MyExampleClass : public Entity
   {
       TFunc()
       void SomePrintFunc();
   };

   TClass()
   class MyPlayer : public Entity
   {
   GENERATE_BODY()

   private: 
       TFunc()
       void Start();

       TFunc()
       void Update(float dt);
   };
}

Change MyExampleClass with your script/class name, you can have as many classes you want in single header.
TClass() is used for Reflection so Tsar and your classes can work together.

3. In source file(.cxx) include your header and define your functions:

MyExampleClass.cxx

#include "MyExampleClass.hxx"

#include "scripting/Input.hxx" //for MyPlayer input

#include "scripting/Debug.hxx" //for MyClassExample

namespace TsarScript
{
   void MyClassExample::SomePrintFunc()
   {
       Debug::LogInfo("something happened");
   }

   void MyPlayer::Start()
   {

   }

   void MyPlayer::Update(float dt)
   {
       if (Input::GetKeyPressed(KeyCode::T))
       {
   	    std::cout << m_Entity.GetName() << '\n';
       }
   }
}

Adding Functions/Methods

There are two types of functions/methods: Reflective and Normal.

Normal functions are your typical C++ methods, which Tsar knows nothing about.

void MyFunction(); // No engine context here

If you need your function to be seen by Tsar you should use Reflective functions/methods, which are declared with TFunc() before them like this:

TFunc()
void MyFunction(); // Can use engine functionality

If your function should access anything from Tsar, like components, scripts, assets you must define your function with TFunc().
If the function is purely C++ logic, you don’t need TFunc().

Adding Properties

Similar to functions, Properties can use reflection, but mainly for modification in Editor.
For example, take this AudioSource component

TClass();
class DumbAI : public Entity
{
public:
	AudioSource m_BigSwing; //Not seen in Editor
};

Written like that AudioSource cannot be assigned/referenced/modified from Editor.

If you want to expose the Property to Editor use TProperty() before declaration.

TClass();
class DumbAI : public Entity
{
public:
    TProperty();
	AudioSource m_BigSwing; //Modifiable in Editor
};

Tsar Docs