Rocket Rider

Rocket riding, Combat, Platforming

Overview



Responsibility



This is a showcase of what I made during the project

This nine-week project, developed with a team of 17 members (5 programmers, 4 designers, and 8 artists), was my first experience with Unreal Engine. 

I appreciated the larger team size, which allowed me to focus on areas I enjoy, such as player controllers and overall feedback.

Targeting the PlayStation 5 platform, I had the opportunity to write code for key console features, particularly the DualSense controller. 

I developed modular DualSense code, enabling designers to implement features through blueprints without needing to access any C++ classes.

In addition to coding, I dedicated significant time to optimizing the game, ensuring well a optimized game and great performance despite the demands of raytracing and lumen.

I hope you enjoy exploring this project, which was a significant part of my journey with PlaygroundSquad!

Rocket Movement

A specialized constant forward velocity character controller was required for the game

HandleRocketMovement(const FVector& MovementDirection)

 LastMovementDirection = FMath::VInterpTo(LastMovementDirection,

    MovementDirection.GetSafeNormal(),

    GetWorld()->GetDeltaSeconds(),

    RocketDirectionalChangeSpeed);


    LastMovementDirection = LastMovementDirection.GetSafeNormal();


    if (FVector::DotProduct(MovementDirection.GetSafeNormal(), LastMovementDirection) < -AngleThreshold)

    {

        const FVector AdjustmentVector = LastMovementDirection.RotateAngleAxis(1.0f, FVector::UpVector);


        LastMovementDirection = FMath::VInterpTo(LastMovementDirection,

        AdjustmentVector,

        GetWorld()->GetDeltaSeconds(),

        RocketDirectionalChangeSpeed);

    }

Move(const FInputActionValue& InputValue)

    MoveAxisValue = InputValue.Get<FVector2D>().GetSafeNormal();


    const FRotator YawRotation(0, Controller->GetControlRotation().Yaw, 0);

    const FVector ForwardDir = FRotationMatrix(YawRotation).GetScaledAxis(EAxis::X);

    const FVector RightDir = FRotationMatrix(YawRotation).GetScaledAxis(EAxis::Y);

    const FVector MovementDirection = ForwardDir * MoveAxisValue.Y + RightDir * MoveAxisValue.X;

    HandleRocketMovement(MovementDirection);

    LastMovementDirection -= LastMovementDirection * RocketDirectionalChangeSpeed * GetWorld()->GetDeltaSeconds();

    LastMovementDirection = LastMovementDirection.GetClampedToMaxSize(1.0f);

Rail Grinding

Predetermined splines in the world allows you to grind, which the magnet helps to make it more forgiving while jumping

RailGrindingMagnet(float DeltaTime)

if (!bIsRailSplineCollided && !GetCharacterMovement()->IsMovingOnGround())

    {


        if (GetWorld()->SweepMultiByChannel(HitResults, 

           TraceStart, 

           TraceEnd, 

           FQuat::Identity, 

           ECC_Pawn, 

           FCollisionShape::MakeSphere(100.0f), Params))

        {

            float MinDistanceSquared = MAX_FLT;

            FVector ClosestPointOnSpline = FVector::ZeroVector;


            for (const FHitResult& HitResult : HitResults)

            {

               

                if (HitResult.GetActor() && HitResult.GetComponent())

                {

                    AActor* HitActor = HitResult.GetActor();

                    TArray<FName> ActorTags = HitActor->Tags;

                    if (HitActor->ActorHasTag("Rail"))

                    {

                        USplineComponent* SplineComponent = 

                        Cast<USplineComponent>(HitActor->FindComponentByClass<USplineComponent>());

                        if (SplineComponent)

                        {

                            FVector ClosestPoint =  SplineComponent->FindLocationClosestToWorldLocation(HitResult.Location, 

                                                  ESplineCoordinateSpace::World);


                            float DistanceSquared = FVector::DistSquared(TraceStart, ClosestPoint);


                            if (DistanceSquared < MinDistanceSquared)

                            {

                                MinDistanceSquared = DistanceSquared;

                                ClosestPointOnSpline = ClosestPoint;

                            }

                            FVector NewLocation = FMath::VInterpTo(GetActorLocation(), ClosestPointOnSpline, DeltaTime, 18.5f);

                            SetActorLocation(NewLocation);

                        }

                    }

                }

            }

        }

    }

MoveAlongRail(float DeltaTime)

 if ( RailSpline && bIsRailSplineCollided )

    {

        TimeAlongSpline += DeltaTime;


        SplineLocation = RailSpline->GetLocationAtDistanceAlongSpline(DistanceAlongSpline, ESplineCoordinateSpace::World);

        RailTangent = RailSpline->GetTangentAtDistanceAlongSpline(DistanceAlongSpline, ESplineCoordinateSpace::World);

       

        if(!SetSplineDirection)

            SetRailVariables();

       

        SetActorLocation(SplineLocation + FVector(0.f, 0.f, GetCapsuleComponent()->GetScaledCapsuleHalfHeight()));


        FVector NewMeshLocation = FVector(0, 0, FMath::Lerp(-79.5f, -80.5f, FMath::Cos(CurveFrequency * GetWorld()->TimeSeconds)));

        FVector InterpolatedLocation = FMath::VInterpTo(GetMesh()->GetRelativeLocation(), NewMeshLocation, DeltaTime, 5.0f);


        GetMesh()->SetRelativeLocation(InterpolatedLocation);


        SplineMoveDirection = ( SplineLocation - LastPlayerPos );


        const FVector RotationDirection = ( SplineLocation - PreviousRailLocation ).GetSafeNormal();

        FRotator TargetRotation = RotationDirection.Rotation();


        float InterpSpeed = 5.0f;


        FRotator NewRotation = FMath::RInterpTo(GetActorRotation(), TargetRotation, DeltaTime, InterpSpeed);

        SetActorRotation(NewRotation);

       

        LastMovementDirection = SplineMoveDirection;

        bool bMovingForward = SplineDot > 0.0f;

        if ( !bIsSprinting )

            SplineMoveDistance = RailGrindSpeed * DeltaTime;

        else

            SplineMoveDistance = RailGrindSpeed * ( RocketSpeedMultiplier / 1.5f ) * DeltaTime;


        if ( !bMovingForward )

            SplineMoveDistance = -SplineMoveDistance;


        if ( ( DistanceAlongSpline <= 0.01f || DistanceAlongSpline >= SplineLength ) && TimeAlongSpline > 0.2f )

        {

            SplineExit();

        }

        DistanceAlongSpline = FMath::Clamp( DistanceAlongSpline + SplineMoveDistance, 0.f, SplineLength );


        PreviousRailLocation = SplineLocation;

    }

Challenges 

Movement

You lost your rocket after attacking or being attacked, leading to gameplay where you only had to back off because you didn't have any other form of offense/defense abilities, which wasn't intuitive gameplay.

Rail Grinding

Initially rail grinding was frustrating due to the size of the players collider making it difficult to jump on the rails

Solutions & Outcome

Movement

After playtesting, we removed the option to exit the rocket to streamline gameplay.

This adjustment focused the player’s movement on the rocket mechanics, enhancing overall game coherence and simplicity.

Rail Grinding

Added a magnet feature that activates when the player is jumping. This helps to grab the rails without making the game easy. 

The magnet improved the gameplay experience by reducing frustration while maintaining the game's challenge.