FPS-3D-CONCEPT

Bienvenu a tous sur ce forum

Besoin d'aide pour la creation de FPS ? Ce forum est fait pour vous.

Like/Tweet/+1

Derniers sujets

Partenaires


créer un forum

      

Ceux qui commencent le plus de sujets

Sondage

Shopactif



Liste des propriètés des actors

Partagez
avatar
JPM_FR
Admin

Sexe : Masculin
Zodiaque : Bélier
Signe Chinois : Tigre
Messages : 77
Date de naissance : 28/03/1962
Date d'inscription : 06/01/2010
Age : 55
Localisation : France
Emploi/loisirs : Décorateur

Liste des propriètés des actors

Message par JPM_FR le Lun 5 Avr - 15:55

Liste des propriètés des actors




Les variables (Editable dans l'Unreal-Ed) :


Advanced :
bConsiderAllStaticMeshComponentsForStreaming : If true, texture streaming code iterates over all StaticMeshComponents found on this actor when building texture streaming information.
bEdShouldSnap : L'actor s'aligne sur la grille dans l'Unreal-Ed.
bHiddenEd : L'actor n'est pas visible pendant dans l'Unreal-Ed.
bHiddenEdGroup : L'actor est cacher par le Group Brower.
bLockLocation : L'actor ne peut etre déplacer dans l'Unreal-Ed.

Attachment :
Base : Déplace l'actor de façon relative a l'actor entrer.
BaseBoneName : Déplace l'actor de façon relative a un bone du BaseSkelComponent.
BaseSkelComponent : Permet d'assigner divers SkeletalMesh a l'actor.
bHardAttach : Ne marche que si bBlockActor est sur False. L'actor ne peut etre déplacer par rapport a sa base (setlocation etc.). Lorsqu'il est baser sur un actor(Base).
bIgnoreBaseRotation : L'actor ignore les changements de rotation de l'actor sur lequel il est basé.
bShadowParented : BaseSkelComponent est l'ombre de l'actor.

Collision :
bCollideComplex : Ignore les collisions simplifier des StaticMeshes. Les collisions sont pour chaque polygones.
BlockRigidBody : mirrored copy of CollisionComponent's BlockRigidBody for the Actor property window for LDs (so it's next to CollisionType) purely for editing convenience and not used at all by the physics code
bNoEncroachCheck : Les collisions entre cet actor et d'autres ne seront pas calculer. Ce qui comprend aussi le déclenchement des triggers (touch). A utiliser dans une map comportant un grand nombre d'actor aevc des PHYS_RigidBody par exemple.
bPathColliding : Si bWorldGeometry et bBlockActors sont a true et que bStatic est a false, cette actor ne bloquera pas la création d'un chemin pour les bots (calculer lors du BuildPaths ou BuilAll). Cette variable est utile pour les movers et les actors qui se déplace (Porte).
CollisionComponent : ???
CollisionType : enum for LDs to select collision options - sets Actor flags and that of our CollisionComponent via PostEditChange()

Debug :
bDebug : Used to toggle debug logging

Display :
bHidden : L'actor n'est pas visible pendant le jeu.
DrawScale : Permet de modifier la taille de l'actor.
DrawScale3D : Permet de modifier la taille de l'actor celon différents angle (X, Y, Z).
PrePivot : Décale l'actor par rapport a son centre (point de pivot).

Movement :

DesiredRotation : Oriente doucement l'actor vers l'angle indiquer.
Location : Le positionement de l'actor dans la map.
Physics : Le mode de déplacement Physics actuel

<TABLE border=0 cellSpacing=1 cellPadding=3 width="95%" align=center>


<TR>
<td>CODE </TD></TR>
<TR>
<td id=CODE>PHYS_None, // Aucun déplacement
PHYS_Walking, // Marche
PHYS_Falling,
PHYS_Swimming, //Nage
PHYS_Flying, //Vol
PHYS_Rotating, // Tourne
PHYS_Projectile,
PHYS_Interpolating,
PHYS_Spider,
PHYS_Ladder,
PHYS_RigidBody,
PHYS_SoftBody, /** update bounding boxes and killzone test, otherwise like PHYS_None */
PHYS_Unused </TD></TR></TABLE>Rotation : Rotation de l'actor en degres.
RotationRate : Modification de la rotation par secondes (rotation en degres)

