#include "UEPyObject.h"

#include "PythonDelegate.h"

#include "PythonFunction.h"

#include "Components/ActorComponent.h"

#include "Engine/UserDefinedEnum.h"

#if WITH_EDITOR

#include "Runtime/AssetRegistry/Public/AssetRegistryModule.h"

#include "ObjectTools.h"

#include "UnrealEd.h"

#include "Runtime/Core/Public/HAL/FeedbackContextAnsi.h"

#include "Wrappers/UEPyFObjectThumbnail.h"

#endif

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

{

ue_py_check(self);

Py_RETURN_UOBJECT(self->ue_object->GetClass());

}

PyObject *py_ue_class_generated_by(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

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

UObject *u_object = u_class->ClassGeneratedBy;

if (!u_object)

Py_RETURN_NONE;

Py_RETURN_UOBJECT(u_object);

}

PyObject *py_ue_class_get_flags(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

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

return PyLong_FromUnsignedLongLong((uint64)u_class->GetClassFlags());

}

PyObject *py_ue_class_set_flags(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

uint64 flags;

if (!PyArg_ParseTuple(args, "K:class_set_flags", &flags))

{

return nullptr;

}

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

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

u_class->ClassFlags = (EClassFlags)flags;

Py_RETURN_NONE;

}

PyObject *py_ue_get_obj_flags(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

return PyLong_FromUnsignedLongLong((uint64)self->ue_object->GetFlags());

}

PyObject *py_ue_set_obj_flags(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

uint64 flags;

if (!PyArg_ParseTuple(args, "K:set_obj_flags", &flags))

{

return nullptr;

}

self->ue_object->SetFlags((EObjectFlags)flags);

Py_RETURN_NONE;

}

#if WITH_EDITOR

PyObject *py_ue_class_set_config_name(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *config_name;

if (!PyArg_ParseTuple(args, "s:class_set_config_name", &config_name))

{

return nullptr;

}

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

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

u_class->ClassConfigName = UTF8_TO_TCHAR(config_name);

Py_RETURN_NONE;

}

PyObject *py_ue_class_get_config_name(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = ue_py_check_type<UClass>(self);

if (!u_class)

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

return PyUnicode_FromString(TCHAR_TO_UTF8(*u_class->ClassConfigName.ToString()));

}

#endif

PyObject *py_ue_get_property_struct(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *property_name;

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

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UClass>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

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

UStructProperty *prop = Cast<UStructProperty>(u_property);

if (!prop)

return PyErr_Format(PyExc_Exception, "object is not a StructProperty");

return py_ue_new_uscriptstruct(prop->Struct, prop->ContainerPtrToValuePtr<uint8>(self->ue_object));

}

PyObject *py_ue_get_super_class(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

UClass *u_class = nullptr;

if (self->ue_object->IsA<UClass>())

{

u_class = (UClass *)self->ue_object;

}

else

{

u_class = self->ue_object->GetClass();

}

Py_RETURN_UOBJECT(u_class->GetSuperClass());

}

PyObject *py_ue_get_outer(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UObject *outer = self->ue_object->GetOuter();

if (!outer)

Py_RETURN_NONE;

Py_RETURN_UOBJECT(outer);

}

PyObject *py_ue_get_outermost(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UObject *outermost = self->ue_object->GetOutermost();

if (!outermost)

Py_RETURN_NONE;

Py_RETURN_UOBJECT(outermost);

}

