Lewis Hill

Ball Control

By adding a PhysicsHandle Component on the Player and creating a cusotm "Grabber" class, I was able to add the functionality of picking up and throwing the ball. The Grabber checks against a custom trace channel to see if any valid objects are within grabbing distance. The PhysicsHandle deals with grabbing the object. In Tick, the location of the grabbed object is updated.

When the ball is thrown, it is released from the PhysicsHandle and an impulse is added to it. By holding down the Throw button before releasing, more power is added to the impulse. I added a shake to the ball using a Vector Timeline to add small offsets to the ball while the throw is charging up.

The springy feel of the ball while it's grabbed is achieved by altering some of the values found on the PhysicsHandle.

• See Grabber Code

  bool UGrabber::GetGrabbableInReach(FHitResult& OutHitResult) const
  	{
  		FVector Start = GetComponentLocation();
  		FVector End = Start + GetForwardVector() * MaxGrabDistance;
  		DrawDebugLine(GetWorld(), Start, End, FColor::Orange);
  	
  		FCollisionShape Sphere = FCollisionShape::MakeSphere(GrabRadius);
  		return GetWorld()->SweepSingleByChannel(
  			OutHitResult,
  			Start, End,
  			FQuat::Identity,
  			ECC_GameTraceChannel2,
  			Sphere
  		);
  	}
  	
  	void UGrabber::Grab()
  	{
  		//Only attempt to grab if we have a physics component, or if the turn is still on-going
  		if (GetPhysicsHandleComponent() == nullptr || GameMode->IsTurnOver)
  		{
  			return;
  		}
  	
  		//Test to see if any grabbable objects are within range
  		FHitResult HitResult;
  		bool HasHit = GetGrabbableInReach(HitResult);
  	
  		if (HasHit && GameMode)
  		{
  			//Reset projectile spawn points ready to use again
  			if (Spawner)
  			{
  				Spawner->SetVisibility(true, 0, Spawner->SpawnedObjects.Num());
  				Spawner->ResetLocation();
  			}
  	
  			UPrimitiveComponent* HitComponent = HitResult.GetComponent();
  			AActor* HitActor = HitResult.GetActor();
  	
  			if (Cast(HitActor))
  			{
  				if (GameMode->IsPlacingPhase)
  				{
  					return;
  				}
  	
  				GameMode->SetGrabbedBallUI(true, true);
  				PlayerCharacter->IsHoldingBall = true;
  			}
  	
  			ToyboxObject = Cast(HitActor);
  	
  			if (ToyboxObject)
  			{
  				ToyboxObject->SecondMesh->AttachToComponent(ToyboxObject->Mesh, FAttachmentTransformRules::KeepWorldTransform);
  				
  				if (!GetMatchingToyboxObject(HitComponent))
  				{
  					return;
  				}
  			}
  	
  			FRotator TargetRotation = FRotator(ToyBoxRotationX, GetComponentRotation().Yaw, ToyBoxRotationZ);
  	
  			//If we've grabbed a toybox spawner, spawn a toybox object and grab that object
  			if (AToyboxSpawner* ToyboxSpawner = Cast(HitActor))
  			{
  				if (GameMode->ToyboxObjectsLeftToSpawn == 0)
  				{
  					return;
  				}
  	
  				//Make sure the toybox spawner outline is deactivated 
  				if (CurrentOutlinedComponent)
  				{
  					CurrentOutlinedComponent->SetRenderCustomDepth(false);
  					CurrentOutlinedComponent = nullptr;
  					GameMode->GrabbableObjectInView(false);
  				}
  	
  				ToyboxObject = ToyboxSpawner->SpawnToyboxObject();
  	
  				if (ToyboxObject)
  				{
  					//Stop spinning toybox objects spinning while holding
  					if (ToyboxObject->ShouldSpin)
  					{
  						ToyboxObject->IsSpinning = false;
  					}
  	
  					ToyBoxObjectMesh = ToyboxObject->Mesh;
  	
  					SetGrabbedComponent(ToyBoxObjectMesh, HitResult.GetActor()->GetActorLocation(), TargetRotation);
  	
  					if (GameMode)
  					{
  						GameMode->PlacedToyboxObjects.Add(ToyboxObject);
  						GameMode->ToyboxObjectsLeftToSpawn--;
  						GameMode->UpdatePlacingPhaseText(ToyboxObject, true);
  					}
  	
  					//Save the profile of the toybox object and set all channels to overlap
  					ChangeToyboxMeshCollision(true);
  				}
  					
  				return;
  			}
  	
  			SetGrabbedComponent(HitComponent, HitResult.GetActor()->GetActorLocation(), TargetRotation);
  	
  			if (Cast(GrabbedComponent->GetOwner()))
  			{
  				GetOwner()->Tags.Add("HoldingBall");
  			}
  	
  			//Turn off object outline if there are any activated
  			if (CurrentOutlinedComponent)
  			{
  				CurrentOutlinedComponent->SetRenderCustomDepth(false);
  				CurrentOutlinedComponent = nullptr;
  				GameMode->GrabbableObjectInView(false);
  			}
  	
  			if (ToyboxObject)
  			{
  				//Stop spinning toybox objects spinning while holding
  				if (ToyboxObject->ShouldSpin)
  				{
  					ToyboxObject->IsSpinning = false;
  				}
  	
  				ToyBoxObjectMesh = ToyboxObject->Mesh;
  				ChangeToyboxMeshCollision(true);
  	
  				if (GameMode)
  				{
  					GameMode->UpdatePlacingPhaseText(ToyboxObject, true);
  				}
  			}
  			else
  			{
  				ToyBoxObjectMesh = nullptr;
  				ToyboxObject = nullptr;
  			}
  		}
  	}
  	
  	void UGrabber::Release()
  	{
  		//If an object is being grabbed
  		if (GetPhysicsHandleComponent() && GrabbedComponent)
  		{	
  			if (Cast(GrabbedComponent->GetOwner()))
  			{
  				GameMode->SetGrabbedBallUI(false, true);
  				PlayerCharacter->IsHoldingBall = false;
  			}
  	
  			//If the grabbed object is a ToyBox object
  			if (GrabbedComponent->GetOwner()->ActorHasTag("Toybox") && ToyBoxObjectMesh)
  			{
  				if (ToyboxObject->CurrentOverlappingActors > 0)
  				{
  					return;
  				}
  	
  				//Let spinning objects spin again on release
  				if (ToyboxObject->ShouldSpin)
  				{
  					ToyboxObject->IsSpinning = true;
  				}
  	
  				if (GameMode)
  				{
  					GameMode->UpdatePlacingPhaseText(ToyboxObject, false);
  				}
  	
  				ChangeToyboxMeshCollision(false);
  			}
  	
  			if (Cast(GrabbedComponent->GetOwner()))
  			{
  				GetOwner()->Tags.Remove("HoldingBall");
  			}
  	
  			HoldDistance = 50.f;
  			GrabbedComponent->WakeAllRigidBodies();
  			GrabbedComponent->GetOwner()->Tags.Remove("Grabbed");
  			GrabbedComponent = nullptr;
  			GetPhysicsHandleComponent()->ReleaseComponent();
  	
  			if (ToyboxObject)
  			{
  				ToyboxObject->SecondMesh->DetachFromComponent(FDetachmentTransformRules::KeepWorldTransform);
  			}
  	
  			if (Spawner)
  			{
  				Spawner->SetVisibility(false, 0, Spawner->SpawnedObjects.Num());
  			}
  		}
  	}
  	
  	void UGrabber::Throw(bool IsRandomThrow)
  	{
  		if (GrabbedComponent == nullptr)
  		{
  			return;
  		}
  	
  		if (GameMode)
  		{
  			GameMode->ThrowLocation = GetOwner()->GetActorLocation();
  		}
  	
  		if (IsRandomThrow)
  		{
  			GrabbedComponent->
  				AddImpulse(FVector(GetForwardVector().X + FMath::RandRange(-1.f, 1.f),
  					GetForwardVector().Y + FMath::RandRange(-1.f, 1.f),
  					GetForwardVector().Z + FMath::RandRange(-1.f, 1.f))
  					* CurrentThrowPower, NAME_None, false);
  		}
  		else
  		{
  			GrabbedComponent->SetPhysicsLinearVelocity(FVector(0, 0, 0));
  			GrabbedComponent->AddImpulse(GetForwardVector() * CurrentThrowPower, NAME_None, false);
  		}
  	
  		FVector Velocity = GetForwardVector() * CurrentThrowPower;
  	
  		if (PlayerCharacter->GetCharacterMovement()->IsFalling())
  		{
  			if (PlayerActionsLeft > 0)
  			{
  				GameMode->ActionPerformed(PlayerActionName);
  				PlayerActionsLeft--;
  			}
  		}
  	
  		Release();
  	}
  	
  	void UGrabber::SetGrabbedComponent(UPrimitiveComponent* ComponentToSet, FVector Location, FRotator Rotation)
  	{
  		if (ToyboxObject)
  		{
  			ComponentToSet->SetSimulatePhysics(true);
  		}
  	
  		UE_LOG(LogTemp, Display, TEXT("%s : turned on physics sim"), *ComponentToSet->GetName());
  		ComponentToSet->WakeAllRigidBodies();
  		ComponentToSet->GetOwner()->Tags.Add("Grabbed");
  	
  		GetPhysicsHandleComponent()->GrabComponentAtLocationWithRotation(
  			ComponentToSet,
  			NAME_None,
  			Location,
  			Rotation
  		);
  	
  		GrabbedComponent = GetPhysicsHandleComponent()->GetGrabbedComponent();
  	}