Object :
Group : Le groupe auquel l'actor appartient (Group Brower).
Name : Le nom de l'actor dans la map (non modifiable)
ObjectArchetype : La hiérachie de l'actor (Sa location(Package > Group > Name), son type (StaticMesh, Actor, ...)
Tag : Le tag de l'actor. Peut servir a beaucoup de choses, comme par exemple si l'actor est un mover, il peut-etre relié a un trigger qui le déclenchera grace a son Tag qui sera le nom de l'Event du trigger.

Physics :

MinDistForNetRBCorrection : Si l'erreur de positionnement est plus petit que cela, elle ne sera pas corriger par un mise a jour via le serveur.
Les fonctions (Unreal Script) :


Les Fonctions appelées par le Moteur :

Fonction générale:


<TABLE border=0 cellSpacing=1 cellPadding=3 width="95%" align=center>


<TR>
<td>Uscript </TD></TR>
<TR>
<td id=CODEU>//=========================================================================
// Engine notification functions.

//
// Major notifications.
//
event Destroyed();
event GainedChild( Actor Other );
event LostChild( Actor Other );
event Tick( float DeltaTime );

//
// Physics & world interaction.
//
event Timer();
event HitWall( vector HitNormal, actor Wall, PrimitiveComponent WallComp);
event Falling();
event Landed( vector HitNormal, actor FloorActor );
event PhysicsVolumeChange( PhysicsVolume NewVolume );
event Touch( Actor Other, PrimitiveComponent OtherComp, vector HitLocation, vector HitNormal );
event PostTouch( Actor Other ); // called for PendingTouch actor after physics completes
event UnTouch( Actor Other );
event Bump( Actor Other, PrimitiveComponent OtherComp, vector HitNormal );
event BaseChange();
event Attach( Actor Other );
event Detach( Actor Other );
event Actor SpecialHandling(Pawn Other);
/**
* Called when collision values change for this actor (via SetCollision/SetCollisionSize).
*/
event CollisionChanged();
/** called when this Actor is encroaching on Other and we couldn't find an appropriate place to push Other to
* @return true to abort the move, false to allow it
* @warning do not abort moves of PHYS_RigidBody actors as that will cause the Unreal location and physics engine location to mismatch
*/
event bool EncroachingOn(Actor Other);
event EncroachedBy( actor Other );
event RanInto( Actor Other ); // called for encroaching actors which successfully moved the other actor out of the way

/** Clamps out_Rot between the upper and lower limits offset from the base */
simulated final native function bool ClampRotation( out rotator out_rot, rotator rBase, rotator rUpperLimits, rotator rLowerLimits );
/** Called by ClampRotation if the rotator was outside of the limits */
simulated event bool OverRotated( out rotator out_Desired, out rotator out_Actual );

/**
* Called when being activated by the specified pawn. Default
* implementation searches for any SeqEvent_Used and activates
* them.
*
* @return true to indicate this actor was activated
*/
function bool UsedBy(Pawn User)
{
return TriggerEventClass(class'SeqEvent_Used', User, -1);
}

/** called when the actor falls out of the world 'safely' (below KillZ and such) */
simulated event FellOutOfWorld(class dmgType)
{
SetPhysics(PHYS_none);
SetHidden(true);
SetCollision(false,false);
Destroy();
}

/** called when the Actor is outside the hard limit on world bounds
* @note physics and collision are automatically turned off after calling this function
*/
simulated event OutsideWorldBounds()
{
Destroy();
}

/**
* Trace a line and see what it collides with first.
* Takes this actor's collision properties into account.
* Returns first hit actor, Level if hit level, or None if hit nothing.
*/
native(277) noexport final function Actor Trace
(
out vector HitLocation,
out vector HitNormal,
vector TraceEnd,
optional vector TraceStart,
optional bool bTraceActors,
optional vector Extent,
optional out TraceHitInfo HitInfo,
optional int ExtraTraceFlags
);

