Class TCastleLiving

Description

Hierarchy

Constants

Methods

Properties

Unit

CastleLivingBehaviors

Declaration

type TCastleLiving = class(TCastleBehavior)

Description

Represents a living (dead or alive at given point) creature. Tracks Life points which determine being Alive or Dead for game purposes. It is also a basis for creatures to be aware of each other.

E.g. we can remember the last Attacker. This may be used by some other logic (not implemented by this behavior) to either run away from the last attacker (e.g. when health low) or run toward it (to retaliate).

This behavior is suitable both for player characters (controlled by humans) and for creatures / NPCs / bots (controller by code). For the latter (creatures / NPCs / bots) consider adding another behavior that implements actual AI, like TCastleMoveAttack or your own logic (see "3D FPS Game" for a simple example). See https://castle-engine.io/behaviors about using and implementing behaviors.

Note that using this class in your own games is completely optional. You can implement "has hit points" functionality yourself trivially, and then make your own decisions about various details (e.g. is life a float, or integer? does life equal "precisely zero" means being still alive, or dead?). This class is just a convenience, we made some decisions trying to address a wide range of games.

Source: scene/castlelivingbehaviors_living.inc (line 45).

Hierarchy

TObject
TPersistent
TComponent
TCastleComponent
TCastleBehavior
TCastleLiving

Show Additional Members: Inherited Protected

Overview

Constants

Public DefaultLife = 100.0;

Methods

Protected	`function GetInternalText: String; virtual;`
Protected	`procedure SetInternalText(const Value: String); virtual;`
Protected	`procedure SetName(const Value: TComponentName); override;`
Protected	`procedure TranslateProperties(const TranslatePropertyEvent: TTranslatePropertyEvent); virtual;`
Public	`destructor Destroy; override;`
Public	`procedure CustomSerialization(const SerializationProcess: TSerializationProcess); virtual;`
Public	`procedure SetTransient;`
Public	`procedure AddNonVisualComponent(const NonVisualComponent: TComponent);`
Public	`procedure InsertNonVisualComponent(const Index: Integer; const NonVisualComponent: TComponent);`
Public	`procedure RemoveNonVisualComponent(const NonVisualComponent: TComponent);`
Public	`function NonVisualComponentsIndexOf(const NonVisualComponent: TComponent): Integer;`
Public	`function NonVisualComponentsCount: Integer;`
Public	`function NonVisualComponentsEnumerate: TNonVisualComponentsEnumerator;`
Public	`function ValueIsStreamed: Boolean; virtual;`
Public	`procedure DesignerInfo(const SList: TStrings); virtual;`
Public	`procedure DesignerWarnings(const SList: TStrings); virtual;`
Protected	`procedure Update(const SecondsPassed: Single; var RemoveMe: TRemoveType); virtual;`
Protected	`procedure BeforeRender( const CameraView: TViewVectors; const ParentParentWorldTransformation: TTransformation); virtual;`
Protected	`procedure ParentChanged; virtual; deprecated 'Use ParentAfterAttach / ParentBeforeDetach or WorldAfterAttach / WorldBeforeDetach';`
Protected	`procedure ParentAfterAttach; virtual;`
Protected	`procedure ParentBeforeDetach; virtual;`
Protected	`procedure WorldAfterAttach; virtual;`
Protected	`procedure WorldBeforeDetach; virtual;`
Public	`procedure BeforeDestruction; override;`
Public	`function World: TCastleAbstractRootTransform;`
Protected	`function CanAttachToParent(const NewParent: TCastleTransform; out ReasonWhyCannot: String): Boolean; override;`
Public	`constructor Create(AOwner: TComponent); override;`
Public	`function PropertySections(const PropertyName: String): TPropertySections; override;`
Public	`function Alive: Boolean;`
Public	`function Dead: Boolean;`
Public	`procedure Hurt(const LifeLoss: Single; const AHurtDirection: TVector3; const AHurtStrength: Single = 0; const AnAttacker: TCastleLiving = nil); virtual;`

