public void Populate(CardEffectTree effectTree)
{
    if (effectTree == null) return;
    ClearElements();
    CurrentTree = effectTree;
    if (effectTree.nodes == null || !effectTree.nodes.Any()) return;

    //Instantiate all nodes 
    foreach (CardEffectNode node in effectTree.nodes)
    {
        VisualNode n = new(node, this);
        AddElement(n);
        n.UpdateDescription();
    }

    //Connect parents to children 
    foreach (CardEffectNode parent in effectTree.nodes)
    {
        if (parent == null) continue;
        VisualNode visualParent = GetVisualFromData(parent);
        foreach (CardEffectNode child in parent.GetChildren())
        {
            if (child == null) continue;
            child.parent = parent;
            VisualNode visualChild = GetVisualFromData(child);
            AddElement(visualParent.outputPort.ConnectTo(visualChild.inputPort));
        }
    }
}

private GraphViewChange OnGraphViewChanged(GraphViewChange graphViewChange)
{
    //Remove Elements
    if (graphViewChange.elementsToRemove != null)
        foreach (GraphElement ge in graphViewChange.elementsToRemove)
            if (ge is VisualNode visualNode)
            {
                CurrentTree.RemoveNode(visualNode.data);
            }
            else if (ge is Edge edge && edge.output.node is VisualNode parent &&
                      edge.input.node is VisualNode child)
            {
                Undo.RecordObject(parent.data, "Remove Child");
                parent.data.Remove(child.data);
                child.data.parent = null;
                EditorUtility.SetDirty(parent.data);
            }

    //Add Elements
    if (graphViewChange.edgesToCreate != null)
        foreach (Edge edge in graphViewChange.edgesToCreate)
            if (edge.output.node is VisualNode parent && edge.input.node is VisualNode child)
            {
                Undo.RecordObject(parent.data, "Add Child");
                parent.data.Add(child.data);
                child.data.parent = parent.data;
                EditorUtility.SetDirty(parent.data);
            }

    //Moved Elements
    if (graphViewChange.movedElements != null) CurrentTree.SortTreeByNodeGraphPosition();

    //Events
    OnGraphViewChange?.Invoke();
    CurrentTree.HandleKeywordData();
    return graphViewChange;
}

public override void BuildContextualMenu(ContextualMenuPopulateEvent evt)
{
    if (CurrentTree == null) return;
    TypeCache.TypeCollection types = TypeCache.GetTypesDerivedFrom<CardEffectNode>();
    foreach (Type type in types)
    {
        if (type.IsAbstract) continue; //Don't instantiate abstract types 
        evt.menu.AppendAction($"{type.BaseType?.Name}/{type.Name}", //create right click menu
            _ =>  //invoke method when item selected 
            {
                MethodInfo method = CreateNodeMethodInfo.MakeGenericMethod(type);
                method.Invoke(this, null);
            });
    }
}

//reflection method info 
private static readonly MethodInfo CreateNodeMethodInfo =
    typeof(CardEffectGraphView).GetMethod("CreateNode", BindingFlags.NonPublic | BindingFlags.Instance);

//method that gets invoked with the generic type of selected node
private void CreateNode<NodeType>() where NodeType : CardEffectNode
{
    NodeType node = CurrentTree.CreateNode<NodeType>();
    if (node == null) return;
    AddElement(new VisualNode(node, this));
}