/**
* Run a line check against just this PrimitiveComponent. Return TRUE if we hit.
* NOTE: the actual Actor we call this on is irrelevant!
*/
native noexport final function bool TraceComponent
(
out vector HitLocation,
out vector HitNormal,
PrimitiveComponent InComponent,
vector TraceEnd,
optional vector TraceStart,
optional vector Extent,
optional out TraceHitInfo HitInfo
);

/**
* Run a point check against just this PrimitiveComponent. Return TRUE if we hit.
* NOTE: the actual Actor we call this on is irrelevant!
*/
native noexport final function bool PointCheckComponent
(
PrimitiveComponent InComponent,
vector PointLocation,
vector PointExtent
);

// returns true if did not hit world geometry
native(548) noexport final function bool FastTrace
(
vector TraceEnd,
optional vector TraceStart,
optional vector BoxExtent,
optional bool bTraceBullet
);

/*
* Tries to position a box to avoid overlapping world geometry.
* If no overlap, the box is placed at SpotLocation, otherwise the position is adjusted
* @Parameter BoxExtent is the collision extent (X and Y=CollisionRadius, Z=CollisionHeight)
* @Parameter SpotLocation is the position where the box should be placed. Contains the adjusted location if it is adjusted.
* @Return true if successful in finding a valid non-world geometry overlapping location
*/
native final function bool FindSpot(vector BoxExtent, out vector SpotLocation);

native final function bool ContainsPoint(vector Spot);
native noexport final function bool IsOverlapping(Actor A);
native final function GetComponentsBoundingBox(out box ActorBox) const;
native function GetBoundingCylinder(out float CollisionRadius, out float CollisionHeight) const;

/** Spawn an actor. Returns an actor of the specified class, not
* of class Actor (this is hardcoded in the compiler). Returns None
* if the actor could not be spawned (if that happens, there will be a log warning indicating why)
* Defaults to spawning at the spawner's location.
*
* @note: ActorTemplate is sent for replicated actors and therefore its properties will also be applied
* at initial creation on the client. However, because of this, ActorTemplate must be a static resource
* (an actor archetype, default object, or a bStatic/bNoDelete actor in a level package)
* or the spawned Actor cannot be replicated
*/
native noexport final function coerce actor Spawn
(
class SpawnClass,
optional actor SpawnOwner,
optional name SpawnTag,
optional vector SpawnLocation,
optional rotator SpawnRotation,
optional Actor ActorTemplate,
optional bool bNoCollisionFail
);

//
// Destroy this actor. Returns true if destroyed, false if indestructible.
// Destruction is latent. It occurs at the end of the tick.
//
native(279) final noexport function bool Destroy();

