[Module] KyberCurrentTimeEntity, KyberTimeSplitterEntity

Module/Public/Entity/Entities/KyberCurrentTimeEntity.h

@@ -0,0 +1,27 @@
+// Copyright Armchair Developers. Licensed under GPLv3.
+
+#pragma once
+
+#include <Entity/NativeEntityManager.h>
+
+namespace Kyber
+{
+class KyberCurrentTimeEntityData : public EntityData
+{
+public:
+    bool EnableUpdates;
+};
+
+class KyberCurrentTimeEntity : public KyberEntity<KyberCurrentTimeEntityData>
+{
+public:
+    KyberCurrentTimeEntity(EntityManager* entityManager, NativeEntity* entity, KyberCurrentTimeEntityData* data);
+
+    void Event(EntityEvent* event) override;
+    void Update(const UpdateParameters& params) override;
+    float GetTime();
+
+private:
+    PropertyWriter<float> m_timeOut;
+};
+} // namespace Kyber

Module/Public/Entity/Entities/KyberTimeSplitterEntity.h

@@ -0,0 +1,30 @@
+// Copyright Armchair Developers. Licensed under GPLv3.
+
+#pragma once
+
+#include <Entity/NativeEntityManager.h>
+
+namespace Kyber
+{
+class KyberTimeSplitterEntityData : public EntityData
+{
+public:
+    bool UseUTC;
+};
+
+class KyberTimeSplitterEntity : public KyberEntity<KyberTimeSplitterEntityData>
+{
+public:
+    KyberTimeSplitterEntity(EntityManager* entityManager, NativeEntity* entity, KyberTimeSplitterEntityData* data);
+
+    void PropertyChanged(PropertyModification* modification) override;
+
+private:
+    PropertyWriter<int> m_secIntOut;
+    PropertyWriter<int> m_minIntOut;
+    PropertyWriter<int> m_hourIntOut;
+    PropertyWriter<int> m_dayIntOut;
+    PropertyWriter<int> m_monthIntOut;
+    PropertyWriter<int> m_yearIntOut;
+};
+} // namespace Kyber

Module/Source/Entity/Entities/KyberCurrentTimeEntity.cpp

@@ -0,0 +1,51 @@
+// Copyright Armchair Developers. Licensed under GPLv3.
+
+#include <Entity/Entities/KyberCurrentTimeEntity.h>
+
+#include <Core/Program.h>
+
+#include <chrono>
+
+namespace Kyber
+{
+KB_IMPLEMENT_TYPE(KyberCurrentTimeEntityData)
+{
+    KyberTypeInfo info("KyberCurrentTimeEntityData", "EntityData");
+    info.AddField("Boolean", "EnableUpdates");
+    return info;
+}
+
+KB_IMPLEMENT_ENTITY(KyberCurrentTimeEntity, KyberCurrentTimeEntityData);
+
+KyberCurrentTimeEntity::KyberCurrentTimeEntity(EntityManager* entityManager, NativeEntity* entity, KyberCurrentTimeEntityData* data)
+    : KyberEntity(entity, data)
+{
+    m_timeOut = CreateFieldOverride<float>("Time", g_program->m_entityManager->GetNativeType("Float32"));
+
+    SetWantUpdates(data->EnableUpdates);
+}
+
+void KyberCurrentTimeEntity::Event(EntityEvent* event)
+{
+    if (event->Is("Update"))
+    {
+        float currentTime = GetTime();
+        m_timeOut = &currentTime;
+        FireEvent("OnUpdate");
+    }
+}
+
+void KyberCurrentTimeEntity::Update(const UpdateParameters& params)
+{
+    float currentTime = GetTime();
+    m_timeOut = &currentTime;
+}
+
+float KyberCurrentTimeEntity::GetTime()
+{
+    auto now = std::chrono::system_clock::now();
+    auto duration = now.time_since_epoch();
+    auto seconds = std::chrono::duration_cast<std::chrono::duration<float>>(duration);
+    return seconds.count();
+}
+} // namespace Kyber