Properties

Public	`property NonVisualComponents [const Index: Integer]: TComponent read GetNonVisualComponents;`
Public	`property IsLoading: Boolean read FIsLoading;`
Public	`property Parent: TCastleTransform read FParent;`
Public	`property ListenWorldChange: Boolean read FListenWorldChange write SetListenWorldChange;`
Public	`property HurtDirection: TVector3 read FHurtDirection;`
Public	`property HurtStrength: Single read FHurtStrength;`
Public	`property Attacker: TCastleLiving read FAttacker write SetAttacker;`
Published	`property Life: Single read FLife write FLife default DefaultLife;`
Published	`property MaxLife: Single read FMaxLife write FMaxLife default DefaultLife;`
Published	`property OnHurt: TNotifyEvent read FOnHurt write FOnHurt;`

Description

Constants

Public DefaultLife = 100.0;

Default value for MaxLife and Life.

Source: scene/castlelivingbehaviors_living.inc (line 62).

Methods

Protected function GetInternalText: String; virtual;

This item is declared in ancestor TCastleComponent.

This item has no description.

Source: base/castleclassutils.pas (line 575).

Protected procedure SetInternalText(const Value: String); virtual;

This item is declared in ancestor TCastleComponent.

This item has no description.

Source: base/castleclassutils.pas (line 576).

Protected procedure SetName(const Value: TComponentName); override;

This item is declared in ancestor TCastleComponent.

This item has no description.

Source: base/castleclassutils.pas (line 577).

Protected procedure TranslateProperties(const TranslatePropertyEvent: TTranslatePropertyEvent); virtual;

This item is declared in ancestor TCastleComponent.

Enumerate all properties that are possible to translate in this component. E.g. in TCastleLabel it will return TCastleLabel.Caption, in TCastleEdit it will return TCastleEdit.Text and TCastleEdit.Placeholder.

Returns only non-empty properties, thus assuming that if current (by convention, English) text is empty, then there is no point in translating it. Moreover descendants may define boolean properties to exclude particular text from translating, e.g. TCastleLabel.CaptionTranslate, TCastleEdit.TextTranslate, TCastleEdit.PlaceholderTranslate.

