void ATankPlayerController::GetCrosshairScreenLocation(FVector2D& ScreenLocation) const
{
int32 ViewportSizeX, ViewportSizeY, ScreenX, ScreenY;
GetViewportSize(ViewportSizeX, ViewportSizeY);
ScreenX = ViewportSizeX * CrosshairXLocation;
ScreenY = ViewportSizeY * CrosshairYLocation;
ScreenLocation.X = ViewportSizeX * CrosshairXLocation;
ScreenLocation.Y = ViewportSizeY * CrosshairYLocation;
}
void ASrPlayerPawn::UpdateSpringArmLength(UWorld* World)
{
if (World && CameraComponent && CameraBoomComponent)
{
auto Viewport = World->GetGameViewport();
if (Viewport)
{
auto ViewportSize = FVector2D::ZeroVector;
Viewport->GetViewportSize(ViewportSize);
CameraBoomComponent->TargetArmLength = 0.5f * VisibleHorizontalArea / FMath::Tan(FMath::DegreesToRadians(CameraComponent->FieldOfView / 2.0f));
CameraBoomComponent->SocketOffset = FVector(0.0f, 0.0f, (ViewportSize.Y / ViewportSize.X) * VisibleHorizontalArea / 2.0f);
}
}
}
bool ATankPlayerController::GetSightRayHitLocation(FVector& HitLocation) const
{
int32 ViewportSizeX, ViewportSizeY;
GetViewportSize(ViewportSizeX, ViewportSizeY);
FVector LookDirection;
FVector2D ScreenLocation = FVector2D(CrosshairXLocation * ViewportSizeX,
CrosshairYLocation * ViewportSizeY);
if (GetLookDirection(ScreenLocation, LookDirection))
{
return GetLookVectorHitLocation(LookDirection, HitLocation);
}
return false;
}
void UFloatingTextWidget::Tick_Implementation(FGeometry myGeometry, float inDeltaTime)
{
auto curPos = GetSlot(messageLabel)->GetPosition();
GetSlot(messageLabel)->SetPosition(curPos + FVector2D(0, -FloatingSpeed * inDeltaTime));
auto opacity = FMath::InterpExpoOut(messageLabel->ColorAndOpacity.GetSpecifiedColor().A,
FMath::Clamp(curPos.Y / (GetViewportSize().Y / 2), 0.f, 1.f),
inDeltaTime * FadeSpeed);
auto color = messageLabel->ColorAndOpacity.GetSpecifiedColor();
color.A = opacity;
SetColor(color);
if (curPos.Y < 0) RemoveFromViewport();
}
// Get world location of linetrace through crosshair, true if hits landscape
bool ATankPlayerController::GetSightRayHitLocation(FVector& HitLocation) const
{
// Find the crosshair position in pixel coordinates
int32 ViewportSizeX, ViewportSizeY;
GetViewportSize(ViewportSizeX, ViewportSizeY);
auto ScreenLocation = FVector2D(ViewportSizeX * CrosshairXLocation, ViewportSizeY * CrosshairYLocation);
// "De-project" the screen position of the crosshair to a world direction
FVector LookDirection;
if (GetLookDirection(ScreenLocation, LookDirection))
{
// Line-trace along that LookDirection, and see what we hit (up to max range)
return GetLookVectorHitLocation(LookDirection, HitLocation);
}
return false;
}
bool ATankPlayerController::GetSightRayHitLocation(FVector& OutHitLocation) const
{
// Find the crosshair position
int32 ViewportSizeX, ViewportSizeY;
GetViewportSize(OUT ViewportSizeX, OUT ViewportSizeY);
FVector2D ScreenLocation = FVector2D(ViewportSizeX * CrossHairXLocation, ViewportSizeY * CrossHairYLocation);
FVector LookDirection;
if(GetLookDirection(ScreenLocation, LookDirection))
{
return GetLookVectorHitLocation(LookDirection, OUT OutHitLocation);
}
// Line trace along that look direction, and see what we hit (up to a max range)
return false;
}
// Get world location of line trace through crosshair, true if this landscape
bool ATankPlayerController::GetSightRayHitLocation(FVector& HitLocation) const
{
// Find the crosshair posisiton
int32 ViewportSizeX, ViewportSizeY;
GetViewportSize(ViewportSizeX, ViewportSizeY);
FVector2D ScreenLocation = FVector2D(ViewportSizeX * CrossHairXLocation, ViewportSizeY * CrossHairYLocation);
// "De-project" the screen position of the crosshair to a world direction
FVector LookDirection;
FHitResult HitResult;
if (GetLookDirection(ScreenLocation, LookDirection))
{
return GetLookVectorHitLocation(LookDirection, HitLocation);
}
return false;
}
void ABaleroPlayerController::OnRightClickPressed()
{
UE_LOG(LogTemp, Warning, TEXT("rightclick"));
FHitResult Hit;
GetHitResultUnderCursor(ECC_Visibility, false, Hit);
FVector2D MouseLocation;
GetMousePosition(MouseLocation.X, MouseLocation.Y);
int32 ViewportX;
int32 ViewportY;
GetViewportSize(ViewportX, ViewportY);
if (MouseLocation.X > ViewportX * .9f)
{
return;
}
if (Hit.bBlockingHit)
{
UE_LOG(LogTemp, Warning, TEXT("rightclickedsomething"));
APawn* pawn = Cast<APawn>(Hit.GetActor());
if (pawn != NULL)
{
UE_LOG(LogTemp, Warning, TEXT("clicked pawn"));
ABaleroCharacter* Unit = Cast<ABaleroCharacter>(pawn);
if (Unit != NULL)
{
MoveToActor(Unit);
}
}
else
{
MoveToMouseCursor();
}
}
}
bool ATankPlayerController::GetSightRayHitLocation(FVector& HitLocation) const
{
// Find the crosshair position
int32 ViewportSizeX, ViewportSizeY;
GetViewportSize(ViewportSizeX, ViewportSizeY);
FVector2D ScreenLocation = FVector2D(CrossHairXLocation * ViewportSizeX,
CrosshairYLocation * ViewportSizeY);
// "De-project" the screen position of the crosshair to a world direction
FVector LookDirection;
FHitResult HitResult;
if (GetLookDirection(ScreenLocation, LookDirection))
{
// Line-trace along that look direction, and see what we hit (up to max range)
if (GetLookVectorHitLocation((HitResult), LookDirection, HitLocation))
{
}
}
return true;
}
//-----------------------------------------------------------------------------
// Updates the relative orientation of the camera, spring mode
//-----------------------------------------------------------------------------
void CWeaponIFMSteadyCam::ComputeMouseRay( const VMatrix &steadyCamToPlayer, Vector &vecForward )
{
// Create a ray in steadycam space
float flMaxD = 1.0f / tan( M_PI * m_flFOV / 360.0f );
// Remap offsets into normalized space
int w, h;
GetViewportSize( w, h );
float flViewX = ( w != 0 ) ? m_vecViewOffset.x / ( w / 2 ) : 0.0f;
float flViewY = ( h != 0 ) ? m_vecViewOffset.y / ( h / 2 ) : 0.0f;
flViewX *= flMaxD;
flViewY *= flMaxD;
Vector vecSelectionDir( 1.0f, -flViewX, -flViewY );
VectorNormalize( vecSelectionDir );
// Rotate the ray into player coordinates
Vector3DMultiply( steadyCamToPlayer, vecSelectionDir, vecForward );
}
void ASrPlayerPawn::UpdateWorldToScreenCoef(UWorld* World)
{
if (World)
{
auto Viewport = World->GetGameViewport();
if (Viewport)
{
auto ViewportSize = FVector2D::ZeroVector;
Viewport->GetViewportSize(ViewportSize);
if (!ViewportSize.X == 0)
{
WorldToScreenCoef = VisibleHorizontalArea / ViewportSize.X;
}
else
{
WorldToScreenCoef = 1.0f;
}
}
}
}
bool ATankPlayerController::GetSightRayHitLocation( FVector& HitLocation ) const
{
//Find the crosshair position in pixel coordinates
int32 ViewportSizeX, ViewportSizeY;
GetViewportSize(ViewportSizeX, ViewportSizeY);
auto ScreenLocation = FVector2D(ViewportSizeX * CrossHairXLocation, ViewportSizeY * CrossHairYLocation);
FVector LookDirection;
if(GetLookDirection(ScreenLocation, LookDirection))
{
// Line trace along that look direction, and see what we hit (up to max range)
if(GetLookVectorHitLocation(LookDirection, HitLocation))
{
//UE_LOG(LogTemp, Warning, TEXT("Hit Location: %s"), *HitLocation.ToString());
}
}
return true;
}
void ASECharacterController::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
if (auto PS = CastChecked<ASECharacterState>(PlayerState))
{
auto LocalPlayer = CastChecked<ULocalPlayer>(this->Player);
auto ViewportClient = LocalPlayer->ViewportClient;
FViewport* Viewport = ViewportClient->Viewport;
FVector2D ViewportSize;
switch (PS->CursorState)
{
case ECharacterCursorState::Uncontrolled:
this->bShowMouseCursor = true;
Viewport->LockMouseToViewport(false);
Viewport->CaptureMouse(false);
break;
case ECharacterCursorState::Free:
this->bShowMouseCursor = false;
Viewport->LockMouseToViewport(true);
Viewport->CaptureMouse(false);
break;
case ECharacterCursorState::Locked:
this->bShowMouseCursor = false;
Viewport->LockMouseToViewport(true);
Viewport->CaptureMouse(true);
ViewportClient->GetViewportSize(ViewportSize);
const int32 X = static_cast<int32>(ViewportSize.X * 0.5f);
const int32 Y = static_cast<int32>(ViewportSize.Y * 0.5f);
Viewport->SetMouse(X, Y);
break;
}
}
}
void ABaleroPlayerController::OnClickPressed()
{
UE_LOG(LogTemp, Warning, TEXT("clickpressed"));
FHitResult Hit;
GetHitResultUnderCursor(ECC_Visibility, false, Hit);
FVector2D MouseLocation;
GetMousePosition(MouseLocation.X, MouseLocation.Y);
int32 ViewportX;
int32 ViewportY;
GetViewportSize(ViewportX, ViewportY);
if (MouseLocation.X > ViewportX * .9f)
{
return;
}
if (Hit.bBlockingHit)
{
UE_LOG(LogTemp, Warning, TEXT("clickedsomething"));
APawn* pawn = Cast<APawn>(Hit.GetActor());
if (pawn != NULL)
{
UE_LOG(LogTemp, Warning, TEXT("clicked pawn"));
ABaleroCharacter* Unit = Cast<ABaleroCharacter>(pawn);
if (Unit != NULL)
{
//deselect the clicked unit
if (SelectedUnits.Contains(Unit))
{
RemoveUnitFromSelection(Unit);
}
//add unit to selection
else
{
AddUnitToSelection(Unit);
}
}
}
else
{
//give move command to move
UE_LOG(LogTemp, Warning, TEXT("MOVE COMMAND_A"));
for (ABaleroCharacter* Unit : SelectedUnits)
{
AAIControllerBase* AIControl = Cast<AAIControllerBase>(Unit->GetController());
FVector loc = Unit->GetActorLocation();
UE_LOG(LogTemp, Warning, TEXT("Unit ai: %s , pos: %.1f %.1f %.1f"), *(AActor::GetDebugName(AIControl)), loc.X, loc.Y, loc.Z);
}
MoveToMouseCursor();
}
}
else
{
UE_LOG(LogTemp, Warning, TEXT("MOVE COMMAND_B"));
MoveToMouseCursor();
}
}