PyObject *py_ue_conditional_begin_destroy(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

self->ue_object->ConditionalBeginDestroy();

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_ue_is_valid(ue_PyUObject * self, PyObject * args)

{

if (!self->ue_object || !self->ue_object->IsValidLowLevel() || self->ue_object->IsPendingKillOrUnreachable())

{

Py_RETURN_FALSE;

}

Py_RETURN_TRUE;

}

PyObject *py_ue_is_a(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

PyObject *obj;

if (!PyArg_ParseTuple(args, "O:is_a", &obj))

{

return NULL;

}

if (!ue_is_pyuobject(obj))

{

return PyErr_Format(PyExc_Exception, "argument is not a UObject");

}

ue_PyUObject *py_obj = (ue_PyUObject *)obj;

if (self->ue_object->IsA((UClass *)py_obj->ue_object))

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

PyObject *py_ue_is_child_of(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

PyObject *obj;

if (!PyArg_ParseTuple(args, "O:is_child_of", &obj))

{

return NULL;

}

if (!self->ue_object->IsA<UClass>())

return PyErr_Format(PyExc_Exception, "object is not a UClass");

if (!ue_is_pyuobject(obj))

{

return PyErr_Format(PyExc_Exception, "argument is not a UObject");

}

ue_PyUObject *py_obj = (ue_PyUObject *)obj;

if (!py_obj->ue_object->IsA<UClass>())

return PyErr_Format(PyExc_Exception, "argument is not a UClass");

UClass *parent = (UClass *)py_obj->ue_object;

UClass *child = (UClass *)self->ue_object;

if (child->IsChildOf(parent))

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

PyObject *py_ue_post_edit_change(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

#if WITH_EDITOR

Py_BEGIN_ALLOW_THREADS;

self->ue_object->PostEditChange();

Py_END_ALLOW_THREADS;

#endif

Py_RETURN_NONE;

}

PyObject *py_ue_post_edit_change_property(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *prop_name = nullptr;

int change_type = 0;

if (!PyArg_ParseTuple(args, "si:post_edit_change_property", &prop_name, &change_type))

{

return nullptr;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *prop = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(prop_name)));

if (!prop)

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

#if WITH_EDITOR

Py_BEGIN_ALLOW_THREADS;

FPropertyChangedEvent changed(prop, change_type);

self->ue_object->PostEditChangeProperty(changed);

Py_END_ALLOW_THREADS;

#endif

Py_RETURN_NONE;

}

PyObject *py_ue_modify(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

#if WITH_EDITOR

Py_BEGIN_ALLOW_THREADS;

self->ue_object->Modify();

Py_END_ALLOW_THREADS;

#endif

Py_RETURN_NONE;

}

PyObject *py_ue_pre_edit_change(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UProperty *prop = nullptr;

char *prop_name = nullptr;

if (!PyArg_ParseTuple(args, "|s:pre_edit_change", &prop_name))

{

return nullptr;

}

if (prop_name)

{

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

prop = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(prop_name)));

if (!prop)

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

}

#if WITH_EDITOR

Py_BEGIN_ALLOW_THREADS;

self->ue_object->PreEditChange(prop);

Py_END_ALLOW_THREADS;

#endif

Py_RETURN_NONE;

}

#if WITH_EDITOR

PyObject *py_ue_set_metadata(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *metadata_key;

char *metadata_value;

if (!PyArg_ParseTuple(args, "ss:set_metadata", &metadata_key, &metadata_value))

{

return NULL;

}

if (self->ue_object->IsA<UClass>())

{

UClass *u_class = (UClass *)self->ue_object;

u_class->SetMetaData(FName(UTF8_TO_TCHAR(metadata_key)), UTF8_TO_TCHAR(metadata_value));

}

else if (self->ue_object->IsA<UField>())

{

UField *u_field = (UField *)self->ue_object;

u_field->SetMetaData(FName(UTF8_TO_TCHAR(metadata_key)), UTF8_TO_TCHAR(metadata_value));

}

else

{

return PyErr_Format(PyExc_TypeError, "the object does not support MetaData");

}

Py_RETURN_NONE;

}

PyObject *py_ue_get_metadata(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *metadata_key;

if (!PyArg_ParseTuple(args, "s:get_metadata", &metadata_key))

{

return NULL;

}

char *metadata_value = nullptr;

if (self->ue_object->IsA<UClass>())

{

UClass *u_class = (UClass *)self->ue_object;

FString value = u_class->GetMetaData(FName(UTF8_TO_TCHAR(metadata_key)));

return PyUnicode_FromString(TCHAR_TO_UTF8(*value));

}

if (self->ue_object->IsA<UField>())

{

UField *u_field = (UField *)self->ue_object;

FString value = u_field->GetMetaData(FName(UTF8_TO_TCHAR(metadata_key)));

return PyUnicode_FromString(TCHAR_TO_UTF8(*value));

}

return PyErr_Format(PyExc_TypeError, "the object does not support MetaData");

}

PyObject *py_ue_has_metadata(ue_PyUObject * self, PyObject * args)

