Latent Attach Wire

class AttachWireTaskFunctor : public LatentF4SEDelayFunctor
    {
    public:
        explicit AttachWireTaskFunctor(UInt32 stackId, TESObjectREFR* refA, TESObjectREFR* refB, TESForm* baseSpline) : LatentF4SEDelayFunctor( stackId )
        {
            m_ref[0] = GetHandleFromObject(refA, TESObjectREFR::kTypeID);
            m_ref[1] = GetHandleFromObject(refB, TESObjectREFR::kTypeID);
            m_ref[2] = GetHandleFromObject(baseSpline, TESForm::kTypeID);
        }
        explicit AttachWireTaskFunctor(SerializationTag tag) : LatentF4SEDelayFunctor( tag ) {}

        virtual const char* ClassName() const       { return "AttachWireTaskFunctor"; }
        virtual UInt32      ClassVersion() const    { return 1; }

        virtual bool Save(const F4SESerializationInterface* intfc);
        virtual bool Load(const F4SESerializationInterface* intfc, UInt32 version);

        virtual void Run(VMValue& resultValue)
        {
            TESObjectREFR * wireRef = nullptr;
            VirtualMachine* vm = (*g_gameVM)->m_virtualMachine;

            TESObjectREFR * refA = (TESObjectREFR*)GetObjectFromHandle(m_ref[0], TESObjectREFR::kTypeID);
            TESObjectREFR * refB = (TESObjectREFR*)GetObjectFromHandle(m_ref[1], TESObjectREFR::kTypeID);
            TESForm * splineForm = (TESForm*)GetObjectFromHandle(m_ref[2], TESForm::kTypeID);

            // There's no 3D loaded for these, probably bad news
            if(!splineForm || !refA || !refB || !refA->GetObjectRootNode() || !refB->GetObjectRootNode()) {
                PackValue(&resultValue, &wireRef, vm);
                return;
            }

            BGSBendableSpline * spline = DYNAMIC_CAST(splineForm, TESForm, BGSBendableSpline);
            BGSBendableSpline * splineA = DYNAMIC_CAST(refA->baseForm, TESForm, BGSBendableSpline);
            BGSBendableSpline * splineB = DYNAMIC_CAST(refB->baseForm, TESForm, BGSBendableSpline);

            BGSKeyword * keyword = DYNAMIC_CAST(LookupFormByID(0x00054BA6), TESForm, BGSKeyword);
            // No workshop keyword is bad
            // Connecting a wire to another wire or connecting a non-wire is invalid
            if(!keyword || !spline || splineA || splineB) {
                PackValue(&resultValue, &wireRef, vm);
                return;
            }

            // Get the workshop by keyword
            TESObjectREFR * workshopRef = GetLinkedRef_Native(refA, keyword);
            if(!workshopRef) {
                PackValue(&resultValue, &wireRef, vm);
                return;
            }

            // Workshop ref isn't a workshop!
            BSExtraData* extraDataWorkshop = workshopRef->extraDataList->GetByType(ExtraDataType::kExtraData_WorkshopExtraData);
            if(!extraDataWorkshop) {
                PackValue(&resultValue, &wireRef, vm);
                return;
            }

            // Create our wire instance
            wireRef = PlaceAtMe_Native(vm, stackId_, &refA, spline, 1, false, false, false);
            if(!wireRef) {
                PackValue(&resultValue, &wireRef, vm);
                return;
            }

            // Set the wire's linked ref to the workshop
            SetLinkedRef_Native(wireRef, workshopRef, keyword);

            LocationData locData(*g_player);
            FinalizeWireLink(&locData, wireRef, refB, 0, refA, 0);
            SetWireEndpoints_Internal(refA, 0, refB, 0, wireRef);


            ExtraBendableSplineParams * splineParams = (ExtraBendableSplineParams*)wireRef->extraDataList->GetByType(kExtraData_BendableSplineParams);
            if(splineParams) {
                splineParams->thickness = 1.5f;
            }

            LinkPower_Internal(extraDataWorkshop, refA, refB, wireRef);

            PackValue(&resultValue, &wireRef, vm);
        }

    private:
        UInt64 m_ref[3];
    };

    bool AttachWireTaskFunctor::Save(const F4SESerializationInterface* intfc)
    {
        using namespace Serialization;

        if (! LatentF4SEDelayFunctor::Save(intfc))
            return false;

        for(UInt32 i = 0; i < 3; i++)
        {
            if(!WriteData(intfc, &m_ref[i]))
                return false;
        }

        return true;
    }

    bool AttachWireTaskFunctor::Load(const F4SESerializationInterface* intfc, UInt32 version)
    {
        using namespace Serialization;

        if (! LatentF4SEDelayFunctor::Load(intfc, version))
            return false;

        for(UInt32 i = 0; i < 3; i++)
        {
            if (! ReadData(intfc, &m_ref[i]))
                return false;

            if (! intfc->ResolveHandle(m_ref[i], &m_ref[i]))
                return false;
        }

        return true;
    }

    bool AttachWire(VirtualMachine * vm, UInt32 stackId, TESObjectREFR* refA, TESObjectREFR* refB, TESForm* baseSpline)
    {
        if(!baseSpline || !refA || !refB)
            return false;

        F4SEDelayFunctorManagerInstance().Enqueue(new AttachWireTaskFunctor(stackId, refA, refB, baseSpline));
        return true;
    }