Jump to content
Unity Insider Forum
Sign in to follow this  
kruemel

Character Motor mit rotation in bewegungs richtung

Recommended Posts

Hi.

 

Ich versuche aktuell einen character motor so um zu ändern das die spielfigur sich beim bewegen auch in die sicht richtung dreht.

leider blicke ich da so noch nicht ganz durch wie es genau klappen soll.

 

ich nutze für die figur den unity Character Controller und 2 standard scripte für die bewegung.

 

Einmal den Character Motor:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;


	
	[RequireComponent (typeof (CharacterController))]

	
	[AddComponentMenu("Character/Character Motor C")]
	


	public class CharacterMotorC : MonoBehaviour {
		[System.Serializable]
		public enum MovementTransferOnJump {
			None, // The jump is not affected by velocity of floor at all.
			InitTransfer, // Jump gets its initial velocity from the floor, then gradualy comes to a stop.
			PermaTransfer, // Jump gets its initial velocity from the floor, and keeps that velocity until landing.
			PermaLocked // Jump is relative to the movement of the last touched floor and will move together with that floor.
		}

		[System.Serializable]
		public class CharacterMotorMovingPlatform {
			public bool enabled = true;
			public MovementTransferOnJump movementTransfer = MovementTransferOnJump.PermaTransfer;
			[System.NonSerialized]
			public Transform hitPlatform;
			[System.NonSerialized]
			public Transform activePlatform;
			[System.NonSerialized]
			public Vector3 activeLocalPoint;
			[System.NonSerialized]
			public Vector3 activeGlobalPoint;
			[System.NonSerialized]
			public Quaternion activeLocalRotation;
			[System.NonSerialized]
			public Quaternion activeGlobalRotation;
			[System.NonSerialized]
			public Matrix4x4 lastMatrix;
			[System.NonSerialized]
			public Vector3 platformVelocity;
			[System.NonSerialized]
			public bool newPlatform;
		}

		[System.Serializable]
		public class CharacterMotorMovement {
			// The maximum horizontal speed when moving
			public float maxForwardSpeed = 10.0f;
			public float maxSidewaysSpeed = 10.0f;
			public float maxBackwardsSpeed = 10.0f;
			// Curve for multiplying speed based on slope (negative = downwards)
			public AnimationCurve slopeSpeedMultiplier = new AnimationCurve(new Keyframe(-90, 1), new Keyframe(0, 1), new Keyframe(90, 0));
			// How fast does the character change speeds?  Higher is faster.
			public float maxGroundAcceleration = 30.0f;
			public float maxAirAcceleration = 20.0f;
			// The gravity for the character
			public float gravity = 10.0f;
			public float maxFallSpeed = 20.0f;
			// For the next variables, [System.NonSerialized] tells Unity to not serialize the variable or show it in the inspector view.
			// Very handy for organization!
			// The last collision flags returned from controller.Move
			[System.NonSerialized]
			public CollisionFlags collisionFlags;
			// We will keep track of the character's current velocity,
			[System.NonSerialized]
			public Vector3 velocity;
			// This keeps track of our current velocity while we're not grounded
			[System.NonSerialized]
			public Vector3 frameVelocity = Vector3.zero;
			[System.NonSerialized]
			public Vector3 hitPoint = Vector3.zero;
			[System.NonSerialized]
			public Vector3 lastHitPoint = new Vector3(Mathf.Infinity, 0, 0);
		}

		// We will contain all the jumping related variables in one helper class for clarity.

		[System.Serializable]
		public class CharacterMotorJumping {
			// Can the character jump?
			public bool enabled = true;
			// How high do we jump when pressing jump and letting go immediately
			public float baseHeight = 1.0f;
			// We add extraHeight units (meters) on top when holding the button down longer while jumping
			public float extraHeight = 4.1f;
			// How much does the character jump out perpendicular to the surface on walkable surfaces?
			// 0 means a fully vertical jump and 1 means fully perpendicular.
			public float perpAmount = 0.0f;
			// How much does the character jump out perpendicular to the surface on too steep surfaces?
			// 0 means a fully vertical jump and 1 means fully perpendicular.
			public float steepPerpAmount = 0.5f;
			// For the next variables, [System.NonSerialized] tells Unity to not serialize the variable or show it in the inspector view.
			// Very handy for organization!
			// Are we jumping? (Initiated with jump button and not grounded yet)
			// To see if we are just in the air (initiated by jumping OR falling) see the grounded variable.
			[System.NonSerialized]
			public bool jumping = false;
			[System.NonSerialized]
			public bool holdingJumpButton = false;
			// the time we jumped at (Used to determine for how long to apply extra jump power after jumping.)
			[System.NonSerialized]
			public float lastStartTime = 0.0f;
			[System.NonSerialized]
			public float lastButtonDownTime = -100f;
			[System.NonSerialized]
			public Vector3 jumpDir = Vector3.up;
		}

		[System.Serializable]
		public class CharacterMotorSliding {
			// Does the character slide on too steep surfaces?
			public bool enabled = true;

			// How fast does the character slide on steep surfaces?
			public float slidingSpeed = 15f;

			// How much can the player control the sliding direction?
			// If the value is 0.5 the player can slide sideways with half the speed of the downwards sliding speed.
			public float sidewaysControl = 1.0f;

			// How much can the player influence the sliding speed?
			// If the value is 0.5 the player can speed the sliding up to 150% or slow it down to 50%.
			public float speedControl = 0.4f;
		}


		// Does this script currently respond to input?
		public bool canControl = true;

		public bool useFixedUpdate = true;

		// For the next variables, [System.NonSerialized] tells Unity to not serialize the variable or show it in the inspector view.
		// Very handy for organization!

		// The current global direction we want the character to move in.
		[System.NonSerialized]
		public Vector3 inputMoveDirection = Vector3.zero;

		// Is the jump button held down? We use this interface instead of checking
		// for the jump button directly so this script can also be used by AIs.
		[System.NonSerialized]
		public bool inputJump = false;

		public CharacterMotorMovement movement = new CharacterMotorMovement();
		public CharacterMotorJumping jumping = new CharacterMotorJumping();
		public CharacterMotorMovingPlatform movingPlatform = new CharacterMotorMovingPlatform();
		public CharacterMotorSliding sliding = new CharacterMotorSliding();

		[System.NonSerialized]
		bool grounded = true;

		[System.NonSerialized]
		Vector3 groundNormal = Vector3.zero;

		private Vector3 lastGroundNormal = Vector3.zero;
		private Transform tr;
		private CharacterController controller;

		void Awake () {
			controller = GetComponent <CharacterController>();
			tr = transform;
		}

		void UpdateFunction () {
			// We copy the actual velocity into a temporary variable that we can manipulate.
			Vector3 velocity = movement.velocity;
			// Update velocity based on input
			velocity = ApplyInputVelocityChange(velocity);
			// Apply gravity and jumping force
			velocity = ApplyGravityAndJumping (velocity);
			// Moving platform support
			Vector3 moveDistance = Vector3.zero;

			if (MoveWithPlatform()) {
				Vector3 newGlobalPoint = movingPlatform.activePlatform.TransformPoint(movingPlatform.activeLocalPoint);
				moveDistance = (newGlobalPoint - movingPlatform.activeGlobalPoint);
				if (moveDistance != Vector3.zero)
					controller.Move(moveDistance);
				// Support moving platform rotation as well:
				Quaternion newGlobalRotation = movingPlatform.activePlatform.rotation * movingPlatform.activeLocalRotation;
				Quaternion rotationDiff = newGlobalRotation * Quaternion.Inverse(movingPlatform.activeGlobalRotation);
				float yRotation = rotationDiff.eulerAngles.y;
				if (yRotation != 0) {
					// Prevent rotation of the local up vector
					tr.Rotate(0, yRotation, 0);
				}
			}
			// Save lastPosition for velocity calculation.
			Vector3 lastPosition = tr.position;
			// We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.
			Vector3 currentMovementOffset = velocity * Time.deltaTime;
			// Find out how much we need to push towards the ground to avoid loosing grouning
			// when walking down a step or over a sharp change in slope.
			float mathf1 = controller.stepOffset;
			float mathf2 = new Vector3(currentMovementOffset.x, 0, currentMovementOffset.z).magnitude;
			float pushDownOffset = Mathf.Max(mathf1, mathf2);
			if (grounded)
				currentMovementOffset -= pushDownOffset * Vector3.up;
			// Reset variables that will be set by collision function
			movingPlatform.hitPlatform = null;
			groundNormal = Vector3.zero;
			// Move our character!
			movement.collisionFlags = controller.Move (currentMovementOffset);
			movement.lastHitPoint = movement.hitPoint;
			lastGroundNormal = groundNormal;
			if (movingPlatform.enabled && movingPlatform.activePlatform != movingPlatform.hitPlatform) {
				if (movingPlatform.hitPlatform != null) {
					movingPlatform.activePlatform = movingPlatform.hitPlatform;
					movingPlatform.lastMatrix = movingPlatform.hitPlatform.localToWorldMatrix;
					movingPlatform.newPlatform = true;
				}
			}
			// Calculate the velocity based on the current and previous position.
			// This means our velocity will only be the amount the character actually moved as a result of collisions.
			Vector3 oldHVelocity = new Vector3(velocity.x, 0, velocity.z);
			movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
			Vector3 newHVelocity = new Vector3(movement.velocity.x, 0, movement.velocity.z);
			// The CharacterController can be moved in unwanted directions when colliding with things.
			// We want to prevent this from influencing the recorded velocity.
			if (oldHVelocity == Vector3.zero) {
				movement.velocity = new Vector3(0, movement.velocity.y, 0);
			}
			else {
				float projectedNewVelocity = Vector3.Dot(newHVelocity, oldHVelocity) / oldHVelocity.sqrMagnitude;
				movement.velocity = oldHVelocity * Mathf.Clamp01(projectedNewVelocity) + movement.velocity.y * Vector3.up;
			}
			if (movement.velocity.y < velocity.y - 0.001) {
				if (movement.velocity.y < 0) {
					// Something is forcing the CharacterController down faster than it should.
					// Ignore this
					movement.velocity.y = velocity.y;
				}
				else {
					// The upwards movement of the CharacterController has been blocked.
					// This is treated like a ceiling collision - stop further jumping here.
					jumping.holdingJumpButton = false;
				}
			}
			// We were grounded but just loosed grounding
			if (grounded && !IsGroundedTest()) {
				grounded = false;
				// Apply inertia from platform
				if (movingPlatform.enabled &&
					(movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
						movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)) {
					movement.frameVelocity = movingPlatform.platformVelocity;
					movement.velocity += movingPlatform.platformVelocity;
				}
				SendMessage("OnFall", SendMessageOptions.DontRequireReceiver);
				// We pushed the character down to ensure it would stay on the ground if there was any.
				// But there wasn't so now we cancel the downwards offset to make the fall smoother.
				tr.position += pushDownOffset * Vector3.up;
			}
			// We were not grounded but just landed on something
			else if (!grounded && IsGroundedTest()) {
				grounded = true;
				jumping.jumping = false;
				SubtractNewPlatformVelocity();
				SendMessage("OnLand", SendMessageOptions.DontRequireReceiver);
			}
			// Moving platforms support
			if (MoveWithPlatform()) {
				// Use the center of the lower half sphere of the capsule as reference point.
				// This works best when the character is standing on moving tilting platforms.
				//movingPlatform.activeGlobalPoint = tr.position +
				//float thisstuff = (float)(controller.center.y - controller.height*0.5 + controller.radius);
				//Vector3 testthis = Vector3.up * thisstuff;
				//movingPlatform.activeGlobalPoint *= (controller.center.y - controller.height*0.5 + controller.radius);
				movingPlatform.activeLocalPoint = movingPlatform.activePlatform.InverseTransformPoint(movingPlatform.activeGlobalPoint);
				// Support moving platform rotation as well:
				movingPlatform.activeGlobalRotation = tr.rotation;
				movingPlatform.activeLocalRotation = Quaternion.Inverse(movingPlatform.activePlatform.rotation) * movingPlatform.activeGlobalRotation;
			}
		}

		void FixedUpdate () {
			if (movingPlatform.enabled) {
				if (movingPlatform.activePlatform != null) {
					if (!movingPlatform.newPlatform) {
						//Vector3 lastVelocity = movingPlatform.platformVelocity;
						movingPlatform.platformVelocity = (
							movingPlatform.activePlatform.localToWorldMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint)
							- movingPlatform.lastMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint)
						) / Time.deltaTime;
					}
					movingPlatform.lastMatrix = movingPlatform.activePlatform.localToWorldMatrix;
					movingPlatform.newPlatform = false;
				}
				else {
					movingPlatform.platformVelocity = Vector3.zero;
				}
			}
			if (useFixedUpdate)
				UpdateFunction();
		}

		void Update () {
			if (!useFixedUpdate)
				UpdateFunction();
		}

		private Vector3 ApplyInputVelocityChange (Vector3 velocity) {
			if (!canControl)
				inputMoveDirection = Vector3.zero;
			// Find desired velocity
			Vector3 desiredVelocity;
			if (grounded && TooSteep()) {
				// The direction we're sliding in
				desiredVelocity = new Vector3(groundNormal.x, 0, groundNormal.z).normalized;
				// Find the input movement direction projected onto the sliding direction
				Vector3 projectedMoveDir = Vector3.Project(inputMoveDirection, desiredVelocity);
				// Add the sliding direction, the spped control, and the sideways control vectors
				desiredVelocity = desiredVelocity + projectedMoveDir * sliding.speedControl + (inputMoveDirection - projectedMoveDir) * sliding.sidewaysControl;
				// Multiply with the sliding speed
				desiredVelocity *= sliding.slidingSpeed;
			}
			else
				desiredVelocity = GetDesiredHorizontalVelocity();
			if (movingPlatform.enabled && movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer) {
				desiredVelocity += movement.frameVelocity;
				desiredVelocity.y = 0;
			}
			if (grounded)
				desiredVelocity = AdjustGroundVelocityToNormal(desiredVelocity, groundNormal);
			else
				velocity.y = 0;
			// Enforce max velocity change
			float maxVelocityChange = GetMaxAcceleration(grounded) * Time.deltaTime;
			Vector3 velocityChangeVector = (desiredVelocity - velocity);
			if (velocityChangeVector.sqrMagnitude > maxVelocityChange * maxVelocityChange) {
				velocityChangeVector = velocityChangeVector.normalized * maxVelocityChange;
			}
			// If we're in the air and don't have control, don't apply any velocity change at all.
			// If we're on the ground and don't have control we do apply it - it will correspond to friction.
			if (grounded || canControl)
				velocity += velocityChangeVector;
			if (grounded) {
				// When going uphill, the CharacterController will automatically move up by the needed amount.
				// Not moving it upwards manually prevent risk of lifting off from the ground.
				// When going downhill, DO move down manually, as gravity is not enough on steep hills.
				velocity.y = Mathf.Min(velocity.y, 0);
			}
			return velocity;
		}

		private Vector3 ApplyGravityAndJumping (Vector3 velocity) {
			if (!inputJump || !canControl) {
				jumping.holdingJumpButton = false;
				jumping.lastButtonDownTime = -100;
			}
			if (inputJump && jumping.lastButtonDownTime < 0 && canControl)
				jumping.lastButtonDownTime = Time.time;
			if (grounded)
				velocity.y = Mathf.Min(0, velocity.y) - movement.gravity * Time.deltaTime;
			else {
				velocity.y = movement.velocity.y - movement.gravity * Time.deltaTime;
				// When jumping up we don't apply gravity for some time when the user is holding the jump button.
				// This gives more control over jump height by pressing the button longer.
				if (jumping.jumping && jumping.holdingJumpButton) {
					// Calculate the duration that the extra jump force should have effect.
					// If we're still less than that duration after the jumping time, apply the force.
					if (Time.time < jumping.lastStartTime + jumping.extraHeight / CalculateJumpVerticalSpeed(jumping.baseHeight)) {
						// Negate the gravity we just applied, except we push in jumpDir rather than jump upwards.
						velocity += jumping.jumpDir * movement.gravity * Time.deltaTime;
					}
				}
				// Make sure we don't fall any faster than maxFallSpeed. This gives our character a terminal velocity.
				velocity.y = Mathf.Max (velocity.y, -movement.maxFallSpeed);
			}
			if (grounded) {
				// Jump only if the jump button was pressed down in the last 0.2 seconds.
				// We use this check instead of checking if it's pressed down right now
				// because players will often try to jump in the exact moment when hitting the ground after a jump
				// and if they hit the button a fraction of a second too soon and no new jump happens as a consequence,
				// it's confusing and it feels like the game is buggy.
				if (jumping.enabled && canControl && (Time.time - jumping.lastButtonDownTime < 0.2)) {
					grounded = false;
					jumping.jumping = true;
					jumping.lastStartTime = Time.time;
					jumping.lastButtonDownTime = -100;
					jumping.holdingJumpButton = true;
					// Calculate the jumping direction
					if (TooSteep())
						jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.steepPerpAmount);
					else
						jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.perpAmount);
					// Apply the jumping force to the velocity. Cancel any vertical velocity first.
					velocity.y = 0;
					velocity += jumping.jumpDir * CalculateJumpVerticalSpeed (jumping.baseHeight);
					// Apply inertia from platform
					if (movingPlatform.enabled &&
						(movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
							movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)) {
						movement.frameVelocity = movingPlatform.platformVelocity;
						velocity += movingPlatform.platformVelocity;

					}
					SendMessage("OnJump", SendMessageOptions.DontRequireReceiver);
				}
				else {
					jumping.holdingJumpButton = false;
				}
			}
			return velocity;
		}

		void OnControllerColliderHit (ControllerColliderHit hit) {
			if (hit.normal.y > 0 && hit.normal.y > groundNormal.y && hit.moveDirection.y < 0) {
				if ((hit.point - movement.lastHitPoint).sqrMagnitude > 0.001 || lastGroundNormal == Vector3.zero)
					groundNormal = hit.normal;
				else
					groundNormal = lastGroundNormal;
				movingPlatform.hitPlatform = hit.collider.transform;
				movement.hitPoint = hit.point;
				movement.frameVelocity = Vector3.zero;
			}
		}

		private IEnumerator SubtractNewPlatformVelocity () {
			// When landing, subtract the velocity of the new ground from the character's velocity
			// since movement in ground is relative to the movement of the ground.
			if (movingPlatform.enabled &&
				(movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
					movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)) {
				// If we landed on a new platform, we have to wait for two FixedUpdates
				// before we know the velocity of the platform under the character
				if (movingPlatform.newPlatform) {
					Transform platform = movingPlatform.activePlatform;
					yield return new WaitForFixedUpdate();
					yield return new WaitForFixedUpdate();
					if (grounded && platform == movingPlatform.activePlatform)
						yield return 1;
				}
				movement.velocity -= movingPlatform.platformVelocity;
			}
		}

		private bool MoveWithPlatform () {
			return (
				movingPlatform.enabled
				&& (grounded || movingPlatform.movementTransfer == MovementTransferOnJump.PermaLocked)
				&& movingPlatform.activePlatform != null
			);
		}

		private Vector3 GetDesiredHorizontalVelocity () {
			// Find desired velocity
			Vector3 desiredLocalDirection = tr.InverseTransformDirection(inputMoveDirection);
			double maxSpeed = MaxSpeedInDirection(desiredLocalDirection);
			if (grounded) {
				// Modify max speed on slopes based on slope speed multiplier curve
				var movementSlopeAngle = Mathf.Asin(movement.velocity.normalized.y)  * Mathf.Rad2Deg;
				maxSpeed *= movement.slopeSpeedMultiplier.Evaluate(movementSlopeAngle);
			}
			return tr.TransformDirection(desiredLocalDirection * (float)maxSpeed);
		}



		private Vector3 AdjustGroundVelocityToNormal (Vector3 hVelocity, Vector3 groundNormal) {
			Vector3 sideways = Vector3.Cross(Vector3.up, hVelocity);
			return Vector3.Cross(sideways, groundNormal).normalized * hVelocity.magnitude;
		}

		private bool IsGroundedTest () {
			return (groundNormal.y > 0.01);
		}

		float GetMaxAcceleration (bool grounded) {
			// Maximum acceleration on ground and in air
			if (grounded)
				return movement.maxGroundAcceleration;
			else
				return movement.maxAirAcceleration;
		}

		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 * movement.gravity);
		}

		bool IsJumping () {
			return jumping.jumping;
		}

		bool IsSliding () {
			return (grounded && sliding.enabled && TooSteep());
		}

		bool IsTouchingCeiling () {
			return (movement.collisionFlags & CollisionFlags.CollidedAbove) != 0;
		}

		bool IsGrounded () {
			return grounded;
		}

		bool TooSteep () {
			return (groundNormal.y <= Mathf.Cos(controller.slopeLimit * Mathf.Deg2Rad));
		}

		Vector3 GetDirection () {
			return inputMoveDirection;
		}

		void SetControllable (bool controllable) {
			canControl = controllable;
		}

		// Project a direction onto elliptical quater segments based on forward, sideways, and backwards speed.
		// The function returns the length of the resulting vector.
		double MaxSpeedInDirection (Vector3 desiredMovementDirection) {
			if (desiredMovementDirection == Vector3.zero)
				return 0;
			else {
				double zAxisEllipseMultiplier = (desiredMovementDirection.z > 0 ? movement.maxForwardSpeed : movement.maxBackwardsSpeed) / movement.maxSidewaysSpeed;
				float dMD = (float)desiredMovementDirection.x;
				float uio = (float)(desiredMovementDirection.z / zAxisEllipseMultiplier);
				Vector3 temp = new Vector3(dMD, 0, uio).normalized;
				float t1 = (float)temp.x; float t2 = (float)(temp.z * zAxisEllipseMultiplier);
				double length = new Vector3(t1, 0, t2).magnitude * movement.maxSidewaysSpeed;
				return length;
			}
		}

		void SetVelocity (Vector3 velocity) {
			grounded = false;
			movement.velocity = velocity;
			movement.frameVelocity = Vector3.zero;
			SendMessage("OnExternalVelocity");
		}
	}
	

 