void APortalManager::UpdatePortalView(APortalActor* Portal)
{
  Portal->GetSceneCaptureComponent()->Activate();
  APortalActor* LinkedPortal = Portal->GetLinkedPortal();
    if (LinkedPortal != nullptr)
    {
    
      const UCameraComponent* PlayerCam = PlayerCon->CameraPawn->GetActiveCamera();
      USceneCaptureComponent2D* LinkedSceneCapture = LinkedPortal->GetSceneCaptureComponent();
      LinkedSceneCapture->Activate();

      //get back-facing transform of the portal-to-enter
      FTransform ReversePortal = Portal->GetActorTransform();
      FRotator Rot = ReversePortal.Rotator();
      Rot.Yaw += 180;
      ReversePortal.SetRotation(FQuat(Rot));
      //set linkedportal's scene capture component transform relative to linkedportal to be the same as the transform between the active camera and the back of the portal-to-enter
      //this makes the portal effect work in 3d, instead of just keeping the camera at the exit of the portal, which would make the effect look flat  
      LinkedSceneCapture->SetRelativeTransform(UKismetMathLibrary::MakeRelativeTransform(PlayerCam->GetComponentTransform(),ReversePortal));
      //having the camera be behind the portal, however, means we need to move it's clipping plane forward to make sure it isn't rendering objects between it and it's portal,
      //we dont want to player to see those as it breaks the effect.
      //these numbers probably need tweaking still but it's close to where i want it to be 
      LinkedSceneCapture->ClipPlaneNormal = LinkedPortal->GetActorForwardVector();
      LinkedSceneCapture->ClipPlaneBase = LinkedPortal->GetActorLocation() - (LinkedSceneCapture->ClipPlaneNormal * ClipBuffer);
    }
  }

  void APortalActor::TeleportActor(AActor* TargetActor)
  {
    TargetActor->SetActorLocation(PortalUtils::ConvertLocationToLocalSpace(TargetActor->GetActorLocation(), this, LinkedPortal));
    FRotator Rot =  PortalUtils::ConvertRotationToLocalSpace(TargetActor->GetActorRotation(), this, LinkedPortal);
    Rot.Yaw += 180.0f;
    TargetActor->SetActorRotation(Rot);
    if(TargetActor->IsA(ACharacter::StaticClass()))
    {
      Rot.Pitch = 0.0f;
      Rot.Roll = 0.0f;
      const ACharacter* c = static_cast<ACharacter*>(TargetActor);
      c->GetController()->SetControlRotation(Rot);
    }

  //reapply velocity in portal direction
  const FVector TeleportVelocity = TargetActor->GetVelocity();
  FVector OrientedVelocity;
  OrientedVelocity.X = FVector::DotProduct(TeleportVelocity, GetActorForwardVector());
  OrientedVelocity.Y = FVector::DotProduct(TeleportVelocity, GetActorRightVector());
  OrientedVelocity.Z = FVector::DotProduct(TeleportVelocity, GetActorUpVector());
  OrientedVelocity = OrientedVelocity.X * LinkedPortal->GetActorForwardVector() + OrientedVelocity.Y * LinkedPortal->GetActorRightVector() + OrientedVelocity.Z * LinkedPortal->GetActorUpVector();

  TargetActor->GetRootComponent()->ComponentVelocity = OrientedVelocity;
  LinkedPortal->IsLastPositionInFrontOfPortal = false;
  LinkedPortal->UpdateSceneCaptureRenderTarget();
}

FVector PortalUtils::ConvertLocationToLocalSpace(FVector Location, AActor* CurrentSpace, AActor* TargetSpace)
{
  if (CurrentSpace == nullptr || TargetSpace == nullptr)
  {
    return FVector::ZeroVector;
  }
  const FVector Direction = Location - CurrentSpace->GetActorLocation();
  FVector Dots;
  Dots.X = FVector::DotProduct(Direction, CurrentSpace->GetActorForwardVector());
  Dots.Y = FVector::DotProduct(Direction, CurrentSpace->GetActorRightVector());
  Dots.Z = FVector::DotProduct(Direction, CurrentSpace->GetActorUpVector());

  FVector NewDirection = Dots.X * TargetSpace->GetActorForwardVector() + Dots.Y * TargetSpace->GetActorRightVector() + Dots.Z * TargetSpace->GetActorUpVector();
  NewDirection.Y *= -1;
  return TargetSpace->GetActorLocation() + NewDirection;
}

FRotator PortalUtils::ConvertRotationToLocalSpace(FRotator Rotation, AActor* CurrentSpace, AActor* TargetSpace)
{
  if (CurrentSpace == nullptr || TargetSpace == nullptr)
  {
    return FRotator::ZeroRotator;
  }

  FQuat TargetRotation = TargetSpace->GetTransform().GetRotation();
  FQuat InverseSpaceRotation = CurrentSpace->GetTransform().GetRotation().Inverse();
  FQuat RotQuat = FQuat(Rotation);
  FQuat FinalQuat = TargetRotation * InverseSpaceRotation * RotQuat;
  FRotator ReturnRot = FinalQuat.Rotator();
  return ReturnRot;
}
              

auto Flock::CalculateForce(Transform* a_transform, std::vector* a_neighbourPointer) -> glm::vec3
{
  if (a_neighbourPointer == nullptr) return glm::vec3(0); //early out
  unsigned int neighbourCount = 0;
  glm::vec3 localPos = a_transform->GetRow(POS_VEC);
  glm::vec3 fwdVec = a_transform->GetRow(FWD_VEC);

  glm::vec3 seperation(0);
  glm::vec3 alignment(0);
  glm::vec3 cohesion(0);

  for (GameObject* other : *a_neighbourPointer)
  {
      Transform* otherT = other->GetComponent<Transform>().get();
      if (otherT == a_transform)
      {
        continue; //we are looking at ourselves get out early
      }
      glm::vec3 otherPos = otherT->GetRow(POS_VEC);
      glm::vec3 toOther = otherPos - localPos;
  
  
      if (dot(fwdVec, normalize(toOther)) < 0.7F /* look angle */ && length(toOther) < s_neighbourhoodRaidus) 
      { //boid is in our neighbourhood 
        
        neighbourCount++; 
        seperation +=toOther * -1; //toLocal
          cohesion +=otherPos; 
          alignment+=other->GetComponent<BoidBehaviour>()->GetVelocity();
      }
  }

  if (neighbourCount == 0)
  {
      return glm::vec3(0);
  }

  for (glm::vec3 v : {seperation, alignment, cohesion})
  {
     v /= neighbourCount;
     if (length(v) != 0.0f)
     {
       v = normalize(v);
     }
  }
  return seperation + alignment + cohesion; //total our forces
}