{

ue_py_check(self);

char *metadata_key;

if (!PyArg_ParseTuple(args, "s:has_metadata", &metadata_key))

{

return NULL;

}

if (self->ue_object->IsA<UClass>())

{

UClass *u_class = (UClass *)self->ue_object;

if (u_class->HasMetaData(FName(UTF8_TO_TCHAR(metadata_key))))

{

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

if (self->ue_object->IsA<UField>())

{

UField *u_field = (UField *)self->ue_object;

if (u_field->HasMetaData(FName(UTF8_TO_TCHAR(metadata_key))))

{

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

return PyErr_Format(PyExc_TypeError, "the object does not support MetaData");

}

#endif

PyObject *py_ue_call_function(ue_PyUObject * self, PyObject * args, PyObject *kwargs)

{

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 (PyUnicodeOrString_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");

return py_ue_ufunction_call(function, self->ue_object, args, 1, kwargs);

}

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)

{

Py_INCREF(Py_None);

return Py_None;

}

Py_RETURN_UOBJECT((UObject *)function);

}

#if ENGINE_MINOR_VERSION >= 15

PyObject *py_ue_can_modify(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (self->ue_object->CanModify())

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

#endif

PyObject *py_ue_set_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *name;

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

{

return NULL;

}

if (!self->ue_object->Rename(UTF8_TO_TCHAR(name), self->ue_object->GetOutermost(), REN_Test))

{

return PyErr_Format(PyExc_Exception, "cannot set name %s", name);

}

if (self->ue_object->Rename(UTF8_TO_TCHAR(name)))

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

PyObject *py_ue_set_outer(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

PyObject *py_outer;

if (!PyArg_ParseTuple(args, "O:set_outer", &py_outer))

{

return nullptr;

}

UPackage *package = ue_py_check_type<UPackage>(py_outer);

if (!package)

return PyErr_Format(PyExc_Exception, "argument is not a UPackage");

if (!self->ue_object->Rename(nullptr, package, REN_Test))

{

return PyErr_Format(PyExc_Exception, "cannot move to package %s", TCHAR_TO_UTF8(*package->GetPathName()));

}

if (self->ue_object->Rename(nullptr, package))

{

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

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

{

ue_py_check(self);

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

}

PyObject *py_ue_get_display_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

#if WITH_EDITOR

if (UClass *uclass = ue_py_check_type<UClass>(self))

{

return PyUnicode_FromString(TCHAR_TO_UTF8(*uclass->GetDisplayNameText().ToString()));

}

if (AActor *actor = ue_py_check_type<AActor>(self))

{

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

}

#endif

if (UActorComponent *component = ue_py_check_type<UActorComponent>(self))

{

return PyUnicode_FromString(TCHAR_TO_UTF8(*component->GetReadableName()));

}

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

}

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())));

}

PyObject *py_ue_get_path_name(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

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

}

PyObject *py_ue_save_config(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

Py_BEGIN_ALLOW_THREADS;

self->ue_object->SaveConfig();

Py_END_ALLOW_THREADS;

Py_RETURN_NONE;

}

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

{

ue_py_check(self);

char *property_name;

PyObject *property_value;

int index = 0;

if (!PyArg_ParseTuple(args, "sO|i:set_property", &property_name, &property_value, &index))

{

return nullptr;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->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, index))

{

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

}

Py_RETURN_NONE;

}

PyObject *py_ue_set_property_flags(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

uint64 flags;

if (!PyArg_ParseTuple(args, "sK:set_property_flags", &property_name, &flags))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

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

u_property->SetPropertyFlags(flags);

Py_RETURN_NONE;

}

PyObject *py_ue_add_property_flags(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

uint64 flags;

if (!PyArg_ParseTuple(args, "sK:add_property_flags", &property_name, &flags))

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

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

u_property->SetPropertyFlags(u_property->GetPropertyFlags() | flags);

Py_RETURN_NONE;

}

PyObject *py_ue_get_property_flags(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

char *property_name;

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

{

return NULL;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

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

return PyLong_FromUnsignedLong(u_property->GetPropertyFlags());

}

PyObject *py_ue_enum_values(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object->IsA<UEnum>())

return PyErr_Format(PyExc_TypeError, "uobject is not a UEnum");

UEnum *u_enum = (UEnum *)self->ue_object;

uint8 max_enum_value = u_enum->GetMaxEnumValue();

PyObject *ret = PyList_New(0);

for (uint8 i = 0; i < max_enum_value; i++)

{

PyObject *py_long = PyLong_FromLong(i);

PyList_Append(ret, py_long);

Py_DECREF(py_long);

}

return ret;

}