• Jump to top

Toybox Object behaviours

The ToyBox objects, such as the Bounce Pad and Cannons, are the edge that allows Players to create complex shots and help them win the game. Performing certain tricks like bouncing the ball off the Bounce Pad are tracked using events. If you make a successful shot, the next Players must match the amount of tricks you performed.

You can win the game if you can pull off a complex shot with lots of chained tricks that the next players can't match.

There is a general "ToyboxObject" class that contains functionality that all the objects share. For unique behaviours, blueprint subclasses are made for each object, with the bounce of the pad being added as a custom "Bouncer" component for example.

Picking up and Placing ToyBox Objects

To make the game harder over time, every round a Player is allowed to place a new ToyBox Object, which can be rotated and placed in the positioned in an optimal location for performing more tricks. Objects can only be placed if they aren't overlapping other objects or specific "No Place" zones, designed so the game doesn't get softlocked, such as around the hoop and in the spawn area.

Calculating the amount of objects overlapping the ToyBox object is done by incremeneting or decrementing a "CurrentOverlappingActors" int variable whenever OnOverlapBegin or OnOverlapEnd is called, which is a low cost method of finding this information. When the value is 0, it can be placed.

I also change the collision profile of the objects while grabbing them. Ordinarily the Bounce Pad blocks most objects, which I couldn't have while grabbing it. So while grabbing, the object collision profiles are set to OverlapAllDynamic, and reset to their original collision profiles on release.