It is not recursive (it doesn't enumerate children properties). Use global TranslateProperties procedure to call this on a hierarchy of TComponent.

You usually don't want to call this method (it is called by other engine routines). But you may find it useful to override this, if you define new component.

Source: base/castleclassutils.pas (line 598).

Public destructor Destroy; override;

This item is declared in ancestor TCastleComponent.

This item has no description.

Source: base/castleclassutils.pas (line 604).

Public procedure CustomSerialization(const SerializationProcess: TSerializationProcess); virtual;

This item is declared in ancestor TCastleComponent.

Override this method to call various methods of SerializationProcess, which in turn allows to serialize/deserialize things that are not published. This allows to serialize/deserialize with more freedom, e.g. to serialize/deserialize some private field.

Source: base/castleclassutils.pas (line 610).

Public procedure SetTransient;

This item is declared in ancestor TCastleComponent.

Ignore this component when serializing parent's TCastleUserInterface.Controls list or TCastleTransform.List, and do not show this component in CGE editor. This simply sets csTransient flag in ComponentStyle.

This is useful for children that are automatically managed by the parent, and should not be modified by user code. For example, TCastleCheckbox is internally composed from TCastleImageControl and TCastleLabel children, but we don't want to serialize or even show these children to user.

Note that if you want to prevent this component from serializing as part of TCastleUserInterface.Controls list or TCastleTransform.List, but you still want it to be visible in CGE editor, then make it a "subcomponent" instead, by SetSubComponent(true).

Note that both csSubComponent and csTransient only disable the component serialization as part of parent's lists enumerated by CustomSerialization (see internal TCastleUserInterface.SerializeChildrenEnumerate , TCastleTransform.SerializeChildrenEnumerate, TCastleTransform.SerializeBehaviorsEnumerate).

If you will make the component published in its own property (which is normal for "subcomponents") then it will be serialized anyway, just as part of it's own property (like TCastleScrollView.ScrollArea). So to really avoid serializing a children component make it csSubComponent and/or csTransient, and do not publish it.

Source: base/castleclassutils.pas (line 663).

Public procedure AddNonVisualComponent(const NonVisualComponent: TComponent);

This item is declared in ancestor TCastleComponent.

Add non-visual component to this component. This is used to organize non-visual components in a tree hierarchy, in CGE designs and editor.

Parameters

RemoveMe: Set this to rtRemove or rtRemoveAndFree to remove this component from Parent after this call finished. rtRemoveAndFree additionally will free this item. Initially it's rtNone when this method is called.

Source: transform/castletransform_behavior.inc (line 52).

Protected procedure BeforeRender( const CameraView: TViewVectors; const ParentParentWorldTransformation: TTransformation); virtual;

This item is declared in ancestor TCastleBehavior.

Event called right before rendering the parent TCastleTransform. Override this if you have to adjust the parent transformation strictly before the rendering.

Compared to adjusting the parent transformation in e.g. Update, adjusting the parent transformation here has advantages:

There's no 1-frame delay between moving the thing that causes the change (like camera) and updating the thing that reacts to it (like a transformation with a billboard).
We adjust transformation before rendering each occurrence of TCastleTransform in the viewport tree. This matters if given TCastleTransform may occur multiple times in the viewport tree, directly or through TCastleTransformReference.
We adjust transformation before each render, so things are OK if given TCastleTransform is present in multiple viewports (see https://castle-engine.io/multiple_viewports_to_display_one_world).

For example, adjusting the TCastleTransform done by the TCastleBillboard is done using this method. The transformation in this case is determined by the camera and parent's parent transformation. The transformation has to be applied without any delay (even a 1-frame delay would be visible, as artifacts caused by billboard not perfectly aligned with the camera would be visible – blending sort along camera direction in sort3D is not perfect if billboard doesn't exactly match camera direction). And the transformation with billboard may be present in multiple viewports and/or multiple times in the same viewport tree.

Parameters

CameraView: Current camera vectors, in world coordinates, used to render the scene now.
ParentParentWorldTransformation: World transformation of the parent of the parent of this behavior. The name is kind of convoluted, but consistent: When the parent of this behavior has exactly one parent TCastleTransform (not zero, not more) then ParentParentWorldTransformation.Transform is equivalent to Parent.Parent.WorldTransform.

Source: transform/castletransform_behavior.inc (line 103).

Protected procedure ParentChanged; virtual; deprecated 'Use ParentAfterAttach / ParentBeforeDetach or WorldAfterAttach / WorldBeforeDetach';

This item is declared in ancestor TCastleBehavior.

Warning: this symbol is deprecated: Use ParentAfterAttach / ParentBeforeDetach or WorldAfterAttach / WorldBeforeDetach

Called after Parent changed, at the end of TCastleTransform.AddBehavior, TCastleTransform.RemoveBehavior.

Source: transform/castletransform_behavior.inc (line 109).

Protected procedure ParentAfterAttach; virtual;

This item is declared in ancestor TCastleBehavior.

Called after Parent changed, e.g. at the end of TCastleTransform.AddBehavior.

Source: transform/castletransform_behavior.inc (line 113).

Protected procedure ParentBeforeDetach; virtual;

This item is declared in ancestor TCastleBehavior.

Called before Parent changed, e.g. at the beginning of TCastleTransform.RemoveBehavior.

This is also called at the destruction of behavior (more precisely from BeforeDestruction now). Even in this case, we guarantee that Parent is still valid during this call, and not in half-destroyed state. Before the actual destructor of TCastleBehavior we do BeforeParentDetach and BeforeWorldDetach and set Parent to Nil.

Source: transform/castletransform_behavior.inc (line 122).

Protected procedure WorldAfterAttach; virtual;

This item is declared in ancestor TCastleBehavior.

Called after Parent became part of World. Called only if ListenWorldChange is True.

Source: transform/castletransform_behavior.inc (line 126).

Protected procedure WorldBeforeDetach; virtual;

This item is declared in ancestor TCastleBehavior.

Called before Parent stops being part of World. Called only if ListenWorldChange is True.

Source: transform/castletransform_behavior.inc (line 136).

Public procedure BeforeDestruction; override;

This item is declared in ancestor TCastleBehavior.

This item has no description.

Source: transform/castletransform_behavior.inc (line 161).

Public function World: TCastleAbstractRootTransform;

This item is declared in ancestor TCastleBehavior.

Reference to the root transformation (typically matching the TCastleViewport.Items value) corresponding to the parent of this behavior.

May be Nil if the behavior is not yet added to the parent TCastleTransform, or when the TCastleTransform is not yet part of the TCastleAbstractRootTransform (which means that TCastleTransform is not added to the viewport yet). You can use ListenWorldChange and override WorldBeforeDetach, WorldAfterAttach to be notified when this changes.

Source: transform/castletransform_behavior.inc (line 184).

Protected function CanAttachToParent(const NewParent: TCastleTransform; out ReasonWhyCannot: String): Boolean; override;

This item has no description. Showing description inherited from TCastleBehavior.CanAttachToParent.

Check can this behavior be added to NewParent. When this returns False, it has to set also ReasonWhyCannot. When overriding this, you can use e.g. this code to make sure we are the only behavior of given class:

function TCastleBillboard.CanAttachToParent(const NewParent: TCastleTransform;
  out ReasonWhyCannot: String): Boolean;
begin
  Result := inherited;
  if not Result then Exit;

  if NewParent.FindBehavior(TCastleBillboard) <> nil then
  begin
    ReasonWhyCannot := 'Only one TCastleBillboard behavior can be added to a given TCastleTransform';
    Result := false;
  end;
end;

Source: scene/castlelivingbehaviors_living.inc (line 57).

Public constructor Create(AOwner: TComponent); override;

This item has no description.

Source: scene/castlelivingbehaviors_living.inc (line 64).

Public function PropertySections(const PropertyName: String): TPropertySections; override;

This item has no description. Showing description inherited from TCastleComponent.PropertySections.

Section where to show property in the editor.

Source: scene/castlelivingbehaviors_living.inc (line 65).

Public function Alive: Boolean;

Shortcut for checking Life > 0. Always equal to not Dead.

Source: scene/castlelivingbehaviors_living.inc (line 68).

Public function Dead: Boolean;

Shortcut for checking Life <= 0. Always equal to not Alive.

Source: scene/castlelivingbehaviors_living.inc (line 70).

Public procedure Hurt(const LifeLoss: Single; const AHurtDirection: TVector3; const AHurtStrength: Single = 0; const AnAttacker: TCastleLiving = nil); virtual;

Hurt given creature, decreasing its Life by LifeLoss, also setting some additional properties that describe the damage. These additional properties do not do anything in this class – but they may be useful by other effects, e.g. "knockback", done by other behaviors.

Note: If all you want to do is to decrease Life, you can also just set Life property directly, like MyCreature.Life := MyCreature.Life - 10;.

)

