/// <summary> /// Return true if the given Pawn can step up onto this component. /// This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it. /// @param Pawn the Pawn that wants to step onto this component. /// @see CanCharacterStepUpOn /// </summary> public bool CanCharacterStepUp(APawn Pawn) { CheckIsValid(); int ___ret = CanCharacterStepUp(_this.Get(), Pawn); return(___ret != 0); }
/// <summary>Gets the owning actor of the Movement Base Component on which the pawn is standing.</summary> public static AActor GetMovementBaseActor(APawn Pawn) { IntPtr ___ret = GetMovementBaseActor(IntPtr.Zero, Pawn); if (___ret == IntPtr.Zero) { return(null); } AActor ___ret2 = new AActor() { _this = ___ret }; return(___ret2); }
/// <summary>Return the Pawn that is currently 'controlled' by this PlayerController</summary> public APawn K2_GetPawn() { CheckIsValid(); IntPtr ___ret = K2_GetPawn(_this.Get()); if (___ret == IntPtr.Zero) { return(null); } APawn ___ret2 = new APawn() { _this = ___ret }; return(___ret2); }
/// <summary> /// Gets the player pawn associated with this UI. /// @return Gets the owning player pawn that's owned by the player controller assigned to this widget. /// </summary> public APawn GetOwningPlayerPawn() { CheckIsValid(); IntPtr ___ret = GetOwningPlayerPawn(_this.Get()); if (___ret == IntPtr.Zero) { return(null); } APawn ___ret2 = new APawn() { _this = ___ret }; return(___ret2); }
/// <summary> /// called when sense's instance gets notified about new pawn that has just been spawned /// </summary> public void OnNewPawn(APawn newPawn) => E_UAISense_Blueprint_K2_OnNewPawn(this, newPawn);
/// <summary> /// Trigger a noise caused by a given Pawn, at a given location. /// Note that the NoiseInstigator Pawn MUST have a PawnNoiseEmitterComponent for the noise to be detected by a PawnSensingComponent. /// Senders of MakeNoise should have an Instigator if they are not pawns, or pass a NoiseInstigator. /// @param Loudness The relative loudness of this noise. Usual range is 0 (no noise) to 1 (full volume). If MaxRange is used, this scales the max range, otherwise it affects the hearing range specified by the sensor. /// @param NoiseInstigator Pawn responsible for this noise. Uses the actor's Instigator if NoiseInstigator=NULL /// @param NoiseLocation Position of noise source. If zero vector, use the actor's location. /// @param MaxRange Max range at which the sound may be heard. A value of 0 indicates no max range (though perception may have its own range). Loudness scales the range. (Note: not supported for legacy PawnSensingComponent, only for AIPerception) /// @param Tag Identifier for the noise. /// </summary> public extern void MakeNoise(float Loudness = 1.000000f, APawn NoiseInstigator = default(APawn), FVector NoiseLocation = default(FVector), float MaxRange = 0.000000f, FName Tag = default(FName));
/// <summary> /// gets called when perception system gets notified about new spawned pawn. /// <para>@Note: do not call super implementation. It's used to detect when subclasses don't override it </para> /// </summary> protected virtual void OnNewPawn(APawn newPawn) => E_UAISense_OnNewPawn(this, newPawn);
/// <summary> /// Alternative AI version of ReceiveTick function. /// <see cref="ReceiveTick"/> /// <para>@Note that if both generic and AI event versions are implemented only the more </para> /// suitable one will be called, meaning the AI version if called for AI, generic one otherwise /// </summary> protected void ReceiveTickAI(AAIController ownerController, APawn controlledPawn, float deltaSeconds) => E_UBTService_BlueprintBase_ReceiveTickAI(this, ownerController, controlledPawn, deltaSeconds);
/// <summary>Tell client to restart the level</summary> public extern virtual void ClientRestart(APawn NewPawn);
/// <summary> /// Handles attaching this controller to the specified pawn. /// Only runs on the network authority (where HasAuthority() returns true). /// @param InPawn The Pawn to be possessed. /// @see HasAuthority() /// </summary> public extern virtual void Possess(APawn InPawn);
public bool PerformAction(APawn pawn, UPawnAction action) => E_UPawnActionsComponent_PerformAction(this, pawn, action);
public void ActionStart(APawn controlledPawn) => E_UPawnAction_BlueprintBase_ActionStart(this, controlledPawn);
public void ActionTick(APawn controlledPawn, float deltaSeconds) => E_UPawnAction_BlueprintBase_ActionTick(this, controlledPawn, deltaSeconds);
public void ActionResume(APawn controlledPawn) => E_UPawnAction_BlueprintBase_ActionResume(this, controlledPawn);
/// <summary> /// Return true if the given Pawn can step up onto this component. /// This controls whether they can try to step up on it when they bump in to it, not whether they can walk on it after landing on it. /// @param Pawn the Pawn that wants to step onto this component. /// @see CanCharacterStepUpOn /// </summary> public extern virtual bool CanCharacterStepUp(APawn Pawn);
/// <summary> /// Initializes player pawn back to starting values, called from RestartPlayer /// </summary> public override void SetPlayerDefaults(APawn playerPawn) { }
/// <summary> /// <para>Notify of collision in case we want to react, such as waking up avoidance or pathing code. </para> /// </summary> public override void NotifyBumpedPawn(APawn BumpedPawn) { }
/// <summary> /// Notify of collision in case we want to react, such as waking up avoidance or pathing code. /// </summary> public virtual void NotifyBumpedPawn(APawn bumpedPawn) => E_UPawnMovementComponent_NotifyBumpedPawn(this, bumpedPawn);
/// <summary>Gets the owning actor of the Movement Base Component on which the pawn is standing.</summary> public extern static AActor GetMovementBaseActor(APawn Pawn);
/// <summary> /// Alternative AI version of ReceiveExecute /// <see cref="ReceiveExecute"/> /// <para>@Note that if both generic and AI event versions are implemented only the more </para> /// suitable one will be called, meaning the AI version if called for AI, generic one otherwise /// </summary> protected void ReceiveExecuteAI(AAIController ownerController, APawn controlledPawn) => E_UBTTask_BlueprintBase_ReceiveExecuteAI(this, ownerController, controlledPawn);
/// <summary> /// Use it to save component work to figure out what it's controlling /// <para>or if component can't/won't be able to figure it out properly </para> /// @NOTE will throw a log warning if trying to set ControlledPawn if it's already set /// </summary> public void SetControlledPawn(APawn newPawn) => E_UPawnActionsComponent_SetControlledPawn(this, newPawn);
/// <summary>acknowledge possession of pawn</summary> public extern virtual void ServerAcknowledgePossession(APawn P);
/// <summary> /// <para>Apply momentum caused by damage. </para> /// </summary> public override void ApplyDamageMomentum(float DamageTaken, FDamageEvent DamageEvent, APawn PawnInstigator, AActor DamageCauser) { }
/// <summary> /// Alternative AI version of ReceiveConditionCheck /// <see cref="ReceiveConditionCheck"/> /// <para>@Note that if both generic and AI event versions are implemented only the more </para> /// suitable one will be called, meaning the AI version if called for AI, generic one otherwise /// </summary> protected bool PerformConditionCheckAI(AAIController ownerController, APawn controlledPawn) => E_UBTDecorator_BlueprintBase_PerformConditionCheckAI(this, ownerController, controlledPawn);
/// <summary> /// Handles attaching this controller to the specified pawn. /// Only runs on the network authority (where HasAuthority() returns true). /// @param InPawn The Pawn to be possessed. /// @see HasAuthority() /// </summary> public void Possess(APawn InPawn) { CheckIsValid(); Possess(_this.Get(), InPawn); }
/// <summary> /// Alternative AI version of ReceiveExecutionStart /// <see cref="ReceiveExecutionStart"/> /// <para>@Note that if both generic and AI event versions are implemented only the more </para> /// suitable one will be called, meaning the AI version if called for AI, generic one otherwise /// </summary> protected void ReceiveExecutionStartAI(AAIController ownerController, APawn controlledPawn) => E_UBTDecorator_BlueprintBase_ReceiveExecutionStartAI(this, ownerController, controlledPawn);
/// <summary> /// Alternative AI version of ReceiveSearchStart function. /// <see cref="ReceiveSearchStart"/> /// <para>@Note that if both generic and AI event versions are implemented only the more </para> /// suitable one will be called, meaning the AI version if called for AI, generic one otherwise /// </summary> protected void ReceiveSearchStartAI(AAIController ownerController, APawn controlledPawn) => E_UBTService_BlueprintBase_ReceiveSearchStartAI(this, ownerController, controlledPawn);
/// <summary> /// Alternative AI version of ReceiveObserverDeactivated /// <see cref="ReceiveObserverDeactivated"/> /// <para>@Note that if both generic and AI event versions are implemented only the more </para> /// suitable one will be called, meaning the AI version if called for AI, generic one otherwise /// </summary> protected void ReceiveObserverDeactivatedAI(AAIController ownerController, APawn controlledPawn) => E_UBTDecorator_BlueprintBase_ReceiveObserverDeactivatedAI(this, ownerController, controlledPawn);
/// <summary> /// Alternative AI version of ReceiveDeactivation function. /// <see cref="ReceiveDeactivation"/> /// <para>@Note that if both generic and AI event versions are implemented only the more </para> /// suitable one will be called, meaning the AI version if called for AI, generic one otherwise /// </summary> protected void ReceiveDeactivationAI(AAIController ownerController, APawn controlledPawn) => E_UBTService_BlueprintBase_ReceiveDeactivationAI(this, ownerController, controlledPawn);
/// <summary> /// Asks perception system to supply Requestor with PredictedActor's predicted location in PredictionTime seconds /// <para>Location is being predicted based on PredicterActor's current location and velocity </para> /// </summary> public void RequestPawnPredictionEvent(APawn requestor, AActor predictedActor, float predictionTime) => E_UAISense_Prediction_RequestPawnPredictionEvent(this, requestor, predictedActor, predictionTime);