• See ToyBox Object Code

  #include "ToyboxObject.h"
  	#include "Components/SphereComponent.h"
  	#include "Kismet/GameplayStatics.h"
  	
  	// Sets default values
  	AToyboxObject::AToyboxObject()
  	{
  		 // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
  		PrimaryActorTick.bCanEverTick = true;
  	
  		Mesh = CreateDefaultSubobject("Mesh");
  		RootComponent = Mesh;
  	
  		SecondMesh = CreateDefaultSubobject("Second Mesh");
  		SecondMesh->SetupAttachment(Mesh);
  	
  		PlacingSpaceCollider = CreateDefaultSubobject("Placing Space Collider");
  		PlacingSpaceCollider->SetupAttachment(Mesh);
  	}
  	
  	// Called when the game starts or when spawned
  	void AToyboxObject::BeginPlay()
  	{
  		Super::BeginPlay();
  	
  		Mesh->OnComponentBeginOverlap.AddDynamic(this, &AToyboxObject::OnOverlapBegin);
  		Mesh->OnComponentEndOverlap.AddDynamic(this, &AToyboxObject::OnOverlapEnd);
  		PlacingSpaceCollider->OnComponentBeginOverlap.AddDynamic(this, &AToyboxObject::OnOverlapBegin);
  		PlacingSpaceCollider->OnComponentEndOverlap.AddDynamic(this, &AToyboxObject::OnOverlapEnd);
  	
  		//Save the original material and collision profile 
  		OriginalMeshMaterial = Mesh->GetMaterial(0);
  		MeshCollisionProfileName = Mesh->GetCollisionProfileName();
  	
  		if (SecondMesh->GetStaticMesh())
  		{
  			OriginalSecondMeshMaterial = SecondMesh->GetMaterial(0);
  			SecondMeshCollisionProfileName = SecondMesh->GetCollisionProfileName();
  		}
  	}
  	
  	// Called every frame
  	void AToyboxObject::Tick(float DeltaTime)
  	{
  		Super::Tick(DeltaTime);
  	
  		if (ShouldSpin && IsSpinning)
  		{
  			Mesh->AddLocalRotation(SpinRotation);
  		}
  	}
  	
  	void AToyboxObject::SetSpinRotation(FRotator Rotation)
  	{
  		SpinRotation = Rotation;
  	}
  	
  	void AToyboxObject::OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
  	{
  		//Return if overlappng with other colliders on the actor
  		if (OtherActor == this || OtherActor == UGameplayStatics::GetPlayerPawn(this, 0)) 
  		{
  			return;
  		}
  	
  		CurrentOverlappingActors++;
  	}
  	
  	void AToyboxObject::OnOverlapEnd(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
  	{
  		//Return if overlappng with other colliders on the actor
  		if (OtherActor == this || OtherActor == UGameplayStatics::GetPlayerPawn(this, 0))
  		{
  			return;
  		}
  	
  		CurrentOverlappingActors--;
  	}
  	
  	void AToyboxObject::SetMaterial(bool IsGrabbing, bool CanPlace)
  	{
  		if (IsGrabbing)
  		{
  			if (CanPlace)
  			{
  				Mesh->SetMaterial(0, CanDropGrabbedMaterial);
  	
  				if (SecondMesh->GetStaticMesh())
  				{
  					SecondMesh->SetMaterial(0, CanDropGrabbedMaterial);
  				}
  			}
  			else
  			{
  				Mesh->SetMaterial(0, CannotDropGrabbedMaterial);
  	
  				if (SecondMesh->GetStaticMesh())
  				{
  					SecondMesh->SetMaterial(0, CannotDropGrabbedMaterial);
  				}
  			}
  		}
  		else
  		{
  			Mesh->SetMaterial(0, OriginalMeshMaterial);
  	
  			if (SecondMesh->GetStaticMesh())
  			{
  				SecondMesh->SetMaterial(0, OriginalSecondMeshMaterial);
  			}
  		}
  	}
  	
  	void AToyboxObject::SetCollision(bool IsGrabbing)
  	{
  		if (IsGrabbing)
  		{
  			Mesh->SetCollisionResponseToAllChannels(ECR_Overlap);
  	
  			if (SecondMesh->GetStaticMesh())
  			{
  				SecondMesh->SetCollisionResponseToAllChannels(ECR_Overlap);
  			}
  		}
  		else
  		{
  			Mesh->SetCollisionProfileName(MeshCollisionProfileName);
  	
  			if (SecondMesh->GetStaticMesh())
  			{
  				SecondMesh->SetCollisionProfileName(SecondMeshCollisionProfileName);
  			}
  		}
  	}

• Jump to top