PyObject *py_ue_enum_names(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object->IsA<UEnum>())

return PyErr_Format(PyExc_TypeError, "uobject is not a UEnum");

UEnum *u_enum = (UEnum *)self->ue_object;

uint8 max_enum_value = u_enum->GetMaxEnumValue();

PyObject *ret = PyList_New(0);

for (uint8 i = 0; i < max_enum_value; i++)

{

#if ENGINE_MINOR_VERSION > 15

PyObject *py_long = PyUnicode_FromString(TCHAR_TO_UTF8(*u_enum->GetNameStringByIndex(i)));

#else

PyObject *py_long = PyUnicode_FromString(TCHAR_TO_UTF8(*u_enum->GetEnumName(i)));

#endif

PyList_Append(ret, py_long);

Py_DECREF(py_long);

}

return ret;

}

#if ENGINE_MINOR_VERSION >= 15

PyObject *py_ue_enum_user_defined_names(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

if (!self->ue_object->IsA<UUserDefinedEnum>())

return PyErr_Format(PyExc_TypeError, "uobject is not a UEnum");

UUserDefinedEnum *u_enum = (UUserDefinedEnum *)self->ue_object;

TArray<FText> user_defined_names;

u_enum->DisplayNameMap.GenerateValueArray(user_defined_names);

PyObject *ret = PyList_New(0);

for (FText text : user_defined_names)

{

PyObject *py_long = PyUnicode_FromString(TCHAR_TO_UTF8(*text.ToString()));

PyList_Append(ret, py_long);

Py_DECREF(py_long);

}

return ret;

}

#endif

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

{

ue_py_check(self);

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

PyObject *ret = PyList_New(0);

for (TFieldIterator<UProperty> PropIt(u_struct); 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;

}

PyObject *py_ue_functions(ue_PyUObject *self, PyObject * args)

{

ue_py_check(self);

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UStruct>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

PyObject *ret = PyList_New(0);

for (TFieldIterator<UFunction> FuncIt(u_struct); FuncIt; ++FuncIt)

{

UFunction* func = *FuncIt;

PyObject *func_name = PyUnicode_FromString(TCHAR_TO_UTF8(*func->GetFName().ToString()));

PyList_Append(ret, func_name);

Py_DECREF(func_name);

}

return ret;

}

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 nullptr;

}

FOutputDeviceNull od_null;

bool success = false;

Py_BEGIN_ALLOW_THREADS;

success = self->ue_object->CallFunctionByNameWithArguments(UTF8_TO_TCHAR(call_args), od_null, NULL, true);

Py_END_ALLOW_THREADS;

if (!success)

{

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

}

Py_RETURN_NONE;

}

PyObject *py_ue_broadcast(ue_PyUObject *self, PyObject *args)

{

ue_py_check(self);

char *property_name;

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

{

return nullptr;

}

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 event property %s", property_name);

if (auto casted_prop = Cast<UMulticastDelegateProperty>(u_property))

{

Py_BEGIN_ALLOW_THREADS;

FMulticastScriptDelegate multiscript_delegate = casted_prop->GetPropertyValue_InContainer(self->ue_object);

uint8 *parms = (uint8 *)FMemory_Alloca(casted_prop->SignatureFunction->PropertiesSize);

FMemory::Memzero(parms, casted_prop->SignatureFunction->PropertiesSize);

multiscript_delegate.ProcessMulticastDelegate<UObject>(parms);

Py_END_ALLOW_THREADS;

}

else

{

return PyErr_Format(PyExc_Exception, "property is not a UMulticastDelegateProperty");

}

Py_RETURN_NONE;

}

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

{

ue_py_check(self);

char *property_name;

int index = 0;

if (!PyArg_ParseTuple(args, "s|i:get_property", &property_name, &index))

{

return nullptr;

}

UStruct *u_struct = nullptr;

if (self->ue_object->IsA<UClass>())

{

u_struct = (UStruct *)self->ue_object;

}

else

{

u_struct = (UStruct *)self->ue_object->GetClass();

}

UProperty *u_property = u_struct->FindPropertyByName(FName(UTF8_TO_TCHAR(property_name)));

if (!u_property)

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