// Called when the game starts or when spawned void AMyPlayer::BeginPlay() { Super::BeginPlay(); //FRotator ActorRotation = GetActorRotation(); SetActorLocation(startLocation); }
void ARockSpell::StartBehavior(const APlayerCharacter& player) { this->SetActorHiddenInGame(false); this->SetActorEnableCollision(true); RockMesh->Activate(true); SetActorLocation(player.GetActorLocation() + player.GetActorForwardVector() * 100,false,(FHitResult*)nullptr,ETeleportType::TeleportPhysics); movementComponent->InitializeAndStart(MaxRockDistance, chargedTime, player.GetActorForwardVector()); }
// Called every frame void AItem::Tick(float DeltaTime) { Super::Tick(DeltaTime); FVector NewLocation = GetActorLocation(); float DeltaHeight = (FMath::Sin(RunningTime + DeltaTime) - FMath::Sin(RunningTime)); NewLocation.Z += DeltaHeight * Magnitude; RunningTime += DeltaTime; SetActorLocation(NewLocation); }
// Called every frame void ALoadingFile::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); FVector NewLocation = GetActorLocation(); float DeltaHeight = (FMath::Sin(RunningTime + DeltaTime) - FMath::Sin(RunningTime)); NewLocation.Z += DeltaHeight * 20.0f; RunningTime += DeltaTime; SetActorLocation(NewLocation); }
//Moves the spawner to a point within a hemisphere of its starting location. void AAsteroidSpawner::CalculateNextPosition() { FVector NewLocation = DefaultLocation; NewLocation.X += SpawnRange * FMath::Cos(FMath::RandRange(0, 360)) * FMath::Cos(FMath::RandRange(0, 360)); NewLocation.Y += SpawnRange * FMath::Cos(FMath::RandRange(0, 360)) * FMath::Sin(FMath::RandRange(0, 360)); NewLocation.Z += std::max(SpawnRange * FMath::Sin(FMath::RandRange(0, 360)), DefaultLocation.Z); SetActorLocation(NewLocation); }
// Called every frame void ABaseCharacter::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); if(_cooldown > 0.0f) _cooldown -= DeltaTime; FVector loc = GetActorLocation(); loc.Y = 0.0f; SetActorLocation(loc); }
void APlayerOvi::OnMobilePlatform(AMobilePlatform *mp, FVector movement){ if (!m_isJumping){ FVector loc = GetActorLocation(); SetActorLocation(loc + movement); m_isOnMobilePlatform = true; } else{ m_isOnMobilePlatform = false; } }
// Called every frame void AEnemy::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); //Make Actor Float in Air FVector Enemy_Location = GetActorLocation(); float Delta_Z = (FMath::Sin(RunningTime + DeltaTime) - FMath::Sin(RunningTime)); Enemy_Location.Z += Delta_Z*10.0f; RunningTime += DeltaTime; SetActorLocation(Enemy_Location); }
// Called every frame void AFloating_Platform::Tick( float DeltaSeconds) { Super::Tick(DeltaSeconds); DeltaSeconds = *fTimeSpeed; FVector NewLocation = GetActorLocation(); FRotator NewRotation = GetActorRotation(); float DeltaHeight = (FMath::Sin(*RunningTime_ + DeltaSeconds) - FMath::Sin(*RunningTime_)); NewLocation.Z += DeltaHeight * (*fFlyingZ); *RunningTime_ += DeltaSeconds; SetActorLocation(NewLocation); }
// Called every frame void APawnWithCamera::Tick(float DeltaTime) { Super::Tick(DeltaTime); //Rotate our actor's yaw, which will turn our camera because we're attached to it { FRotator NewRotation = OurCameraBase->GetComponentRotation(); NewRotation.Yaw += -CameraInput.X; OurCameraBase->SetWorldRotation(NewRotation); } //Rotate our camera's pitch, but limit it so we're always looking downward { FRotator NewRotation = OurCameraBase->GetComponentRotation(); NewRotation.Pitch = FMath::Clamp(NewRotation.Pitch - CameraInput.Y, -80.0f, 80.0f); OurCameraBase->SetWorldRotation(NewRotation); } //Handle movement based on our "MoveX" and "MoveY" axes { if (!MovementInput.IsZero()) { //Scale our movement input axis values by 100 units per second MovementInput = MovementInput.SafeNormal() * 100.0f; FVector NewLocation = GetActorLocation(); NewLocation += GetActorForwardVector() * MovementInput.X * DeltaTime; NewLocation += GetActorRightVector() * MovementInput.Y * DeltaTime; SetActorLocation(NewLocation); } } FVector LeftEyePosition = LeftEyePos->GetComponentLocation() - OurCamera->GetComponentLocation(); LeftEyePosition.Normalize(); FVector RightEyePosition = RightEyePos->GetComponentLocation() - OurCamera->GetComponentLocation(); RightEyePosition.Normalize(); FVector4 LeftEyeWeight; FVector4 RightEyeWeight; for (int i = 0; i < 4; i++) { LeftEyeWeight[i] = FVector::DotProduct((LeftEyePosition - FishEyePos[i]), dir[i]) / length[i]; RightEyeWeight[i] = FVector::DotProduct((RightEyePosition - FishEyePos[i]), dir[i]) / length[i]; } RV_MatInst->SetVectorParameterValue(FName("LeftEyePos"), LeftEyePosition); RV_MatInst->SetVectorParameterValue(FName("RightEyePos"), RightEyePosition); RV_MatInst->SetVectorParameterValue(FName("RightWeight"), LeftEyePosition); RV_MatInst->SetVectorParameterValue(FName("LeftWeight"), RightEyePosition); }
// Called every frame void AFlatEarth::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); FVector Position = GetActorLocation(); Position.Y -= 10; if (Position.Y == SwapPosition) { Position.Y = StartPosition; } SetActorLocation(Position); }
void AInertiaCamera::Tick(float Delta) { if (FollowComponent == NULL) { return; } FVector Location = GetActorLocation(); FRotator Rotation = GetActorRotation(); FVector CompLocation = FollowComponent->GetComponentLocation(); FRotator CompRotation = FollowComponent->GetComponentRotation(); Location = Location * 0.7 + CompLocation * 0.3; Rotation = Rotation * 0.7 + CompRotation * 0.3; LocationError = (CompLocation - Location) * 0.05 + LocationError * 0.95; RotationError = (CompRotation - Rotation) * 0.05 + RotationError * 0.95; //Location = FMath::VInterpTo(Location, CompLocation, Delta, 10); //Rotation = FMath::RInterpTo(Rotation, CompRotation, Delta, 10); SetActorRotation(Rotation + RotationError); SetActorLocation(Location + LocationError); /* CurrentLocation = 0.5 * CurrentLocation + 0.5 * FollowComponent->GetComponentLocation(); FTransform Transform = FollowComponent->ComponentToWorld; FTransform CurrentTransform = GetTransform(); Transform.Rotat FTransform ThisTransform = UKismetMathLibrary::TInterpTo(GetTransform(), Transform, Delta, 10); SetActorTransform(ThisTransform);*/ //SetActorLocation(CurrentLocation); //FVector MyLocation = GetActorLocation(); //FVector CurrentLocation = FollowComponent->GetComponentLocation(); //SetActorLocation(CurrentLocation, false); //SetActorRotation(FollowComponent->GetComponentRotation()); //SetActorLocation(FollowActor->GetActorLocation() + FollowComponent->RelativeLocation); //SetActorTransform(FollowComponent->GetRelativeTransform() * FollowActor->GetTransform()); //SetActorLocation(FollowActor->GetActorLocation() + FVector(0, 0, 1000)); //FTransform Trans = FollowComponent->ComponentToWorld; //FVector LocationComp = CurrentLocation; //FVector LocationAct = FollowActor->GetActorLocation(); //FVector MyLoc = GetActorLocation(); //SetActorLocation(LocationComp); //SetActorRotation(FollowComponent->GetComponentRotation()); }
//======================================================================== void C_DudeDrop::Start() { auto companion = m_Dude.GetCompanion(); if (!companion) { return; } companion->DetachRootComponentFromParent(false); companion->SetActorLocation(m_Dude.GetActorLocation()); companion->OnDrop(); m_Dude.SetCompanion(nullptr); }
void AProjectile::DeactivateProjectile() { bIsActive = false; SetActorHiddenInGame(true); //set the projectile in a hidden position outside game SetActorLocation(FVector(0, 1000, 3000)); //deactive collisions and movement CollisionComp->Deactivate(); MovementComp->Deactivate(); }
void AMobilePlatform::RestoreInitialState() { SetActorLocation(m_initialPosition); MobilePlatformMaterial->SetVectorParameterValue("Color", m_initialColor); Enabled = m_enabledInitial; m_state = INITIAL_DELAY; m_totalDistance = RightDistance; m_actions = 0; m_isPlayerOn = false; intermitedOn = true; m_elapsedIntermitence = 0.0f; m_movement = FVector(0); m_currentDistance = 0; }
void ALevelBlockConstructor::BeginPlay() { Super::BeginPlay(); // Get pointer to The Game Mode if (GetWorld() && GetWorld()->GetAuthGameMode() && GetWorld()->GetAuthGameMode<ARadeGameMode>()) { GetWorld()->GetAuthGameMode<ARadeGameMode>()->TheLevelBlockConstructor = this; } // Set to root of world SetActorLocation(FVector(0, 0, 0)); }
void ACapTheBrainCharacter::LooseBrain() { GotHit = false; FellDown = false; FVector newBrainPosition = this->GetActorLocation(); SetActorLocation(startPosition); SetActorRotation(startRotation); gameState->brain->DetachFromHead(this, newBrainPosition); for (int i = 0; i < gameState->characters.Num(); i++) { gameState->arrows[gameState->characters[i]->id]->ChangeMaterial(false, false, true); } }
void AAnchovieCharacter::Tick(float DeltaTime) { Super::Tick(DeltaTime); if (PatrolPath != NULL) { if (LightOn == true) { if (PatrolPath->GetSplineLength() <= DistanceOnSpline) { DistanceOnSpline = 0; } else { DistanceOnSpline += AnchovySpeed * DeltaTime; } SetActorRotation(PatrolPath->GetRotationAtDistanceAlongSpline(DistanceOnSpline, ESplineCoordinateSpace::World)); SetActorLocation(PatrolPath->GetLocationAtDistanceAlongSpline(DistanceOnSpline, ESplineCoordinateSpace::World)); } else { if (DistanceOnSpline <= 0) { DistanceOnSpline = PatrolPath->GetSplineLength(); } else { DistanceOnSpline -= AnchovySpeed * DeltaTime; } rotationTarget = PatrolPath->GetRotationAtDistanceAlongSpline(DistanceOnSpline, ESplineCoordinateSpace::World); rotationTarget.Yaw += 180; SetActorRotation(rotationTarget); SetActorLocation(PatrolPath->GetLocationAtDistanceAlongSpline(DistanceOnSpline, ESplineCoordinateSpace::World)); } } }
// Called every frame void AFollowingActor::Tick(float DeltaTime) { Super::Tick(DeltaTime); if (bFollowing && (nullptr != TargetActor)) { const float InterpSpeed = 1.0f; const FVector CurrentLocation = GetActorLocation(); const FVector InterpLocation = FMath::VInterpTo(CurrentLocation, TargetActor->GetActorLocation(), DeltaTime, InterpSpeed); const bool bSweep = false; // Do NOT perform collision detection (this is the default) SetActorLocation(InterpLocation, bSweep); } }
void AMyPlayer::MoveRight(float Value) { if ((Controller != NULL) && (Value != 0.0f) && this->GetActorLocation().X < 1950 && this->GetActorLocation().X > -150) { FTransform newLocation; newLocation.SetLocation(FVector(this->GetActorLocation().X + Value * speed, this->GetActorLocation().Y, this->GetActorLocation().Z)); newLocation.SetRotation(FQuat(FRotator(0, 0, 0))); SetActorTransform(newLocation); } else if (this->GetActorLocation().X >= 1950) { SetActorLocation(FVector(1949, this->GetActorLocation().Y, this->GetActorLocation().Z)); } else if (this->GetActorLocation().X <= -150) { SetActorLocation(FVector(-149, this->GetActorLocation().Y, this->GetActorLocation().Z)); } }
// Called every frame void APaperPawn::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); //Get Actor Vector FVector CurrentVector = GetActorLocation(); //Vector.x Value ++ CurrentVector.X += ConstLocationValue; //Set Actor Vector SetActorLocation(CurrentVector); }
void APlayerOvi::CalculateGravity(float DeltaSeconds){ FVector up = GetActorUpVector(); FVector location = GetActorLocation(); if (m_enabledGravity && !m_hasLanded && !m_isOnMobilePlatform) { if (m_actualJumpSpeed < FallSpeed) m_actualJumpSpeed += AccelerationFall * DeltaSeconds; else{ m_actualJumpSpeed = FallSpeed; } location -= m_actualJumpSpeed * DeltaSeconds * up; SetActorLocation(location); } }
// Called every frame void AFournoidKeeper::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); auto NewLocation = GetActorLocation(); auto DeltaHeight = FMath::Sin(RunningTime + DeltaTime) - FMath::Sin(RunningTime); NewLocation.Z += DeltaHeight * KeeperHoverFalloff; SetActorLocation(NewLocation); RunningTime += DeltaTime; //FollowMaster(DeltaTime); }
// Called every frame void APawnWithCamera::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); //zooming in and out code if (bZoomingIn) { ZoomFactor += DeltaTime / 0.5f; //zoom in over half a second } else { ZoomFactor -= DeltaTime / 0.25f; // zoom out over a quarter of a second } ZoomFactor = FMath::Clamp<float>(ZoomFactor, 0.0f, 1.0f); //blend our camera's FOV and our springArms length based on zoomfactor OurCamera->FieldOfView = FMath::Lerp<float>(90.0f, 60.0f, ZoomFactor); OurCameraSpringArm->TargetArmLength = FMath::Lerp<float>(400.0f, 300.0f, ZoomFactor); //camera control code { //rotate our actor's yaw which will turn our camera because we're attached to it FRotator newRot = GetActorRotation(); newRot.Yaw += CameraInput.X; SetActorRotation(newRot); //rotate the camera's pitch, but limit it so we're always looking downward FRotator newRot2 = OurCameraSpringArm->GetComponentRotation(); newRot2.Pitch = FMath::Clamp(newRot2.Pitch + CameraInput.Y, -80.0f, -15.0f); OurCameraSpringArm->SetWorldRotation(newRot2); FRotator newRot3 = OurCamera->GetComponentRotation(); newRot3.Roll = FMath::Lerp<float>(newRot.Roll, 120.0f * MovementInput.Y, DeltaTime); OurCamera->SetWorldRotation(newRot3); } //handle movememnt based on out movex and movey axes if (!MovementInput.IsZero()) { //scale our moevement input axis values by 100 units per second MovementInput = MovementInput.GetSafeNormal(); FVector newLoc = GetActorLocation(); newLoc += GetActorForwardVector() * MovementInput.X * DeltaTime * ForwardSpeed; newLoc += GetActorRightVector() * MovementInput.Y * DeltaTime * StrafeSpeed; SetActorLocation(newLoc); //also slightly roll the camera when the player strafes FRotator newRot = FRotator(GetActorRotation().Pitch, GetActorRotation().Yaw, 0.0f); newRot.Roll += MovementInput.Y * DeltaTime * StrafeSpeed; } }
// Called every frame void ADKBarrel::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); if (RotMovement) RotMovement->RotationRate = RotationRate; FVector DeltaMovement = FVector::ZeroVector; FHitResult hit; if (GetFloor(hit) && !bMovingOnLadder) { if (bMoveDirection) { DeltaMovement.Y = FMath::Abs<float>(Move) * -1;// FVector(0, -400, 0); TraceStartDistance = FMath::Abs<float>(40); RotationRate = FRotator(0, 0, -180); } else { DeltaMovement.Y = FMath::Abs<float>(Move);// FVector(0, 400, 0);; TraceStartDistance = FMath::Abs<float>(40) * -1;; RotationRate = FRotator(0, 0, 180); } bChangeDirection = true; FVector CurrentLocation = GetActorLocation(); float DesiredLocationZ = hit.Location.Z + 40; CurrentLocation.Z = DesiredLocationZ; SetActorLocation(FMath::VInterpTo(GetActorLocation(), CurrentLocation, DeltaTime, 5)); } else { DeltaMovement = FVector(0, 0, Falling); if (bChangeDirection) { if (bMoveDirection) { bMoveDirection = false; } else { bMoveDirection = true; } } bChangeDirection = false; } DeltaMovement = DeltaMovement * DeltaTime; AddActorWorldOffset(DeltaMovement); }
void AProjectile::ActivateProjectile(const FVector& location, const FRotator& rotator, ACharacter* initializer) { bIsActive = true; //set the projectile at the start position, and rotates to the aim rotation SetActorLocation(location); SetActorRotation(rotator); Instigator = initializer; SetActorHiddenInGame(false); InitializeProjectile(initializer); CollisionComp->Activate(true); MovementComp->Activate(true); }
// Called every frame void AMyDrone::Tick( float DeltaTime ) { Super::Tick(DeltaTime); FVector NewLocation; // we update position of the actor (with [m] to [cm] transform!) float x = 100 * curveX->Eval(RunningTime); float y = 100 * curveY->Eval(RunningTime); float z = 100 * curveZ->Eval(RunningTime); NewLocation.X = InitialLocation.X + x; NewLocation.Y = InitialLocation.Y + y; NewLocation.Z = InitialLocation.Z + z; SetActorLocation(NewLocation); // we update attitude of the actor // notice that the quaternion convention of UE is inverted! // in my favorite description: q = ( W -X -Y -Z ) float q0 = curveQ0->Eval(RunningTime); float q1 = curveQ1->Eval(RunningTime); float q2 = curveQ2->Eval(RunningTime); float q3 = curveQ3->Eval(RunningTime); NewRotation.W = q0; NewRotation.X = -q1; NewRotation.Y = -q2; NewRotation.Z = q3; //float theta = 3.14159 / 4; //NewRotation.W = FMath::Cos(theta/2); //NewRotation.X = -FMath::Sin(theta/2)*0; //NewRotation.Y = -FMath::Sin(theta/2)*FMath::Cos(theta / 2); //NewRotation.Z = -FMath::Sin(theta/2)*FMath::Sin(theta / 2); SetActorRotation(NewRotation); // update elevon poses float d1 = curveD1->Eval(RunningTime); float d2 = curveD2->Eval(RunningTime); Elevon1Rotation.Pitch = -d1; // sign is opposite to model standards Elevon2Rotation.Pitch = -d2; elevon1Mesh->SetRelativeRotation(Elevon1Rotation); elevon2Mesh->SetRelativeRotation(Elevon2Rotation); // here we update running time of actor RunningTime += DeltaTime; }
// Called every frame void AShip::Tick( float DeltaTime ) { Super::Tick( DeltaTime ); shootTimer += DeltaTime; if (direction != 0.0) { FVector newLocation = GetRootComponent()->GetComponentLocation(); newLocation.Y += DeltaTime * speed * direction; newLocation.Y = FMath::Min(FMath::Max(newLocation.Y, -500.0f), 500.0f); SetActorLocation(newLocation); } if (isShooting && shootTimer >= shootCooldown) { FVector location = GetRootComponent()->GetComponentLocation(); AActor *laser = GetWorld()->SpawnActor<ALaser>(location, FRotator(90, 0, 0)); shootSound->Play(); shootTimer = 0; } }
void ABrush::CopyPosRotScaleFrom( ABrush* Other ) { check(BrushComponent); check(Other); check(Other->BrushComponent); SetActorLocation(Other->GetActorLocation(), false); SetActorRotation(Other->GetActorRotation()); if( GetRootComponent() != NULL ) { SetPrePivot( Other->GetPrePivot() ); } if(Brush) { Brush->BuildBound(); } ReregisterAllComponents(); }
void APlayerOvi::AjustPosition() { FVector location = GetActorLocation(); if (location.X > m_limit) location.X = m_limit; else if (location.X < -m_limit) location.X = -m_limit; if (location.Y > m_limit) location.Y = m_limit; else if (location.Y < -m_limit) location.Y = -m_limit; if (location.Z > m_limit) location.Z = m_limit; else if (location.Z < -m_limit) location.Z = -m_limit; SetActorLocation(location); }