#include "UnrealEnginePythonPrivatePCH.h"

#include "Kismet/KismetSystemLibrary.h"

#include "UEPySpline.h"

#include "UEPyNavigation.h"

#include "UEPyInput.h"

DEFINE_LOG_CATEGORY(LogPython);

PyDoc_STRVAR(unreal_engine_py_doc, "Unreal Engine Python module.");

static PyModuleDef unreal_engine_module = {

PyModuleDef_HEAD_INIT,

"unreal_engine",

unreal_engine_py_doc,

-1,

NULL,

};

static PyObject *init_unreal_engine(void) {

return PyModule_Create(&unreal_engine_module);

}

static PyObject *py_unreal_engine_log(PyObject * self, PyObject * args) {

char *message;

if (!PyArg_ParseTuple(args, "s:log", &message)) {

return NULL;

}

UE_LOG(LogPython, Log, TEXT("%s"), UTF8_TO_TCHAR(message));

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_unreal_engine_log_warning(PyObject * self, PyObject * args) {

char *message;

if (!PyArg_ParseTuple(args, "s:log_warning", &message)) {

return NULL;

}

UE_LOG(LogPython, Warning, TEXT("%s"), UTF8_TO_TCHAR(message));

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_unreal_engine_log_error(PyObject * self, PyObject * args) {

char *message;

if (!PyArg_ParseTuple(args, "s:log_error", &message)) {

return NULL;

}

UE_LOG(LogPython, Error, TEXT("%s"), UTF8_TO_TCHAR(message));

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_unreal_engine_add_on_screen_debug_message(PyObject * self, PyObject * args) {

int key;

float time_to_display;

char *message;

if (!PyArg_ParseTuple(args, "ifs:add_on_screen_debug_message", &key, &time_to_display, &message)) {

return NULL;

}

if (!GEngine)

goto end;

GEngine->AddOnScreenDebugMessage(key, time_to_display, FColor::Green, FString::Printf(TEXT("%s"), UTF8_TO_TCHAR(message)));

end:

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_unreal_engine_print_string(PyObject * self, PyObject * args) {

char *message;

if (!PyArg_ParseTuple(args, "s:print_string", &message)) {

return NULL;

}

if (!GEngine)

goto end;

GEngine->AddOnScreenDebugMessage(-1, 2.0, FColor::Cyan, FString::Printf(TEXT("%s"), UTF8_TO_TCHAR(message)));

end:

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_unreal_engine_find_class(PyObject * self, PyObject * args) {

char *name;

if (!PyArg_ParseTuple(args, "s:find_class", &name)) {

return NULL;

}

UClass *u_class = FindObject<UClass>(ANY_PACKAGE, UTF8_TO_TCHAR(name));

if (u_class) {

ue_PyUObject *ret = ue_get_python_wrapper(u_class);

if (!ret)

return PyErr_Format(PyExc_Exception, "uobject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_unreal_engine_find_object(PyObject * self, PyObject * args) {

char *name;

if (!PyArg_ParseTuple(args, "s:find_object", &name)) {

return NULL;

}

UObject *u_object = FindObject<UObject>(ANY_PACKAGE, UTF8_TO_TCHAR(name));

if (u_object) {

ue_PyUObject *ret = ue_get_python_wrapper(u_object);

if (!ret)

return PyErr_Format(PyExc_Exception, "uobject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

Py_INCREF(Py_None);

return Py_None;

}

#if WITH_EDITOR

static PyObject *py_unreal_engine_get_editor_world(PyObject * self, PyObject * args) {

if (!GEditor)

return PyErr_Format(PyExc_Exception, "no GEditor found");

UWorld *world = GEditor->GetEditorWorldContext().World();

ue_PyUObject *ret = ue_get_python_wrapper(world);

if (!ret)

return PyErr_Format(PyExc_Exception, "uobject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

#endif

static PyObject *py_unreal_engine_vector_add_vector(PyObject * self, PyObject *args) {

float x = 0, y = 0, z = 0;

Py_ssize_t items = PyTuple_Size(args);

if ((items % 3) != 0) {

return PyErr_Format(PyExc_TypeError, "this function requires a 3-multiple number of args");

}

for (int i = 0; i < (int)items; i += 3) {

PyObject *x_py = PyTuple_GetItem(args, i);

if (!PyFloat_Check(x_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

x += (float)PyFloat_AsDouble(x_py);

PyObject *y_py = PyTuple_GetItem(args, i + 1);

if (!PyFloat_Check(y_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (y)");

y += (float)PyFloat_AsDouble(y_py);

PyObject *z_py = PyTuple_GetItem(args, i + 2);

if (!PyFloat_Check(z_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (z)");

z += (float)PyFloat_AsDouble(z_py);

}

return Py_BuildValue("fff", x, y, z);

}

static PyObject *py_unreal_engine_vector_add_float(PyObject * self, PyObject *args) {

float x = 0, y = 0, z = 0;

Py_ssize_t items = PyTuple_Size(args);

if (items < 3) {

return PyErr_Format(PyExc_TypeError, "this function requires a xyz vector");

}

PyObject *x_py = PyTuple_GetItem(args, 0);

if (!PyFloat_Check(x_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

x = (float)PyFloat_AsDouble(x_py);

PyObject *y_py = PyTuple_GetItem(args, 1);

if (!PyFloat_Check(y_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

y = (float)PyFloat_AsDouble(y_py);

PyObject *z_py = PyTuple_GetItem(args, 2);

if (!PyFloat_Check(z_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

z = (float)PyFloat_AsDouble(z_py);

for (int i = 3; i < (int)items; i++) {

PyObject *delta_py = PyTuple_GetItem(args, i);

if (!PyFloat_Check(delta_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values");

float delta = (float)PyFloat_AsDouble(delta_py);

x += delta;

y += delta;

z += delta;

}

return Py_BuildValue("fff", x, y, z);

}

static PyObject *py_unreal_engine_vector_mul_vector(PyObject * self, PyObject *args) {

float x = 1, y = 1, z = 1;

Py_ssize_t items = PyTuple_Size(args);

if ((items % 3) != 0) {

return PyErr_Format(PyExc_TypeError, "this function requires a 3-multiple number of args");

}

for (int i = 0; i < (int)items; i += 3) {

PyObject *x_py = PyTuple_GetItem(args, i);

if (!PyFloat_Check(x_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

x *= (float)PyFloat_AsDouble(x_py);

PyObject *y_py = PyTuple_GetItem(args, i + 1);

if (!PyFloat_Check(y_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (y)");

y *= (float)PyFloat_AsDouble(y_py);

PyObject *z_py = PyTuple_GetItem(args, i + 2);

if (!PyFloat_Check(z_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (z)");

z *= (float)PyFloat_AsDouble(z_py);

}

return Py_BuildValue("fff", x, y, z);

}

static PyObject *py_unreal_engine_vector_mul_float(PyObject * self, PyObject *args) {

float x = 0, y = 0, z = 0;

Py_ssize_t items = PyTuple_Size(args);

if (items < 3) {

return PyErr_Format(PyExc_TypeError, "this function requires a xyz vector");

}

PyObject *x_py = PyTuple_GetItem(args, 0);

if (!PyFloat_Check(x_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

x = (float)PyFloat_AsDouble(x_py);

PyObject *y_py = PyTuple_GetItem(args, 1);

if (!PyFloat_Check(y_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

y = (float)PyFloat_AsDouble(y_py);

PyObject *z_py = PyTuple_GetItem(args, 2);

if (!PyFloat_Check(z_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values (x)");

z = (float)PyFloat_AsDouble(z_py);

for (int i = 3; i < (int)items; i++) {

PyObject *delta_py = PyTuple_GetItem(args, i);

if (!PyFloat_Check(delta_py))

return PyErr_Format(PyExc_TypeError, "this function supports only float values");

float delta = (float)PyFloat_AsDouble(delta_py);

x *= delta;

y *= delta;

z *= delta;

}

return Py_BuildValue("fff", x, y, z);

}

static PyMethodDef unreal_engine_methods[] = {

{ "log", py_unreal_engine_log, METH_VARARGS, "" },

{ "log_warning", py_unreal_engine_log_warning, METH_VARARGS, "" },

{ "log_error", py_unreal_engine_log_error, METH_VARARGS, "" },

{ "add_on_screen_debug_message", py_unreal_engine_add_on_screen_debug_message, METH_VARARGS, "" },

{ "print_string", py_unreal_engine_print_string, METH_VARARGS, "" },

#if WITH_EDITOR

{ "get_editor_world()", py_unreal_engine_get_editor_world, METH_VARARGS, "" },

#endif

{ "find_class", py_unreal_engine_find_class, METH_VARARGS, "" },

{ "find_object", py_unreal_engine_find_object, METH_VARARGS, "" },

{ "vector_add_vector", py_unreal_engine_vector_add_vector, METH_VARARGS, "" },

{ "vector_add_float", py_unreal_engine_vector_add_float, METH_VARARGS, "" },

{ "vector_mul_vector", py_unreal_engine_vector_mul_vector, METH_VARARGS, "" },

{ "vector_mul_float", py_unreal_engine_vector_mul_float, METH_VARARGS, "" },

{ NULL, NULL },

};

static PyObject *py_ue_call(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

char *call_args;

if (!PyArg_ParseTuple(args, "s:call", &call_args)) {

return NULL;

}

FOutputDeviceNull od_null;

if (!self->ue_object->CallFunctionByNameWithArguments(UTF8_TO_TCHAR(call_args), od_null, NULL, true)) {

return PyErr_Format(PyExc_Exception, "error while calling \"%s\"", call_args);

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_get_property(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

char *property_name;

if (!PyArg_ParseTuple(args, "s:get_property", &property_name)) {

return NULL;

}

UProperty *u_property = self->ue_object->GetClass()->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

return ue_py_convert_property(u_property, (uint8 *)self->ue_object);

}

static PyObject *py_ue_set_property(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

char *property_name;

PyObject *property_value;

if (!PyArg_ParseTuple(args, "sO:set_property", &property_name, &property_value)) {

return NULL;

}

UProperty *u_property = self->ue_object->GetClass()->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

return PyErr_Format(PyExc_Exception, "unable to find property %s", property_name);

if (!ue_py_convert_pyobject(property_value, u_property, (uint8 *)self->ue_object)) {

return PyErr_Format(PyExc_Exception, "unable to set property %s", property_name);

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_properties(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

PyObject *ret = PyList_New(0);

for (TFieldIterator<UProperty> PropIt(self->ue_object->GetClass()); PropIt; ++PropIt)

{

UProperty* property = *PropIt;

PyObject *property_name = PyUnicode_FromString(TCHAR_TO_UTF8(*property->GetName()));

PyList_Append(ret, property_name);

Py_DECREF(property_name);

}

return ret;

}

static PyObject *py_ue_get_owner(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

if (!self->ue_object->IsA<UActorComponent>()) {

return PyErr_Format(PyExc_Exception, "uobject is not a component");

}

UActorComponent *component = (UActorComponent *)self->ue_object;

ue_PyUObject *ret = ue_get_python_wrapper(component->GetOwner());

if (!ret)

return PyErr_Format(PyExc_Exception, "uobject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

static PyObject *py_ue_get_name(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

return PyUnicode_FromString(TCHAR_TO_UTF8(*(self->ue_object->GetName())));

}

static PyObject *py_ue_get_full_name(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

return PyUnicode_FromString(TCHAR_TO_UTF8(*(self->ue_object->GetFullName())));

}

#if WITH_EDITOR

static PyObject *py_ue_get_actor_label(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

if (self->ue_object->IsA<AActor>()) {

AActor *actor = (AActor *)self->ue_object;

return PyUnicode_FromString(TCHAR_TO_UTF8(*(actor->GetActorLabel())));

}

if (self->ue_object->IsA<UActorComponent>()) {

UActorComponent *component = (UActorComponent *)self->ue_object;

return PyUnicode_FromString(TCHAR_TO_UTF8(*(component->GetOwner()->GetActorLabel())));

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

}

#endif

static PyObject *py_ue_get_actor_location(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

FVector vec3;

if (self->ue_object->IsA<AActor>()) {

vec3 = ((AActor *)self->ue_object)->GetActorLocation();

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

vec3 = ((UActorComponent *)self->ue_object)->GetOwner()->GetActorLocation();

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

return Py_BuildValue("fff", vec3.X, vec3.Y, vec3.Z);

}

static PyObject *py_ue_get_actor_forward(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

FVector vec3;

if (self->ue_object->IsA<AActor>()) {

vec3 = ((AActor *)self->ue_object)->GetActorForwardVector();

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

vec3 = ((UActorComponent *)self->ue_object)->GetOwner()->GetActorForwardVector();

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

return Py_BuildValue("fff", vec3.X, vec3.Y, vec3.Z);

}

static PyObject *py_ue_get_actor_right(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

FVector vec3;

if (self->ue_object->IsA<AActor>()) {

vec3 = ((AActor *)self->ue_object)->GetActorRightVector();

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

vec3 = ((UActorComponent *)self->ue_object)->GetOwner()->GetActorRightVector();

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

return Py_BuildValue("fff", vec3.X, vec3.Y, vec3.Z);

}

static PyObject *py_ue_get_actor_up(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

FVector vec3;

if (self->ue_object->IsA<AActor>()) {

vec3 = ((AActor *)self->ue_object)->GetActorUpVector();

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

vec3 = ((UActorComponent *)self->ue_object)->GetOwner()->GetActorUpVector();

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

return Py_BuildValue("fff", vec3.X, vec3.Y, vec3.Z);

}

static PyObject *py_ue_get_actor_rotation(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

FRotator vec3;

if (self->ue_object->IsA<AActor>()) {

vec3 = ((AActor *)self->ue_object)->GetActorRotation();

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

vec3 = ((UActorComponent *)self->ue_object)->GetOwner()->GetActorRotation();

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

return Py_BuildValue("fff", vec3.Pitch, vec3.Yaw, vec3.Roll);

}

static PyObject *py_ue_get_actor_velocity(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

FVector vec3;

if (self->ue_object->IsA<AActor>()) {

vec3 = ((AActor *)self->ue_object)->GetVelocity();

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

vec3 = ((UActorComponent *)self->ue_object)->GetOwner()->GetVelocity();

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

return Py_BuildValue("fff", vec3.X, vec3.Y, vec3.Z);

}

static PyObject *py_ue_quit_game(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

UWorld *world = ue_get_uworld(self);

if (!world)

return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");

UKismetSystemLibrary::QuitGame(world, world->GetFirstPlayerController(), EQuitPreference::Quit);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_get_world(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

UWorld *world = ue_get_uworld(self);

if (!world)

return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");

ue_PyUObject *ret = ue_get_python_wrapper(world);

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

static PyObject *py_ue_set_actor_location(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

float x, y, z;

if (!PyArg_ParseTuple(args, "fff:set_actor_location", &x, &y, &z)) {

return NULL;

}

if (self->ue_object->IsA<AActor>()) {

((AActor *)self->ue_object)->SetActorLocation(FVector(x, y, z));

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

((UActorComponent *)self->ue_object)->GetOwner()->SetActorLocation(FVector(x, y, z));

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_set_actor_rotation(ue_PyUObject *self, PyObject * args) {

ue_py_check(self);

float pitch, yaw, roll;

if (!PyArg_ParseTuple(args, "fff:set_actor_rotation", &pitch, &yaw, &roll)) {

return NULL;

}

if (self->ue_object->IsA<AActor>()) {

((AActor *)self->ue_object)->SetActorRotation(FRotator(pitch, yaw, roll));

goto ret;

}

if (self->ue_object->IsA<UActorComponent>()) {

((UActorComponent *)self->ue_object)->GetOwner()->SetActorRotation(FRotator(pitch, yaw, roll));

goto ret;

}

return PyErr_Format(PyExc_Exception, "uobject is not an actor or a component");

ret:

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_find_object(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

char *name;

if (!PyArg_ParseTuple(args, "s:find_object", &name)) {

return NULL;

}

UObject *u_object = nullptr;

for (TObjectIterator<UObject> Itr; Itr; ++Itr) {

UObject *u_obj = *Itr;

if (u_obj->GetName().Equals(UTF8_TO_TCHAR(name))) {

u_object = u_obj;

break;

}

}

if (u_object) {

ue_PyUObject *ret = ue_get_python_wrapper(u_object);

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_find_function(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

char *name;

if (!PyArg_ParseTuple(args, "s:find_function", &name)) {

return NULL;

}

UFunction *function = self->ue_object->FindFunction(FName(UTF8_TO_TCHAR(name)));

if (!function)

goto end;

UE_LOG(LogPython, Warning, TEXT("Func %d %d"), function->NumParms, function->ReturnValueOffset);

ue_PyUObject *ret = ue_get_python_wrapper((UObject *)function);

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

end:

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_call_function(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

UFunction *function = nullptr;

if (PyTuple_Size(args) < 1) {

return PyErr_Format(PyExc_TypeError, "this function requires at least an argument");

}

PyObject *func_id = PyTuple_GetItem(args, 0);

if (PyUnicode_Check(func_id)) {

function = self->ue_object->FindFunction(FName(UTF8_TO_TCHAR(PyUnicode_AsUTF8(func_id))));

}

if (!function)

return PyErr_Format(PyExc_Exception, "unable to find function");

uint8 *buffer = (uint8 *)FMemory_Alloca(function->ParmsSize);

int argn = 1;

TFieldIterator<UProperty> PArgs(function);

for (; PArgs && ((PArgs->PropertyFlags & (CPF_Parm | CPF_ReturnParm)) == CPF_Parm); ++PArgs) {

UProperty *prop = *PArgs;

PyObject *py_arg = PyTuple_GetItem(args, argn);

if (!py_arg) {

return PyErr_Format(PyExc_TypeError, "not enough arguments");

}

if (!ue_py_convert_pyobject(py_arg, prop, buffer)) {

return PyErr_Format(PyExc_TypeError, "unable to convert pyobject to property");

}

argn++;

}

self->ue_object->ProcessEvent(function, buffer);

TFieldIterator<UProperty> Props(function);

for (; Props; ++Props) {

UProperty *prop = *Props;

if (prop->GetPropertyFlags() & CPF_ReturnParm) {

return ue_py_convert_property(prop, buffer);

}

}

Py_INCREF(Py_None);

return Py_None;

}

#if WITH_EDITOR

static PyObject *py_ue_find_actor_by_label(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

char *name;

if (!PyArg_ParseTuple(args, "s:find_actor_by_label", &name)) {

return NULL;

}

UWorld *world = ue_get_uworld(self);

if (!world)

return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");

UObject *u_object = nullptr;

for (TActorIterator<AActor> Itr(world); Itr; ++Itr) {

AActor *u_obj = *Itr;

if (u_obj->GetActorLabel().Equals(UTF8_TO_TCHAR(name))) {

u_object = u_obj;

break;

}

}

if (u_object) {

ue_PyUObject *ret = ue_get_python_wrapper(u_object);

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

Py_INCREF(Py_None);

return Py_None;

}

#endif

static PyObject *py_ue_get_class(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

ue_PyUObject *ret = ue_get_python_wrapper(self->ue_object->GetClass());

if (!ret)

return PyErr_Format(PyExc_Exception, "PyUObject is in invalid state");

Py_INCREF(ret);

return (PyObject *)ret;

}

static PyObject *py_ue_all_objects(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

UWorld *world = ue_get_uworld(self);

if (!world)

return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");

PyObject *ret = PyList_New(0);

for (TObjectIterator<UObject> Itr; Itr; ++Itr) {

UObject *u_obj = *Itr;

if (u_obj->GetWorld() != world)

continue;

ue_PyUObject *py_obj = ue_get_python_wrapper(u_obj);

if (!py_obj)

continue;

PyList_Append(ret, (PyObject *)py_obj);

}

return ret;

}

static PyObject *py_ue_all_actors(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

UWorld *world = ue_get_uworld(self);

if (!world)

return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");

PyObject *ret = PyList_New(0);

for (TActorIterator<AActor> Itr(world); Itr; ++Itr) {

UObject *u_obj = *Itr;

ue_PyUObject *py_obj = ue_get_python_wrapper(u_obj);

if (!py_obj)

continue;

PyList_Append(ret, (PyObject *)py_obj);

}

return ret;

}

static PyObject *py_ue_set_simulate_physics(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

bool enabled = true;

PyObject *is_true = NULL;

if (!PyArg_ParseTuple(args, "|O:set_simulate_physics", &is_true)) {

return NULL;

}

if (is_true && !PyObject_IsTrue(is_true))

enabled = false;

UPrimitiveComponent *primitive = nullptr;

if (self->ue_object->IsA<UPrimitiveComponent>()) {

primitive = (UPrimitiveComponent *)self->ue_object;

}

else {

return PyErr_Format(PyExc_Exception, "uobject is not an UPrimitiveComponent");

}

if (!primitive) {

return PyErr_Format(PyExc_Exception, "unable to set physics for the object");

}

primitive->SetSimulatePhysics(enabled);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_actor_components(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

if (!self->ue_object->IsA<AActor>()) {

return PyErr_Format(PyExc_Exception, "uobject is not an AActor");

}

AActor *actor = (AActor *)self->ue_object;

PyObject *ret = PyList_New(0);

for (UActorComponent *component : actor->GetComponents()) {

ue_PyUObject *py_obj = ue_get_python_wrapper(component);

if (!py_obj)

continue;

PyList_Append(ret, (PyObject *)py_obj);

}

return ret;

}

static PyObject *py_ue_actor_destroy(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

if (!self->ue_object->IsA<AActor>()) {

return PyErr_Format(PyExc_Exception, "uobject is not an AActor");

}

AActor *actor = (AActor *)self->ue_object;

actor->Destroy();

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_ue_actor_has_tag(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

char *tag;

if (!PyArg_ParseTuple(args, "s:actor_has_tag", &tag)) {

return NULL;

}

if (!self->ue_object->IsA<AActor>()) {

return PyErr_Format(PyExc_Exception, "uobject is not an AActor");

}

AActor *actor = (AActor *)self->ue_object;

if (actor->ActorHasTag(FName(UTF8_TO_TCHAR(tag)))) {

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

static PyObject *py_ue_get_actor_bounds(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

if (!self->ue_object->IsA<AActor>()) {

return PyErr_Format(PyExc_Exception, "uobject is not an AActor");

}

AActor *actor = (AActor *)self->ue_object;

FVector origin;

FVector extent;

actor->GetActorBounds(false, origin, extent);

return Py_BuildValue("ffffff", origin.X, origin.Y, origin.Z, extent.X, extent.Y, extent.Z);

}

static PyObject *py_ue_line_trace_single_by_channel(ue_PyUObject * self, PyObject * args) {

ue_py_check(self);

float x1 = 0, y1 = 0, z1 = 0;

float x2 = 0, y2 = 0, z2 = 0;

int channel;

UWorld *world = ue_get_uworld(self);

if (!world)

return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");