und dann noch den FPS Imput Controller:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;


	// Require a character controller to be attached to the same game object
	[RequireComponent (typeof (CharacterMotorC))]

	//RequireComponent (CharacterMotor)
	[AddComponentMenu("Character/FPS Input Controller C")]
	//@script AddComponentMenu ("Character/FPS Input Controller")


	public class FPSInputControllerC : MonoBehaviour {
		private CharacterMotorC cmotor;
		// Use this for initialization
		void Awake() {
			cmotor = GetComponent<CharacterMotorC>();
		}

		// Update is called once per frame
		void Update () {
			// Get the input vector from keyboard or analog stick
			Vector3 directionVector;
			directionVector = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
			if (directionVector != Vector3.zero) {
				// Get the length of the directon vector and then normalize it
				// Dividing by the length is cheaper than normalizing when we already have the length anyway
				float directionLength = directionVector.magnitude;
				directionVector = directionVector / directionLength;

				// Make sure the length is no bigger than 1
				directionLength = Mathf.Min(1, directionLength);

				// Make the input vector more sensitive towards the extremes and less sensitive in the middle
				// This makes it easier to control slow speeds when using analog sticks
				directionLength = directionLength * directionLength;

				// Multiply the normalized direction vector by the modified length
				directionVector = directionVector * directionLength;
			}

			// Apply the direction to the CharacterMotor
			cmotor.inputMoveDirection = transform.rotation * directionVector;
			cmotor.inputJump = Input.GetButton("Jump");
		}

	}

 