Parameters

AHurtDirection: Should be a normalized vector indicating direction from which the attack came, in world coordinates.
In this class, it does nothing, merely sets HurtDirection property. Which may be used by other effects.
AHurtStrength: Describes "strength" of the attack. What this "strengh" exactly means is not defined in this class. It may cause a "knockback" effect, in which case it may be a knockback distance, or a physical force strength, and is meaningful only when AHurtDirection parameter is non-zero.
In this class, it does nothing, merely sets HurtStrength property. Which may be used by other effects.
AnAttacker: The other living creature that caused this damage. It may be Nil if no other TCastleLiving is directly responsible for this damage. This may be useful for various purposes, for example the victim may become aware of attacker presence when it's attacked.
In this class, it does nothing, merely sets Attacker property. Which may be used by other effects.

Source: scene/castlelivingbehaviors_living.inc (line 106).

Properties

Public property NonVisualComponents [const Index: Integer]: TComponent read GetNonVisualComponents;

This item is declared in ancestor TCastleComponent.

Components added by AddNonVisualComponent.

Source: base/castleclassutils.pas (line 698).

Public property IsLoading: Boolean read FIsLoading;

This item is declared in ancestor TCastleComponent.

Is the component during deserialization now.

Note: We can't use csLoading in ComponentState because in Delphi it is not possible to control it from CastleComponentSerialize.

