Worker Demo Collision issue!

kurtfury

i am posting to see if anyone can explain and possibly offer a solution to a issue with the controller in the Worker demo.
I was experimenting with the controller when i discovered that if the model that is being controlled by the controller hits any type of collider the controlled model seems to jitter to the left and right. i have been trying to figure out why this is happening for a few days and just cant seem to locate the root of it. there are a few suspected areas in the code that i think maybe causing it but cant seem to pinpoint the exact one. im assuming its because when the controller makes contact with the collider mutiple move or rotate values are being applied and are conflicting and need to have a buffer set. but i cant locate exactly were its originating from.
thanks in advance.

Tobias

I guess in these cases, the controller will put your char into a position that's physically impossible, so that the rigid body physics is correcting this. Each frame your network positioning Update will conflict with that of the physics.
You would need to somehow feed back the physics re-positioning to the network controller, as it's position is impossible.

kurtfury

it is not using Rigidbody, i posted the code below for ease of discussion


[code2=csharp]using UnityEngine;
using System.Collections;

public enum CharacterState
{
Idle = 0,
Walking = 1,
Trotting = 2,
Running = 3,
Jumping = 4,
}

public class ThirdPersonController : MonoBehaviour
{

public AnimationClip idleAnimation;
public AnimationClip walkAnimation;
public AnimationClip runAnimation;
public AnimationClip jumpPoseAnimation;

public float walkMaxAnimationSpeed = 0.75f;
public float trotMaxAnimationSpeed = 1.0f;
public float runMaxAnimationSpeed = 1.0f;
public float jumpAnimationSpeed = 1.15f;
public float landAnimationSpeed = 1.0f;

private Animation _animation;



public CharacterState _characterState;

// The speed when walking
public float walkSpeed = 2.0f;
// after trotAfterSeconds of walking we trot with trotSpeed
public float trotSpeed = 4.0f;
// when pressing "Fire3" button (cmd) we start running
public float runSpeed = 6.0f;

public float inAirControlAcceleration = 3.0f;

// How high do we jump when pressing jump and letting go immediately
public float jumpHeight = 0.5f;

// The gravity for the character
public float gravity = 20.0f;
// The gravity in controlled descent mode
public float speedSmoothing = 10.0f;
public float rotateSpeed = 500.0f;
public float trotAfterSeconds = 3.0f;

public bool canJump = false;

private float jumpRepeatTime = 0.05f;
private float jumpTimeout = 0.15f;
private float groundedTimeout = 0.25f;

// The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
private float lockCameraTimer = 0.0f;

// The current move direction in x-z
private Vector3 moveDirection = Vector3.zero;
// The current vertical speed
private float verticalSpeed = 0.0f;
// The current x-z move speed
private float moveSpeed = 0.0f;

// The last collision flags returned from controller.Move
private CollisionFlags collisionFlags;

// Are we jumping? (Initiated with jump button and not grounded yet)
private bool jumping = false;
private bool jumpingReachedApex = false;

// Are we moving backwards (This locks the camera to not do a 180 degree spin)
private bool movingBack = false;
// Is the user pressing any keys?
private bool isMoving = false;
// When did the user start walking (Used for going into trot after a while)
private float walkTimeStart = 0.0f;
// Last time the jump button was clicked down
private float lastJumpButtonTime = -10.0f;
// Last time we performed a jump
private float lastJumpTime = -1.0f;
// the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
//private float lastJumpStartHeight = 0.0f;
private Vector3 inAirVelocity = Vector3.zero;

private float lastGroundedTime = 0.0f;
public bool isControllable = true;

void 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.");

/*
public AnimationClip idleAnimation;
public AnimationClip walkAnimation;
public AnimationClip runAnimation;
public AnimationClip jumpPoseAnimation;
*/
if (!idleAnimation)
{
_animation = null;
Debug.Log("No idle animation found. Turning off animations.");
}
if (!walkAnimation)
{
_animation = null;
Debug.Log("No walk animation found. Turning off animations.");
}
if (!runAnimation)
{
_animation = null;
Debug.Log("No run animation found. Turning off animations.");
}
if (!jumpPoseAnimation && canJump)
{
_animation = null;
Debug.Log("No jump animation found and the character has canJump enabled. Turning off animations.");
}

}

private Vector3 lastPos;