irgendwo beim Character Motor muss da ja eigentlich nur vollgendes in etwa ergänzt werden: ...

transform.LookAt(newPosition + transform.position);
transform.Translate(newPosition * moveSpeed * Time.deltaTime, Space.World);

 

... und natürlich auch "sideways" und "backwards" funktion entfernt werden oder sehe ich das falsch. 🤔

ich bin da schon die ganze zeit am rum experimentieren und bekomme es einfach nicht ordentlich hin. 🙁

 

ich hoffe ihr könnt mir da etwas behilflich sein.

bin auch erst vor kurzem komplett von Javascript zu C umgestiegen so das ich noch ein paar kleine schwierigkeiten habe ^^°

 

 

Share this post


Link to post
Share on other sites

Unitys CharacterMotor-Script ist superkomplex, und es abzuändern ist meistens mehr Aufwand als ein eigenes Script anzufangen. Ich würde dir also empfehlen, einfach mal ein eigenes Script anzufangen. Ist nicht so schwer, wie es sich vielleicht anhört.

Am 21.9.2019 um 14:12 schrieb kruemel:

bin auch erst vor kurzem komplett von Javascript zu C umgestiegen so das ich noch ein paar kleine schwierigkeiten habe ^^°

C# ist nicht C. Ich erwähne das lieber mal, bevor du dich beim googeln wunderst ;)