Module/Source/Entity/Entities/KyberTimeSplitterEntity.cpp

@@ -0,0 +1,71 @@
+// Copyright Armchair Developers. Licensed under GPLv3.
+
+#include <Entity/Entities/KyberTimeSplitterEntity.h>
+
+#include <Core/Program.h>
+
+#include <chrono>
+
+namespace Kyber
+{
+KB_IMPLEMENT_TYPE(KyberTimeSplitterEntityData)
+{
+    KyberTypeInfo info("KyberTimeSplitterEntityData", "EntityData");
+    info.AddField("Boolean", "UseUTC");
+    return info;
+}
+
+KB_IMPLEMENT_ENTITY(KyberTimeSplitterEntity, KyberTimeSplitterEntityData);
+
+KyberTimeSplitterEntity::KyberTimeSplitterEntity(EntityManager* entityManager, NativeEntity* entity, KyberTimeSplitterEntityData* data)
+    : KyberEntity(entity, data)
+{
+    m_dayIntOut = CreateFieldOverride<int>("DayInt", g_program->m_entityManager->GetNativeType("Int32"));
+    m_monthIntOut = CreateFieldOverride<int>("MonthInt", g_program->m_entityManager->GetNativeType("Int32"));
+    m_yearIntOut = CreateFieldOverride<int>("YearInt", g_program->m_entityManager->GetNativeType("Int32"));
+    m_secIntOut = CreateFieldOverride<int>("SecondInt", g_program->m_entityManager->GetNativeType("Int32"));
+    m_minIntOut = CreateFieldOverride<int>("MinuteInt", g_program->m_entityManager->GetNativeType("Int32"));
+    m_hourIntOut = CreateFieldOverride<int>("HourInt", g_program->m_entityManager->GetNativeType("Int32"));
+}
+
+void KyberTimeSplitterEntity::PropertyChanged(PropertyModification* modification)
+{
+    float currentTime = 0;
+
+    PropertyReader<float> fieldValue = GetFieldReader<float>("Time");
+    if (fieldValue.HasConnectionValue())
+    {
+        currentTime = fieldValue.Get();
+    }
+
+    if (currentTime <= 0)
+    {
+        return;
+    }
+
+    // Convert to time_point from float
+    auto duration = std::chrono::duration<float>(currentTime);
+    auto timePoint = std::chrono::system_clock::time_point(
+        std::chrono::duration_cast<std::chrono::system_clock::duration>(duration)
+    );
+
+    std::time_t sysClockTime = std::chrono::system_clock::to_time_t(timePoint);
+    std::tm* time = GetData()->UseUTC ? std::gmtime(&sysClockTime) : std::localtime(&sysClockTime);
+
+    // Get Second, Minute, Hour, Day, Month, Year
+    int second = time->tm_sec;
+    int minute = time->tm_min;
+    int hour = time->tm_hour;
+    int day = time->tm_mday;
+    int month = time->tm_mon + 1;
+    int year = time->tm_year + 1900;
+
+    // Update property outputs
+    m_dayIntOut = &day;
+    m_monthIntOut = &month;
+    m_yearIntOut = &year;
+    m_secIntOut = &second;
+    m_minIntOut = &minute;
+    m_hourIntOut = &hour;
+}
+} // namespace Kyber

Module/Source/Entity/NativeEntityManager.cpp

@@ -386,14 +386,14 @@ ClassInfoAsset* EntityManager::CreateClassInfoAsset(const KyberTypeInfo& info)
 
 void KyberEntityBase::FireEvent(EventId entityEvent)
 {
-    KYBER_LOG(Info, "Firing event " << entityEvent);
-
     EntityEvent event = entityEvent;
     FullEntityBusInternalFireEventHk(m_nativeEntity->m_entityBus, reinterpret_cast<const DataContainer*>(m_data), &event);
 }
 
 void KyberEntityBase::FireEvent(const char* event)
 {
+    KYBER_LOG(Debug, "Firing event " << event);
+
     FireEvent(StringUtils::HashQuick(event));
 }