void UpdateSmoothedMovementDirection()
{
Transform cameraTransform = Camera.main.transform;
bool grounded = IsGrounded();

// Forward vector relative to the camera along the x-z plane
Vector3 forward = cameraTransform.TransformDirection(Vector3.forward);
forward.y = 0;
forward = forward.normalized;

// Right vector relative to the camera
// Always orthogonal to the forward vector
Vector3 right = new Vector3(forward.z, 0, -forward.x);

float v = Input.GetAxisRaw("Vertical");
float h = Input.GetAxisRaw("Horizontal");

// Are we moving backwards or looking backwards
if (v < -0.2f)
movingBack = true;
else
movingBack = false;

bool wasMoving = isMoving;
isMoving = Mathf.Abs(h) > 0.1f || Mathf.Abs(v) > 0.1f;

// Target direction relative to the camera
Vector3 targetDirection = h * right + v * forward;

// Grounded controls
if (grounded)
{
// Lock camera for short period when transitioning moving & standing still
lockCameraTimer += Time.deltaTime;
if (isMoving != wasMoving)
lockCameraTimer = 0.0f;

// 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.9f && grounded)
{
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
float 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
float targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0f);

_characterState = CharacterState.Idle;

// Pick speed modifier
if (Input.GetKey(KeyCode.LeftShift) | Input.GetKey(KeyCode.RightShift))
{
targetSpeed *= runSpeed;
_characterState = CharacterState.Running;
}
else if (Time.time - trotAfterSeconds > walkTimeStart)
{
targetSpeed *= trotSpeed;
_characterState = CharacterState.Trotting;
}
else
{
targetSpeed *= walkSpeed;
_characterState = CharacterState.Walking;
}

moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);

// Reset walk time start when we slow down
if (moveSpeed < walkSpeed * 0.3f)
walkTimeStart = Time.time;
}
// In air controls
else
{
// Lock camera while in air
if (jumping)
lockCameraTimer = 0.0f;

if (isMoving)
inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
}



}
void ApplyJumping()
{
// Prevent jumping too fast after each other
if (lastJumpTime + jumpRepeatTime > Time.time)
return;

if (IsGrounded())
{
// Jump
// - Only when pressing the button down
// - With a timeout so you can press the button slightly before landing
if (canJump && Time.time < lastJumpButtonTime + jumpTimeout)
{
verticalSpeed = CalculateJumpVerticalSpeed(jumpHeight);
SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
}
}
}
void ApplyGravity()
{
if (isControllable) // don't move player at all if not controllable.
{
// Apply gravity
//bool jumpButton = Input.GetButton("Jump");

// When we reach the apex of the jump we send out a message
if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0f)
{
jumpingReachedApex = true;
SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
}

if (IsGrounded())
verticalSpeed = 0.0f;
else
verticalSpeed -= gravity * Time.deltaTime;
}
}

float CalculateJumpVerticalSpeed(float targetJumpHeight)
{
// From the jump height and gravity we deduce the upwards speed
// for the character to reach at the apex.
return Mathf.Sqrt(2 * targetJumpHeight * gravity);
}

void DidJump()
{
jumping = true;
jumpingReachedApex = false;
lastJumpTime = Time.time;
//lastJumpStartHeight = transform.position.y;
lastJumpButtonTime = -10;

_characterState = CharacterState.Jumping;
}

Vector3 velocity = Vector3.zero;

void Update()
{
if (isControllable)
{
if (Input.GetButtonDown("Jump"))
{
lastJumpButtonTime = Time.time;
}

UpdateSmoothedMovementDirection();

// Apply gravity
// - extra power jump modifies gravity
// - controlledDescent mode modifies gravity
ApplyGravity();

// Apply jumping logic
ApplyJumping();


// Calculate actual motion
Vector3 movement = moveDirection * moveSpeed + new Vector3(0, verticalSpeed, 0) + inAirVelocity;
movement *= Time.deltaTime;

// Move the controller
CharacterController controller = GetComponent<CharacterController>();
collisionFlags = controller.Move(movement);
}
velocity = (transform.position - lastPos)*25;

// ANIMATION sector
if (_animation)
{
if (_characterState == CharacterState.Jumping)
{
if (!jumpingReachedApex)
{
_animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
_animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
_animation.CrossFade(jumpPoseAnimation.name);
}
else
{
_animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
_animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
_animation.CrossFade(jumpPoseAnimation.name);
}
}
else
{
if (this.isControllable && velocity.sqrMagnitude < 0.001f)
{
_characterState = CharacterState.Idle;
_animation.CrossFade(idleAnimation.name);
}
else
{
if (_characterState == CharacterState.Idle)
{
_animation.CrossFade(idleAnimation.name);
}
else if (_characterState == CharacterState.Running)
{
_animation[runAnimation.name].speed = runMaxAnimationSpeed;
if (this.isControllable)
{
_animation[runAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, runMaxAnimationSpeed);
}
_animation.CrossFade(runAnimation.name);
}
else if (_characterState == CharacterState.Trotting)
{
_animation[walkAnimation.name].speed = trotMaxAnimationSpeed;
if (this.isControllable)
{
_animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, trotMaxAnimationSpeed);
}
_animation.CrossFade(walkAnimation.name);
}
else if (_characterState == CharacterState.Walking)
{
_animation[walkAnimation.name].speed = walkMaxAnimationSpeed;
if (this.isControllable)
{
_animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, walkMaxAnimationSpeed);
}
_animation.CrossFade(walkAnimation.name);
}

}
}
}
// ANIMATION sector

