From pybind11 and Boost.Python​

struct Entity {
    virtual ~Entity() = default;
    std::string name = "entity";
    virtual std::string describe() const { return "entity " + name; }
};

struct Monster : Entity {
    int64_t hp = 10;
    Monster() = default;
    Monster(std::string a_name, int64_t a_hp) : hp(a_hp) { name = std::move(a_name); }
    void damage(int64_t amount) { hp -= amount; }
    void damage(int64_t amount, double multiplier) { hp -= static_cast<int64_t>(amount * multiplier); }
    int64_t health() const { return hp; }
    void setHealth(int64_t a_hp) { hp = a_hp < 0 ? 0 : a_hp; }
    bool alive() const { return hp > 0; }
    std::string describe() const override { return "monster " + name; }
    bool operator==(const Monster& o) const { return name == o.name && hp == o.hp; }
};

int64_t load_level(const std::string& name) {
    if (name.empty()) { throw std::runtime_error("level name is empty"); }
    return 1;
}

#include <pybind11/embed.h>
#include <pybind11/operators.h>

namespace py = pybind11;

PYBIND11_EMBEDDED_MODULE(game, m) {
    py::class_<Entity, std::shared_ptr<Entity>>(m, "Entity")
        .def_readwrite("name", &Entity::name)
        .def("describe", &Entity::describe);

    py::class_<Monster, Entity, std::shared_ptr<Monster>>(m, "Monster")
        .def(py::init<>())
        .def(py::init<std::string, int64_t>())
        .def("damage", py::overload_cast<int64_t>(&Monster::damage))
        .def("damage", py::overload_cast<int64_t, double>(&Monster::damage))
        .def("alive", &Monster::alive)
        .def_property("hp", &Monster::health, &Monster::setHealth)
        .def_property_readonly("max_hp", [](const Monster&) { return int64_t{100}; })
        .def(py::self == py::self);

    m.def("describe", [](std::shared_ptr<Entity> e) { return e->describe(); });
    m.def("load_level", &load_level);
    m.attr("HOST_SEED") = 42;
}

#include <boost/python.hpp>

int64_t monster_max_hp(const Monster&) { return 100; }

BOOST_PYTHON_MODULE(game) {
    using namespace boost::python;
    class_<Entity, std::shared_ptr<Entity>>("Entity")
        .def_readwrite("name", &Entity::name)
        .def("describe", &Entity::describe);

    class_<Monster, bases<Entity>, std::shared_ptr<Monster>>("Monster", init<>())
        .def(init<std::string, int64_t>())
        .def("damage", static_cast<void (Monster::*)(int64_t)>(&Monster::damage))
        .def("damage", static_cast<void (Monster::*)(int64_t, double)>(&Monster::damage))
        .def("alive", &Monster::alive)
        .add_property("hp", &Monster::health, &Monster::setHealth)
        .add_property("max_hp", &monster_max_hp)
        .def(self == self);

    def("load_level", &load_level);
}

#include <jaiscript/jaiscript.hpp>
#include <jaiscript/stdlib/stdlib.hpp>

void bind_game(jai::engine& eng) {
    jai::dynamic_binder<Entity>(eng, "Entity")
        .property("name", &Entity::name)
        .method("describe", &Entity::describe)
        .build();

    jai::dynamic_binder<Monster>(eng, "Monster")
        .base_class<Entity>()
        .constructor<>()
        .constructor<std::string, int64_t>()
        .method("damage", static_cast<void (Monster::*)(int64_t)>(&Monster::damage))
        .method("damage", static_cast<void (Monster::*)(int64_t, double)>(&Monster::damage))
        .method("alive", &Monster::alive)
        .method("==", &Monster::operator==)
        .property("hp", &Monster::health, &Monster::setHealth)
        .property("max_hp", [](const Monster&) { return int64_t{100}; }, nullptr)
        .build();

    eng.add_function("describe", [](std::shared_ptr<Entity> e) { return e->describe(); });
    eng.add_function("load_level", &load_level);
    eng.add_global("HOST_SEED", int64_t{42});
}

py::scoped_interpreter guard{};
py::exec("def damage_for(level):\n    return level * 3\n");
py::object damage_for = py::module_::import("__main__").attr("damage_for");
int64_t dmg = damage_for(4).cast<int64_t>();                   // 12

auto boss = std::make_shared<Monster>("boss", 50);
py::module_::import("__main__").attr("boss") = boss;
py::exec("boss.damage(20)");                                     // boss->hp is 30

try {
    py::exec("raise ValueError('from script')");
} catch (const py::error_already_set& e) {
    std::cerr << e.what();
}

auto eng = jai::engine::make();
jai::stdlib::register_all(eng);
bind_game(*eng);
eng->execute("int damage_for(int level) { return level * 3; }");
auto damage_for = jai::convert_script_function<int64_t(int64_t)>(eng->get_variable("damage_for"));
int64_t dmg = damage_for(4);                                     // 12

auto boss = std::make_shared<Monster>("boss", 50);
eng->add_global("boss", eng->make_object(boss));
eng->execute("boss.damage(20);");                                // boss->hp is 30

try {
    eng->execute("throw \"from script\";");
} catch (const jai::script_exception& e) {
    std::cerr << e.what();                                       // from script
}