// Networking - called on client when actor is torn off (bTearOff==true)
event TornOff(); </TD></TR></TABLE>

  • event Destroyed();
    Appeléer lors de la destruction de l'actor.
  • event GainedChild( Actor Other );
    Appelée lorsque cet acteur devient le propriétaire du autre.
  • event LostChild( Actor Other );
    Appelée lorsque cet acteur n'est plus le propriétaire d'un autre (y compris lors de Destroyed() [Vous devez être inscrit et connecté pour voir cette image] .
  • event Tick( float DeltaTime );
    Appelée a chaque frame, DeltaTime est le temps passer depuis la derniere frame.
  • event HitWall( vector HitNormal, actor Wall, PrimitiveComponent WallComp);
    Appelée lorsque l'acteur touche un mur. Utiliser seulement pour les projectiles et appeler en meme temps que touch() si l'actor toucher a BlockAll a true.
  • event Falling();
    Appelée quand l'actor (Pawn) tombe.
  • event Landed( vector HitNormal, actor FloorActor );
    Appelée quand l'actor touch le sol.
  • event PhysicsVolumeChange( PhysicsVolume NewVolume );
    Appelée lorsque l'actor change de PhysicsVolume ou entre dedans.
  • event Touch( Actor Other, PrimitiveComponent OtherComp, vector HitLocation, vector HitNormal );
    Appelée lorsqu'un autre actor touche cette actor.
  • event UnTouch( Actor Other );
    Appelée lorsqu'un autre actor ne touche plus cette actor.
  • event Bump( Actor Other, PrimitiveComponent OtherComp, Vector HitNormal );
    Appelée lorsqu'un autre actor touche cette actor et est bloquer (entre en collision).
  • event BaseChange();
    Appelée lorsque la Base change;
  • event CollisionChanged();
    Appelée lorsque les proprietés des collisions changes(via SetCollision/SetCollisionSize).
  • event bool EncroachingOn(Actor Other);
  • event EncroachedBy( actor Other );
  • event RanInto( Actor Other );
    // called for encroaching actors which successfully moved the other actor out of the way
  • event bool OverRotated( out Rotator out_Desired, out Rotator out_Actual );
  • UsedBy(Pawn User);
    Appelée lors qu'un Pawn appuis sur utiliser lorsque qu'il touch cette actor
  • event Timer();
    Fonction déclancher par SetTimer apres un nombre de secondes indiquers dans le SetTimer() (Voir les fontions de temps);
Functions de début de partie :

  • event PreBeginPlay()
    Appelée juste avant le Gameplay.
  • event PostBeginPlay();
    Appelée juste apres le Gameplay.

Fonctions de dégats :


  • event TakeDamage(int DamageAmount, Controller EventInstigator, vector HitLocation, vector Momentum, class DamageType, optional TraceHitInfo HitInfo, optional Actor DamageCauser);
    Lorsque l'actor prends des dammages.
  • HealDamage(int Amount, Controller Healer, class DamageType);
    L'inverse de TakeDamage, lorsqu'e l'actor récupere de la vie.

Functions de temps:

NB : Dans l'Unreal Engine 3.0, une meme class peut utiliser plusieur timer simultanément. Ce grâce au nom spécifié dans le SetTimer();

  • SetTimer(float inRate, optional bool inbLoop, optional Name inTimerFunc='Timer', optional Object inObj);
    Lance la fonction Timer() apres inRate Secondes, inbLoop défini si la fonction Timer tournera en boucle.
  • ClearTimer(optional Name inTimerFunc='Timer', optional Object inObj);
    Arrete la fonction timer de la class.
  • bool IsTimerActive(optional Name inTimerFunc='Timer', optional Object inObj);
    Indique si la fonction timer() est lancé.
  • float GetTimerCount(optional Name inTimerFunc='Timer', optional Object inObj);
    Permet de récupérer l'intervale de temps entre l'execution de la fonction timer(); (Pas sur)
  • float GetTimerRate(optional name TimerFuncName = 'Timer', optional Object inObj);
    Permet de récupérer le temps avant la porchaine execution de la fonction timer(); (Pas sur)
Fontions courantes :
    Divers :
  • native noexport final function coerce actor Spawn(class SpawnClass, optional actor SpawnOwner, optional name SpawnTag, optional vector SpawnLocation, optional rotator SpawnRotation, optional Actor ActorTemplate, optional bool bNoCollisionFail);
    Fait apparaitre un actor
Latent function :

  • latent function Sleep( float Seconds );
  • latent function FinishAnim( AnimNodeSequence SeqNode );
Display function :

  • SetCollision( optional bool bNewColActors, optional bool bNewBlockActors, optional bool bNewIgnoreEncroachers );
    Modifie les collisions.
  • SetCollisionSize( float NewRadius, float NewHeight );
    Modifie la taille des collisions.
  • SetDrawScale(float NewScale);
    Modifie la taille de l'actor.
  • SetDrawScale3D(vector NewScale3D);
    Modifie la taille de l'actor de façon non uniforme selon les 3 axes (X,Y,Z).
  • bool SetLocation( vector NewLocation );
    Modifie la Location de l'actor d'apres un vector (vect(X,Y,Z))
  • bool SetRotation( rotator NewRotation );
    Modifie la Rotation de l'actor d'apres un rotator (rot(Pitch,Yaw,Roll))






JPM_FR



    La date/heure actuelle est Mar 19 Sep - 18:27