Share this post


Link to post
Share on other sites
Am 22.9.2019 um 18:11 schrieb Sascha:

Unitys CharacterMotor-Script ist superkomplex, und es abzuändern ist meistens mehr Aufwand als ein eigenes Script anzufangen. Ich würde dir also empfehlen, einfach mal ein eigenes Script anzufangen. Ist nicht so schwer, wie es sich vielleicht anhört.

C# ist nicht C. Ich erwähne das lieber mal, bevor du dich beim googeln wunderst ;)

 

uff das wird echt schwierig 🤔

 

gibt es da schon irgenwelche tutorials zu?

ich brauche eigentlich nur einen character controller welcher den char in die richtung sehen läst welche er läuft.

 

finde da bisher nicht wirklich was was mir irgendwie weiterhelfen könnte 🙁

 

 

Share this post


Link to post
Share on other sites

ich habe jetzt eben von einem bekannten ein script zu geschickt bekommen welches aber leider noch nicht so 100% läuft.

 

using UnityEngine;

public class CharacterMoving : MonoBehaviour {

	float speed = 5.0f;

	float gravity = 5.0f;

	float smoothSpeed = 100.0f;
	float smoothDirection = 100.0f;



	private Vector3 moveDirection = Vector3.zero;
	private float verticalSpeed = 0.0f;
	private float moveSpeed = 0.0f;

