Unity3D Troisième Personne du Contrôleur et des Animations

Mon problème est que une coutume à pied de l'animation, j'ai mis à la troisième personne du contrôleur de Unity3D est pas montré.

L'animation est importé à partir d'un fichier FBX avec l'[email protected] structure. Je sais que l'animation fonctionne, parce que si je l'utilise comme l'inactivité d'animation qu'il montre. D'autre part, il ne semble pas être un problème avec le contrôleur de script, il fonctionne très bien avec le caractère de prototype.

Il semble que l'animation en cours de lecture est celui qui est sélectionné dans l'Animation composant (qui a " Jouer Automatiquement sélectionné). Toute tentative de modification de l'animation à partir de la troisième personne du contrôleur de travaux pour le caractère de prototype, mais pas pour le mien.

Je n'ai pas et ne veulent pas courir et sauter animations. Avec le caractère de prototype j'ai mis le pied d'animation sur chacun de ceux qui, sans les effets indésirables. Le contrôleur ne s'est pas éteint animation de cette manière, voyant qu'il n'y a pas d'entrées de journal dans la console à partir de la troisième personne du contrôleur de script. La ligne correspondante avec le Fondu enchaîné appel est appelé.

Des indices quant à l'endroit où je pouvais regarder la prochaine? Est-il plus probable d'un problème avec le contrôleur, ou de l'animation? Quelque chose de complètement différent?

Mise à jour: ci-Dessous le code de mon contrôleur. Il fonctionne très bien lorsque j'utilise l'exemple de modèle du travailleur de la construction qui est fourni avec l'Unité. Les lignes avec _animation.CrossFade sont appelé à la fois. À l'aide de Play ou Blend au lieu de cela n'aide pas. Il n'y a pas d'erreurs enregistrées dans la console.

Pour nos animations personnalisées toutefois, il ne fonctionne pas. Je suis maintenant se douter des problèmes réside dans le modèle. Malheureusement, je ne suis pas à la liberté de partager un échantillon de ce modèle. J'ai demandé à l'animateur pour plus de détails sur la façon dont il a créé l'exportation FBX. Existe-il des réglages spécifiques qu'il doit utiliser pour le modèle à travailler dans l'Unité? Il reste étrange que les animations ne fonctionnent si je les ajouter indepently à la scène.

//Require a character controller to be attached to the same game object
@script RequireComponent(CharacterController)
public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var walkMaxAnimationSpeed : float = 0.75;
private var _animation : Animation;
enum CharacterState {
Idle = 0,
Walking = 1,
}
private var _characterState : CharacterState;
//The speed when walking
var walkSpeed = 2.0;
var speedSmoothing = 10.0;
var rotateSpeed = 500.0;
var targetPrecision = 5;
var targetMaxDistance = 200;
//The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
private var lockCameraTimer = 0.0;
//The current move direction in x-z
private var moveDirection = Vector3.zero;
//The current x-z move speed
private var moveSpeed = 0.0;
//The last collision flags returned from controller.Move
private var collisionFlags : CollisionFlags; 
//Are we moving backwards (This locks the camera to not do a 180 degree spin)
private var movingBack = false;
//Is the user pressing any keys?
private var isMoving = false;
private var isControllable = true;
private var isTargetting : boolean = false;
private var targetPoint : Vector3 = Vector3.zero;
function Awake () {
moveDirection = transform.TransformDirection(Vector3.forward);
_animation = GetComponent(Animation);
if(!_animation)
Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");
if(!idleAnimation) {
_animation = null;
Debug.Log("No idle animation found. Turning off animations.");
}
//_animation[idleAnimation.name] = idleAnimation;
if(!walkAnimation) {
_animation = null;
Debug.Log("No walk animation found. Turning off animations.");
}
//_animation[walkAnimation.name] = walkAnimation;
}
function UpdateSmoothedMovementDirection () {
var cameraTransform = Camera.main.transform;
//Forward vector relative to the camera along the x-z plane    
var forward = cameraTransform.TransformDirection(Vector3.forward);
forward.y = 0;
forward = forward.normalized;
//Right vector relative to the camera
//Always orthogonal to the forward vector
var right = Vector3(forward.z, 0, -forward.x);
var v = Input.GetAxisRaw("Vertical");
var h = Input.GetAxisRaw("Horizontal");
//Are we moving backwards or looking backwards
if (v < -0.2)
movingBack = true;
else
movingBack = false;
var wasMoving = isMoving;
isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;
//Target direction relative to the camera
var targetDirection = h * right + v * forward;
//Lock camera for short period when transitioning moving & standing still
lockCameraTimer += Time.deltaTime;
if (isMoving != wasMoving)
lockCameraTimer = 0.0;
//We store speed and direction seperately,
//so that when the character stands still we still have a valid forward direction
//moveDirection is always normalized, and we only update it if there is user input.
if (targetDirection != Vector3.zero) {
//If we are really slow, just snap to the target direction
if (moveSpeed < walkSpeed * 0.9) {
moveDirection = targetDirection.normalized;
}
//Otherwise smoothly turn towards it
else {
moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
moveDirection = moveDirection.normalized;
}
}
//Smooth the speed based on the current target direction
var curSmooth = speedSmoothing * Time.deltaTime;
//Choose target speed
//* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);
_characterState = CharacterState.Idle;
//Pick speed modifier
targetSpeed *= walkSpeed;
_characterState = CharacterState.Walking;
moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);
}
function UpdateTargettedMovementDirection () {
var cameraTransform = Camera.main.transform;
var wasMoving = isMoving;
isMoving = true;//Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;
//Target direction relative to the camera
//var targetDirection = h * right + v * forward;
var targetDirection = Vector3.zero;
targetDirection.x =  targetPoint.x - transform.position.x;
targetDirection.z =  targetPoint.z - transform.position.z;
targetDirection = targetDirection.normalized;
//Debug.Log("Target direction is " + targetDirection);
//Lock camera for short period when transitioning moving & standing still
lockCameraTimer += Time.deltaTime;
if (isMoving != wasMoving)
lockCameraTimer = 0.0;
//We store speed and direction seperately,
//so that when the character stands still we still have a valid forward direction
//moveDirection is always normalized, and we only update it if there is user input.
if (targetDirection != Vector3.zero) {
//If we are really slow, just snap to the target direction
if (moveSpeed < walkSpeed * 0.9) {
moveDirection = targetDirection.normalized;
}
//Otherwise smoothly turn towards it
else {
moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
moveDirection = moveDirection.normalized;
}
}
//Smooth the speed based on the current target direction
var curSmooth = speedSmoothing * Time.deltaTime;
//Choose target speed
//* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);
_characterState = CharacterState.Idle;
//Pick speed modifier
targetSpeed *= walkSpeed;
_characterState = CharacterState.Walking;
moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);      
}
function Update() {
if (!isControllable) {
//kill all inputs if not controllable.
Input.ResetInputAxes();
}
var distance : float = 0;
if (Input.GetMouseButtonUp(0)) {
if (isTargetting) {
isTargetting = false;
//Debug.Log("Stopped moving");
FaceCamera();
} else {
var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
var layerMask = 1 << 8; //Terrain is layer 8
var hit : RaycastHit;
Physics.Raycast(Camera.main.transform.position, ray.direction, hit, 1000, layerMask);
distance = Vector3.Distance(transform.position, hit.point);
if (distance <= targetMaxDistance && hit.point != Vector3.zero) {
targetPoint = hit.point;
isTargetting = true;
//Debug.Log("Mouse up at hit " + hit.point + " at distance " + distance);
} else {
isTargetting = false;
//Debug.Log("Ignored mouse up at hit " + hit.point + " at distance " + distance);
}
}
}
if (isTargetting) {
//Debug.Log("Moving to " + targetPoint);
distance = Vector3.Distance(transform.position, targetPoint);
if (distance < targetPrecision) {
//Debug.Log("Reached point " + targetPoint + " at distance " + distance);
isTargetting = false;
FaceCamera();
} else {
UpdateTargettedMovementDirection();
}
} else {
UpdateSmoothedMovementDirection();
}
//Calculate actual motion
var movement = moveDirection * moveSpeed;
movement *= Time.deltaTime;
//Move the controller
var controller : CharacterController = GetComponent(CharacterController);
collisionFlags = controller.Move(movement);
//ANIMATION sector
if (_animation) {       
if (controller.velocity.sqrMagnitude < 0.1) {
_animation.CrossFade(idleAnimation.name);
} else {
//_animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed);
_animation.CrossFade(walkAnimation.name);       
}
} else {
Debug.Log("Animation is null!");
}
//ANIMATION sector
//Set rotation to the move direction
transform.rotation = Quaternion.LookRotation(moveDirection);
}
function OnControllerColliderHit (hit : ControllerColliderHit ) {
// Debug.DrawRay(hit.point, hit.normal);
if (hit.moveDirection.y > 0.01) 
return;
}
function GetSpeed () {
return moveSpeed;
}
function GetDirection () {
return moveDirection;
}
function IsMovingBackwards () {
return movingBack;
}
function GetLockCameraTimer () {
return lockCameraTimer;
}
function IsMoving () : boolean {
return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5;
}
function Reset () {
gameObject.tag = "Player";
}
function FaceCamera() {
var cameraTransform = Camera.main.transform;
//Forward vector relative to the camera along the x-z plane    
var forward = cameraTransform.TransformDirection(Vector3.forward);
forward.y = 0;
forward = forward.normalized;
moveDirection = -forward;
}

Mise à jour 2: Les paramètres utilisés pour créer les animations sont dans ces captures d'écran. Sont-ils corrects?

OriginalL'auteur Johan Kool | 2012-05-01