Skip to content
TheChatArchiveThe Chat Archive
Metallama-3.3-70b-instruct· MetaHugging Face LMArena Human Preference 140K

I'm developing a video game in Unreal Engine and want a character to stick to the…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Googlegemma-3-27b-it’s answer.
  1. User

    I'm developing a video game in Unreal Engine and want a character to stick to the ground. I'm using Blueprints, and already have the movement graph written. I just need the Event Graph for keeping the character on the ground. Since the character is a car, this graph should also account for the height of all of the tires and correctly rotate the model

  2. Meta Assistant

    Ground Sticking Event Graph for a Car Character in Unreal Engine

    To create an Event Graph that keeps your car character stuck to the ground, you'll need to use a combination of raycasting, vector calculations, and rotation transformations. Here's a step-by-step guide to help you achieve this:

    Step 1: Define the Tire Positions and Heights

    • Create a custom struct to hold the tire positions and heights:
      • TirePosition (Vector): The position of the tire relative to the car's center.
      • TireHeight (Float): The height of the tire above the ground.
    • Create an array of this struct to hold the positions and heights of all tires.

    Step 2: Raycast Down from Each Tire

    • Create a For Each loop to iterate over the tire array.
    • Inside the loop, use a Line Trace By Channel node to raycast down from each tire position:
      • Start (Vector): The tire position.
      • End (Vector): The tire position minus the tire height (to account for the height of the tire).
      • Channel (Enum): The collision channel to use (e.g., ECC_Visibility).
    • Store the hit result in a variable (e.g., HitResult).

    Step 3: Calculate the Ground Normal and Rotation

    • Use the HitResult to get the ground normal (e.g., HitResult.ImpactNormal).
    • Calculate the rotation needed to align the car with the ground normal:
      • Use a Vector Length node to get the length of the ground normal.
      • Use a Vector Normalize node to normalize the ground normal.
      • Use a Make Rot from X node to create a rotation from the normalized ground normal.
    • Store the rotation in a variable (e.g., GroundRotation).

    Step 4: Apply the Rotation and Position Correction

    • Use a Set World Rotation node to set the car's rotation to the GroundRotation.
    • Use a Set World Location node to set the car's position to the HitResult.ImpactPoint (the point where the raycast hit the ground).
    • Use a Vector + Vector node to add the tire height to the HitResult.ImpactPoint to account for the height of the tire.

    Step 5: Repeat for All Tires

    • Repeat steps 2-4 for all tires in the array.
    • Use a For Each loop to iterate over the tire array and apply the rotation and position correction for each tire.

    Example Blueprint Graph

    Here's an example of what the Event Graph might look like:

    +---------------+
    |  Event Begin  |
    +---------------+
           |
           |
           v
    +---------------+
    |  For Each Tire  |
    |  (Tire Array)  |
    +---------------+
           |
           |
           v
    +---------------+
    |  Line Trace By  |
    |  Channel (Down) |
    +---------------+
           |
           |
           v
    +---------------+
    |  Get Hit Result  |
    |  (HitResult)    |
    +---------------+
           |
           |
           v
    +---------------+
    |  Calculate Ground  |
    |  Normal and Rotation |
    +---------------+
           |
           |
           v
    +---------------+
    |  Set World Rotation  |
    |  (GroundRotation)    |
    +---------------+
           |
           |
           v
    +---------------+
    |  Set World Location  |
    |  (HitResult.ImpactPoint) |
    +---------------+
           |
           |
           v
    +---------------+
    |  Add Tire Height    |
    |  (HitResult.ImpactPoint) |
    +---------------+
           |
           |
           v
    +---------------+
    |  Repeat for All Tires |
    +---------------+
    

    Note that this is a simplified example and you may need to adjust the graph to fit your specific use case.

    Code Example (Optional)

    If you prefer to use C++ instead of Blueprints, here's an example of how you might implement the ground sticking logic:

    // MyCarCharacter.cpp
    
    #include "MyCarCharacter.h"
    #include "CoreMinimal.h"
    #include "GameFramework/Character.h"
    #include "GameFramework/CharacterMovementComponent.h"
    
    void AMyCarCharacter::StickToGround()
    {
        // Define the tire positions and heights
        TArray<FVector> tirePositions = { /* initialize tire positions */ };
        TArray<float> tireHeights = { /* initialize tire heights */ };
    
        // Raycast down from each tire
        for (int i = 0; i < tirePositions.Num(); i++)
        {
            FVector start = tirePositions[i];
            FVector end = start - FVector(0, 0, tireHeights[i]);
            FHitResult hitResult;
            GetWorld()->SweepSingleByChannel(hitResult, start, end, FQuat::Identity, ECC_Visibility, FCollisionShape::MakeSphere(1.0f));
    
            // Calculate the ground normal and rotation
            FVector groundNormal = hitResult.ImpactNormal;
            float groundNormalLength = groundNormal.Size();
            groundNormal.Normalize();
            FQuat groundRotation = FQuat::MakeFromEuler(groundNormal);
    
            // Apply the rotation and position correction
            SetWorldRotation(groundRotation);
            SetWorldLocation(hitResult.ImpactPoint + FVector(0, 0, tireHeights[i]));
        }
    }
    

    Note that this is just an example and you'll need to modify it to fit your specific use case.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.