	private bool  grounded = false;


	private float targetAngle = 0.0f;



	void  Awake (){
		moveDirection = transform.TransformDirection(Vector3.forward);
	}

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

	   
		Vector3 forward = cameraTransform.TransformDirection(Vector3.forward);
		forward.y = 0;
		forward = forward.normalized;

		Vector3 right = Vector3(forward.z, 0, -forward.x);


		Vector3 targetDirection = Input.GetAxis("Horizontal") * right + Input.GetAxis("Vertical") * forward;

	
		if (targetDirection != Vector3.zero)
		{
			moveDirection = Vector3.Lerp(moveDirection, targetDirection, smoothDirection * Time.deltaTime);
			moveDirection = moveDirection.normalized;
		}


		float curSmooth = smoothSpeed * Time.deltaTime;

		if (!grounded)
		{
			curSmooth *= 0.5f;
		}

		moveSpeed = Mathf.Lerp(moveSpeed, targetDirection.magnitude * speed, curSmooth);
	}

	void  Update (){

		UpdateSmoothedMovementDirection();

		if (grounded) {
			verticalSpeed = 0.0f;



		}

		verticalSpeed -= gravity * Time.deltaTime;

		Vector3 movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0);
		movement *= Time.deltaTime;


		CharacterController controller = GetComponent<CharacterController>();
		CollisionFlags flags = controller.Move(movement);


		 
		transform.rotation = Quaternion.LookRotation(moveDirection);

	}

	void  GetSpeed (){
		return moveSpeed;
	}


	void  GetDirection (){
		return moveDirection;
	}
}

 

 