Source: base/castleclassutils.pas (line 711).

Public property Parent: TCastleTransform read FParent;

This item is declared in ancestor TCastleBehavior.

Parent TCastleTransform of this behavior. Change it by doing TCastleTransform.AddBehavior, TCastleTransform.RemoveBehavior.

Nil if this behavior is not yet added to a parent.

Source: transform/castletransform_behavior.inc (line 191).

Public property ListenWorldChange: Boolean read FListenWorldChange write SetListenWorldChange;

This item is declared in ancestor TCastleBehavior.

Set this to True to receive WorldBeforeDetach, WorldAfterAttach calls.

Source: transform/castletransform_behavior.inc (line 194).

Public property HurtDirection: TVector3 read FHurtDirection;

Direction from where the last attack came, set by Hurt, in world coordinates. Zero if there was no specific direction of last attack, otherwise a normalized (length 1) vector.

Source: scene/castlelivingbehaviors_living.inc (line 115).

Public property HurtStrength: Single read FHurtStrength;

Strengh of the last attack, set by Hurt. What this "strengh" exactly means is not defined in this class. It may cause a "knockback" effect, in which case it may be a knockback distance, or a physical force strength, and is meaningful only when HurtDirection is non-zero.

Source: scene/castlelivingbehaviors_living.inc (line 122).

Public property Attacker: TCastleLiving read FAttacker write SetAttacker;

Last attacker. Set by the last Hurt call, it may also be set directly.

Source: scene/castlelivingbehaviors_living.inc (line 126).

Published property Life: Single read FLife write FLife default DefaultLife;

Current Life (hit points). The object is considered "dead" when this is <= 0.

Expressed as float, allows to represent fractional life, allows to animate life (e.g. increasing life by some "SecondsPassed * RegenerationRate" each frame, or decreasing by "SeconsPassed * PoisonSpeed").

Source: scene/castlelivingbehaviors_living.inc (line 134).

Published property MaxLife: Single read FMaxLife write FMaxLife default DefaultLife;

Maximum amount of life. Can be also used for information (to display on player HUDs and such).

This is not a strict limit on Life, i.e. all the code allows the have Life > MaxLife to account for special game mechanisms, like "magic life boost to make health temporarily larger than normal". It is up to your game logic whether such situation will actually happen.

Source: scene/castlelivingbehaviors_living.inc (line 144).

Published property OnHurt: TNotifyEvent read FOnHurt write FOnHurt;

Event called right after creature is hurt and properties like HurtDirection, HurtStrength and Attacker are set.

Source: scene/castlelivingbehaviors_living.inc (line 148).

Generated by PasDoc 0.17.0.snapshot.

Castle Game Engine

API Reference

Class TCastleLiving

Unit

Declaration

Description

Hierarchy

Overview

Constants

Methods

Properties

Description

Constants

Methods

See also

See also

See also

See also

Parameters

Parameters

Parameters

Properties