// Set rotation to the move direction
if (IsGrounded())
{

transform.rotation = Quaternion.LookRotation(moveDirection);

}
else
{
Vector3 xzMove = velocity;
xzMove.y = 0;
if (xzMove.sqrMagnitude > 0.001f)
{
transform.rotation = Quaternion.LookRotation(xzMove);
}
}

// We are in jump mode but just became grounded
if (IsGrounded())
{
lastGroundedTime = Time.time;
inAirVelocity = Vector3.zero;
if (jumping)
{
jumping = false;
SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
}
}

lastPos = transform.position;
}

void OnControllerColliderHit(ControllerColliderHit hit)
{
// Debug.DrawRay(hit.point, hit.normal);
if (hit.moveDirection.y > 0.01f)


return;
}

public float GetSpeed()
{
return moveSpeed;
}

public bool IsJumping()
{
return jumping;
}

public bool IsGrounded()
{
return (collisionFlags & CollisionFlags.CollidedBelow) != 0;
}

public Vector3 GetDirection()
{
return moveDirection;
}

public bool IsMovingBackwards()
{
return movingBack;
}

public float GetLockCameraTimer()
{
return lockCameraTimer;
}

public bool IsMoving()
{
return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5f;
}

public bool HasJumpReachedApex()
{
return jumpingReachedApex;
}

public bool IsGroundedWithTimeout()
{
return lastGroundedTime + groundedTimeout > Time.time;
}

public void Reset()
{
gameObject.tag = "Player";
}


}[/code2]

Tobias

That's a bunch of code and I don't know if I should dive into this. This is usually something game-depending which you should be able to work around in worst case.
Can you try to narrow down the issue somehow?

kurtfury

well i posted the entire script so that perhaps another set of eyes might of spotted an issue, and for testing this script is very simple to setup and requires nothing more then a character controller and a model with basic move animations that you can just drop into the inspector.
the point of the post was not just looking for the answer but more so the reason, ive gone through this code over and over , and though i do see a few areas that are not really properly coded such is " cursmooth" and the "movingBack" i cant see anything that is causing the controller to go haywire on collision.

Tobias

Ok.
The character controller comes in multiple flavors. We usually use a cs version but in many demos there's a JS variant.
If you export the repro project and post it here, I'll take a look and try to find the solution / explanation with you.

kurtfury

The concerning controller is the C# version , if you test the JS version it works fine yet seems to be the coded identically. i posted the package with no modifcations other then adding collider objects for testing. the package is over 2MB so cant be attached, so i hosted it on my ftp. or you can just run the Worker demo supplied with the Photon Network Demo.



http://relicsrealm.com/public/DEMOworker.rar

Tobias

"with no modifcations other then adding collider objects for testing"
Where are they? I don't know how to reproduce the issue in this case.

Tobias

I can produce an effect that seems to be what you mean by running 2 clients and making the workers run into each other. For a while the worker heavily oscillates between 2 rotations. In my framerate it almost looks like he's translucent. This affects the local character.

I don't know exactly why this happens. I still suspect it to be a physics versus controller issue like posted above. We'll see if I can analyze and fix this.

Edit: I doubt it's a networking issue at all. Turning off the "ThirdPersonNetwork" doesn't solve the issue, either. We should start looking around if someone has noticed this issue with the ThirdPersonController and physics and solved it.

kurtfury

yes i that is the exact problem i am having. i have searched around the Unity forums as well as a few other informational forums for others having posted on this and had not luck.thank you for taking the time to looking into this.i cant for the life of me find what is causing this now it has almost became an obsession to solve this.You maybe correct in stating the issue is in the physics, i cant see any reason for this to happen. perhaps the script conflicts with the Character controller witch is were i am gonna focus on tonight.

Tobias

I am almost certain it's an issue between the physics and setting the move direction by a script. I am not sure how to fix this though. Not even, if this is in my range to fix.
What did you find out?