Ich bekomme da noch 4 fehler angezeigt... von vorher 12 ^^°

nur leider verstehe ich nicht genau wie ich diese letzten beheben könnte 🙁

 

ich habe mal ein bild mit den fehlern angehangen.

 

Vielen lieben dank schonmal

 

 

Neue Bitmap.bmp

Share this post


Link to post
Share on other sites

Ich meine das ernst:

vor 2 Stunden schrieb kruemel:

Ich würde dir also empfehlen, einfach mal ein eigenes Script anzufangen. Ist nicht so schwer, wie es sich vielleicht anhört.

Geh einfach mal die Anfängertutorials von Unity Learn durch, vielleicht ein C#- oder ein Unity-Buch. So ein simples CharacterController-Script ist vielleicht 20-30 Zeilen lang.

Share this post


Link to post
Share on other sites

bin ich ja quasi dabei.

 

aber ich finde einfach den fehler in dem script nicht.

Vector3 right = Vector3(forward.z, 0, -forward.x);

die beiden letzten hab ich raus aber oben steh ich etwas auf dem schlauch 🤔

 

das script war vorher in JS und ich habe es zu C# abgeändert...

 

nur leider passt da etwas noch nicht so 100%ig

Share this post


Link to post
Share on other sites

Das Script, in dem du den Fehler suchst, ist aber nicht von dir. Du wühlst dadrin herum, ohne zu wissen, was die einzelnen Teile tun. Das ist halt nicht sonderlich zielführend.

Selbst, wenn du das Script, das du selber von Grund auf schreibst, am Ende wegwirfst, wird dir der Lerneffekt bei der ganzen Sache enorm helfen. Hier hast du ein Template, mit dem du loslegen kannst:

private CharacterController controller;
public float speed = 10f;

private void Awake()
{
  controller = GetComponent<CharacterController>();
}

private void FixedUpdate()
{
  controller.Move(transform.forward * speed * Time.deltaTime);
}

 

Share this post


Link to post
Share on other sites

ich schau mir am liebsten immer zuerst mal scripte an um diese zu verstehen.

 

was eigenes hatte ich danach natürlich schon vor zu schreiben 🙂

 

ich versuche halt immer zuerst die fehler zu verstehen und das tue ich oben leider bei dem einen fehler überhaupt nicht so wirklich.

das komische ist das ich es ja von JS zu C# übersetzt habe und es vorher aber in JS ohne weiteres geklappt hat...

laut internet recherche sollte es aber eigenlich so klappen 😨

 

Danke schonmal für die template.

 

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
Sign in to follow this  

×
×
  • Create New...