Hello there,
I was wondering if anyone could help me, I have got a number of errors that are currently being shown up when saving my c# script. The errors are shown below:
Could anyone please have a look at the coding, shown below, and suggest where I could possibly be going wrong.
Any help will be greatly appreciated!
Can you please provide the complete script it will be helpful for solve the error easily ?
Yes. See below the full code…
In addition to my original post I am getting this error;
Now I’m sure I’ve closed everything off but could anyone suggest why I could be getting this error too?
Thanks.
using UnityEngine;
using System.Collections;
using System;
public class GameSettings : MonoBehaviour {
void Awake()
{
DontDestroyOnLoad(this);
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
public void SaveCharacterData()
{
GameObject pc = GameObject.Find("pc");
PlayerCharacter pcClass = pc.GetComponent<PlayerCharacter>();
PlayerPrefs.SetString("Player Name", pcClass.Name);
for (int cnt = 0; cnt < Enum.GetValues(typeof(AttributeName)).Length; cnt++)
{
PlayerPrefs.SetInt(((AttributeName)cnt).ToString () + " - Base Value", pcClass.GetPrimaryAttribute (cnt).BaseValue);
PlayerPrefs.SetInt (((AttributeName)cnt).ToString () + " - Exp To Level", pcClass.GetPrimaryAttribute (cnt).ExpToLevel);
}
for (int cnt = 0; cnt < Enum.GetValues(typeof(VitalName)).Length; cnt++)
{
PlayerPrefs.SetInt (((VitalName)cnt).ToString () + " - Base Value", pcClass.GetVital (cnt).BaseValue);
PlayerPrefs.SetInt (((VitalName)cnt).ToString () + " - Exp To Level", pcClass.GetVital (cnt).ExpToLevel);
PlayerPrefs.SetInt (((VitalName)cnt).ToString () + " - Current Value", pcClass.GetVital (cnt).CurValue);
PlayerPrefs.SetString (((VitalName)cnt).ToString () + " - Mods", pcClass.GetVital(cnt).GetModifyingAttributesString());
}
for (int cnt = 0; cnt < Enum.GetValues(typeof(SkillName)).Length; cnt++)
{
PlayerPrefs.SetInt (((SkillName)cnt).ToString () + " - Base Value", pcClass.GetSkill (cnt).BaseValue);
PlayerPrefs.SetInt (((SkillName)cnt).ToString () + " - Exp To Level", pcClass.GetSkill (cnt).ExpToLevel);
PlayerPrefs.SetString(((SkillName)cnt).ToString () + " - Mods", pcClass.GetSkill(cnt).GetModifyingAttributesString());
}
}
public void LoadCharacterData()
{
GameObject pc = GameObject.Find ("pc");
PlayerCharacter pcClass = pc.GetComponent<PlayerCharacter> ();
pcClass.Name = PlayerPrefs.GetString ("Player Name", "Name Me");
for (int cnt = 0; cnt < Enum.GetValues(typeof(AttributeName)).Length; cnt++) {
pcClass.GetPrimaryAttribute (cnt).BaseValue = PlayerPrefs.GetInt (((AttributeName)cnt).ToString () + " - Base Value", 0);
pcClass.GetPrimaryAttribute (cnt).ExpToLevel = PlayerPrefs.GetInt (((AttributeName)cnt).ToString () + " - Exp To Level", 0);
}
for (int cnt = 0; cnt < Enum.GetValues(typeof(VitalName)).Length; cnt++)
{
pcClass.GetVital (cnt).BaseValue = PlayerPrefs.GetInt (((VitalName)cnt).ToString () + " - Base Value", 0);
pcClass.GetVital (cnt).ExpToLevel = PlayerPrefs.GetInt (((VitalName)cnt).ToString () + " - Exp To Level", 0);
string myMods = PlayerPrefs.GetString(((VitalName)cnt).ToString() + " - Mods", "");
string[] mods = myMods.Split('|');
foreach(string s in mods)
{
string[] modStats = s.Split('_');
int attribIndex = 0
for(int x = 0; x < Enum.GetValues(typeof(AttributeName)).Length; x++)
{
if (modStats [0] == ((AttributeName)x).ToString ())
{
attribIndex = x;
Debug.Log (modStats[0] + " = " + ((AttributeName)x).ToString());
break;
}
}
pcClass.GetVital ((int)VitalName.Health).AddModifier (new ModifyingAttribute (GetPrimaryAttribute ((int)AttributeName.Constitution), modStats [1]));
}
// pcClass.GetVital (cnt).CurValue = PlayerPrefs.GetInt (((VitalName)cnt).ToString () + " - Current Value", 0);
// PlayerPrefs.SetString (((VitalName)cnt).ToString () + " - Mods", pcClass.GetVital(cnt).GetModifyingAttributesString());
}
}
}
My bad, sorry
Just Add semi-colon 82 line after int attribIndex = 0;
thank you so much 
Can’t believe I missed it haha, thanks everyone for your help!
Yo, I need help and I am new to Unity. What do you do when you get compile errors?
Compiler Errors are showing that somewhere your code is wrong, if you post your code here I’ll take a look at it for you and see if I can work out what’s wrong with it.
Ok, here is the first script!
#pragma strict
#pragma implicit
#pragma downcast
// Does this script currently respond to input?
var canControl : boolean = true;
var useFixedUpdate : boolean = 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
var inputMoveDirection : Vector3 = 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
var inputJump : boolean = false;
class CharacterMotorMovement {
// The maximum horizontal speed when moving
var maxForwardSpeed : float = 10.0;
var maxSidewaysSpeed : float = 10.0;
var maxBackwardsSpeed : float = 10.0;
// Curve for multiplying speed based on slope (negative = downwards)
var slopeSpeedMultiplier : AnimationCurve = AnimationCurve(Keyframe(-90, 1), Keyframe(0, 1), Keyframe(90, 0));
// How fast does the character change speeds? Higher is faster.
var maxGroundAcceleration : float = 30.0;
var maxAirAcceleration : float = 20.0;
// The gravity for the character
var gravity : float = 10.0;
var maxFallSpeed : float = 20.0;
// 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
var collisionFlags : CollisionFlags;
// We will keep track of the character’s current velocity,
@System.NonSerialized
var velocity : Vector3;
// This keeps track of our current velocity while we’re not grounded
@System.NonSerialized
var frameVelocity : Vector3 = Vector3.zero;
@System.NonSerialized
var hitPoint : Vector3 = Vector3.zero;
@System.NonSerialized
var lastHitPoint : Vector3 = Vector3(Mathf.Infinity, 0, 0);
}
var movement : CharacterMotorMovement = CharacterMotorMovement();
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.
}
// We will contain all the jumping related variables in one helper class for clarity.
class CharacterMotorJumping {
// Can the character jump?
var enabled : boolean = true;
// How high do we jump when pressing jump and letting go immediately
var baseHeight : float = 1.0;
// We add extraHeight units (meters) on top when holding the button down longer while jumping
var extraHeight : float = 4.1;
// 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.
var perpAmount : float = 0.0;
// 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.
var steepPerpAmount : float = 0.5;
// 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
var jumping : boolean = false;
@System.NonSerialized
var holdingJumpButton : boolean = false;
// the time we jumped at (Used to determine for how long to apply extra jump power after jumping.)
@System.NonSerialized
var lastStartTime : float = 0.0;
@System.NonSerialized
var lastButtonDownTime : float = -100;
@System.NonSerialized
var jumpDir : Vector3 = Vector3.up;
}
var jumping : CharacterMotorJumping = CharacterMotorJumping();
class CharacterMotorMovingPlatform {
var enabled : boolean = true;
var movementTransfer : MovementTransferOnJump = MovementTransferOnJump.PermaTransfer;
@System.NonSerialized
var hitPlatform : Transform;
@System.NonSerialized
var activePlatform : Transform;
@System.NonSerialized
var activeLocalPoint : Vector3;
@System.NonSerialized
var activeGlobalPoint : Vector3;
@System.NonSerialized
var activeLocalRotation : Quaternion;
@System.NonSerialized
var activeGlobalRotation : Quaternion;
@System.NonSerialized
var lastMatrix : Matrix4x4;
@System.NonSerialized
var platformVelocity : Vector3;
@System.NonSerialized
var newPlatform : boolean;
}
var movingPlatform : CharacterMotorMovingPlatform = CharacterMotorMovingPlatform();
class CharacterMotorSliding {
// Does the character slide on too steep surfaces?
var enabled : boolean = true;
// How fast does the character slide on steep surfaces?
var slidingSpeed : float = 15;
// 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.
var sidewaysControl : float = 1.0;
// 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%.
var speedControl : float = 0.4;
}
var sliding : CharacterMotorSliding = CharacterMotorSliding();
@System.NonSerialized
var grounded : boolean = true;
@System.NonSerialized
var groundNormal : Vector3 = Vector3.zero;
private var lastGroundNormal : Vector3 = Vector3.zero;
private var tr : Transform;
private var controller : CharacterController;
function Awake () {
controller = GetComponent (CharacterController);
tr = transform;
}
private function UpdateFunction () {
// We copy the actual velocity into a temporary variable that we can manipulate.
var velocity : Vector3 = movement.velocity;
// Update velocity based on input
velocity = ApplyInputVelocityChange(velocity);
// Apply gravity and jumping force
velocity = ApplyGravityAndJumping (velocity);
// Moving platform support
var moveDistance : Vector3 = Vector3.zero;
if (MoveWithPlatform()) {
var newGlobalPoint : Vector3 = movingPlatform.activePlatform.TransformPoint(movingPlatform.activeLocalPoint);
moveDistance = (newGlobalPoint - movingPlatform.activeGlobalPoint);
if (moveDistance != Vector3.zero)
controller.Move(moveDistance);
// Support moving platform rotation as well:
var newGlobalRotation : Quaternion = movingPlatform.activePlatform.rotation * movingPlatform.activeLocalRotation;
var rotationDiff : Quaternion = newGlobalRotation * Quaternion.Inverse(movingPlatform.activeGlobalRotation);
var yRotation = rotationDiff.eulerAngles.y;
if (yRotation != 0) {
// Prevent rotation of the local up vector
tr.Rotate(0, yRotation, 0);
}
}
// Save lastPosition for velocity calculation.
var lastPosition : Vector3 = tr.position;
// We always want the movement to be framerate independent. Multiplying by Time.deltaTime does this.
var currentMovementOffset : Vector3 = 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.
var pushDownOffset : float = Mathf.Max(controller.stepOffset, Vector3(currentMovementOffset.x, 0, currentMovementOffset.z).magnitude);
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.
var oldHVelocity : Vector3 = new Vector3(velocity.x, 0, velocity.z);
movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
var newHVelocity : Vector3 = 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 {
var projectedNewVelocity : float = 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 + Vector3.up * (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;
}
}
function FixedUpdate () {
if (movingPlatform.enabled) {
if (movingPlatform.activePlatform != null) {
if (!movingPlatform.newPlatform) {
var lastVelocity : Vector3 = movingPlatform.platformVelocity;
movingPlatform.platformVelocity = (
movingPlatform.activePlatform.localToWorldMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint)
if (useFixedUpdate)
UpdateFunction();
}
function Update () {
if (!useFixedUpdate)
UpdateFunction();
}
private function ApplyInputVelocityChange (velocity : Vector3) {
if (!canControl)
inputMoveDirection = Vector3.zero;
// Find desired velocity
var desiredVelocity : Vector3;
if (grounded TooSteep()) {
// The direction we’re sliding in
desiredVelocity = Vector3(groundNormal.x, 0, groundNormal.z).normalized;
// Find the input movement direction projected onto the sliding direction
var 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
var maxVelocityChange : float = GetMaxAcceleration(grounded) * Time.deltaTime;
var velocityChangeVector : Vector3 = (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 function ApplyGravityAndJumping (velocity : Vector3) {
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;
}
function OnControllerColliderHit (hit : ControllerColliderHit) {
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 function 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) {
var platform : Transform = movingPlatform.activePlatform;
yield WaitForFixedUpdate();
yield WaitForFixedUpdate();
if (grounded platform == movingPlatform.activePlatform)
yield 1;
}
movement.velocity -= movingPlatform.platformVelocity;
}
}
private function MoveWithPlatform () : boolean {
return (
movingPlatform.enabled
(grounded || movingPlatform.movementTransfer == MovementTransferOnJump.PermaLocked)
movingPlatform.activePlatform != null
);
}
private function GetDesiredHorizontalVelocity () {
// Find desired velocity
var desiredLocalDirection : Vector3 = tr.InverseTransformDirection(inputMoveDirection);
var maxSpeed : float = 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 * maxSpeed);
}
private function AdjustGroundVelocityToNormal (hVelocity : Vector3, groundNormal : Vector3) : Vector3 {
var sideways : Vector3 = Vector3.Cross(Vector3.up, hVelocity);
return Vector3.Cross(sideways, groundNormal).normalized * hVelocity.magnitude;
}
private function IsGroundedTest () {
return (groundNormal.y > 0.01);
}
function GetMaxAcceleration (grounded : boolean) : float {
// Maximum acceleration on ground and in air
if (grounded)
return movement.maxGroundAcceleration;
else
return movement.maxAirAcceleration;
}
function CalculateJumpVerticalSpeed (targetJumpHeight : float) {
// 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);
}
function IsJumping () {
return jumping.jumping;
}
function IsSliding () {
return (grounded sliding.enabled TooSteep());
}
function IsTouchingCeiling () {
return (movement.collisionFlags CollisionFlags.CollidedAbove) != 0;
}
function IsGrounded () {
return grounded;
}
function TooSteep () {
return (groundNormal.y <= Mathf.Cos(controller.slopeLimit * Mathf.Deg2Rad));
}
function GetDirection () {
return inputMoveDirection;
}
function SetControllable (controllable : boolean) {
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.
function MaxSpeedInDirection (desiredMovementDirection : Vector3) : float {
if (desiredMovementDirection == Vector3.zero)
return 0;
else {
var zAxisEllipseMultiplier : float = (desiredMovementDirection.z > 0 ? movement.maxForwardSpeed : movement.maxBackwardsSpeed) / movement.maxSidewaysSpeed;
var temp : Vector3 = new Vector3(desiredMovementDirection.x, 0, desiredMovementDirection.z / zAxisEllipseMultiplier).normalized;
var length : float = new Vector3(temp.x, 0, temp.z * zAxisEllipseMultiplier).magnitude * movement.maxSidewaysSpeed;
return length;
}
}
function SetVelocity (velocity : Vector3) {
grounded = false;
movement.velocity = velocity;
movement.frameVelocity = Vector3.zero;
SendMessage(“OnExternalVelocity”);
}
// Require a character controller to be attached to the same game object
@script RequireComponent (CharacterController)
@script AddComponentMenu (“Character/Character Motor”)
And here is the second!
#pragma strict
// Objects to drag in
public var motor : MovementMotor;
public var character : Transform;
public var cursorPrefab : GameObject;
public var joystickPrefab : GameObject;
// Settings
public var cameraSmoothing : float = 0.01;
public var cameraPreview : float = 2.0f;
// Cursor settings
public var cursorPlaneHeight : float = 0;
public var cursorFacingCamera : float = 0;
public var cursorSmallerWithDistance : float = 0;
public var cursorSmallerWhenClose : float = 1;
// Private memeber data
private var mainCamera : Camera;
private var cursorObject : Transform;
private var joystickLeft : Joystick;
private var joystickRight : Joystick;
private var mainCameraTransform : Transform;
private var cameraVelocity : Vector3 = Vector3.zero;
private var cameraOffset : Vector3 = Vector3.zero;
private var initOffsetToPlayer : Vector3;
// Prepare a cursor point varibale. This is the mouse position on PC and controlled by the thumbstick on mobiles.
private var cursorScreenPosition : Vector3;
private var playerMovementPlane : Plane;
private var joystickRightGO : GameObject;
private var screenMovementSpace : Quaternion;
private var screenMovementForward : Vector3;
private var screenMovementRight : Vector3;
function Awake () {
motor.movementDirection = Vector2.zero;
motor.facingDirection = Vector2.zero;
// Set main camera
mainCamera = Camera.main;
mainCameraTransform = mainCamera.transform;
// Ensure we have character set
// Default to using the transform this component is on
if (!character)
character = transform;
initOffsetToPlayer = mainCameraTransform.position - character.position;
#if UNITY_IPHONE || UNITY_ANDROID
if (joystickPrefab) {
// Create left joystick
var joystickLeftGO : GameObject = Instantiate (joystickPrefab) as GameObject;
joystickLeftGO.name = “Joystick Left”;
joystickLeft = joystickLeftGO.GetComponent. ();
// Create right joystick
joystickRightGO = Instantiate (joystickPrefab) as GameObject;
joystickRightGO.name = “Joystick Right”;
joystickRight = joystickRightGO.GetComponent. ();
}
#elif !UNITY_FLASH
if (cursorPrefab) {
cursorObject = (Instantiate (cursorPrefab) as GameObject).transform;
}
#endif
// Save camera offset so we can use it in the first frame
cameraOffset = mainCameraTransform.position - character.position;
// Set the initial cursor position to the center of the screen
cursorScreenPosition = Vector3 (0.5 * Screen.width, 0.5 * Screen.height, 0);
// caching movement plane
playerMovementPlane = new Plane (character.up, character.position + character.up * cursorPlaneHeight);
}
function Start () {
#if UNITY_IPHONE || UNITY_ANDROID
// Move to right side of screen
var guiTex : GUITexture = joystickRightGO.GetComponent. ();
guiTex.pixelInset.x = Screen.width - guiTex.pixelInset.x - guiTex.pixelInset.width;
#endif
// it’s fine to calculate this on Start () as the camera is static in rotation
screenMovementSpace = Quaternion.Euler (0, mainCameraTransform.eulerAngles.y, 0);
screenMovementForward = screenMovementSpace * Vector3.forward;
screenMovementRight = screenMovementSpace * Vector3.right;
}
function OnDisable () {
if (joystickLeft)
joystickLeft.enabled = false;
if (joystickRight)
joystickRight.enabled = false;
}
function OnEnable () {
if (joystickLeft)
joystickLeft.enabled = true;
if (joystickRight)
joystickRight.enabled = true;
}
function Update () {
// HANDLE CHARACTER MOVEMENT DIRECTION
#if UNITY_IPHONE || UNITY_ANDROID
motor.movementDirection = joystickLeft.position.x * screenMovementRight + joystickLeft.position.y * screenMovementForward;
#else
motor.movementDirection = Input.GetAxis (“Horizontal”) * screenMovementRight + Input.GetAxis (“Vertical”) * screenMovementForward;
#endif
// Make sure the direction vector doesn’t exceed a length of 1
// so the character can’t move faster diagonally than horizontally or vertically
if (motor.movementDirection.sqrMagnitude > 1)
motor.movementDirection.Normalize();
// HANDLE CHARACTER FACING DIRECTION AND SCREEN FOCUS POINT
// First update the camera position to take into account how much the character moved since last frame
//mainCameraTransform.position = Vector3.Lerp (mainCameraTransform.position, character.position + cameraOffset, Time.deltaTime * 45.0f * deathSmoothoutMultiplier);
// Set up the movement plane of the character, so screenpositions
// can be converted into world positions on this plane
//playerMovementPlane = new Plane (Vector3.up, character.position + character.up * cursorPlaneHeight);
// optimization (instead of newing Plane):
playerMovementPlane.normal = character.up;
playerMovementPlane.distance = -character.position.y + cursorPlaneHeight;
// used to adjust the camera based on cursor or joystick position
var cameraAdjustmentVector : Vector3 = Vector3.zero;
#if UNITY_IPHONE || UNITY_ANDROID
// On mobiles, use the thumb stick and convert it into screen movement space
motor.facingDirection = joystickRight.position.x * screenMovementRight + joystickRight.position.y * screenMovementForward;
cameraAdjustmentVector = motor.facingDirection;
#else
#if !UNITY_EDITOR (UNITY_XBOX360 || UNITY_PS3)
// On consoles use the analog sticks
var axisX : float = Input.GetAxis(“LookHorizontal”);
var axisY : float = Input.GetAxis(“LookVertical”);
motor.facingDirection = axisX * screenMovementRight + axisY * screenMovementForward;
cameraAdjustmentVector = motor.facingDirection;
#else
// On PC, the cursor point is the mouse position
var cursorScreenPosition : Vector3 = Input.mousePosition;
// Find out where the mouse ray intersects with the movement plane of the player
var cursorWorldPosition : Vector3 = ScreenPointToWorldPointOnPlane (cursorScreenPosition, playerMovementPlane, mainCamera);
var halfWidth : float = Screen.width / 2.0f;
var halfHeight : float = Screen.height / 2.0f;
var maxHalf : float = Mathf.Max (halfWidth, halfHeight);
// Acquire the relative screen position
var posRel : Vector3 = cursorScreenPosition - Vector3 (halfWidth, halfHeight, cursorScreenPosition.z);
posRel.x /= maxHalf;
posRel.y /= maxHalf;
cameraAdjustmentVector = posRel.x * screenMovementRight + posRel.y * screenMovementForward;
cameraAdjustmentVector.y = 0.0;
// The facing direction is the direction from the character to the cursor world position
motor.facingDirection = (cursorWorldPosition - character.position);
motor.facingDirection.y = 0;
// Draw the cursor nicely
HandleCursorAlignment (cursorWorldPosition);
#endif
#endif
// HANDLE CAMERA POSITION
// Set the target position of the camera to point at the focus point
var cameraTargetPosition : Vector3 = character.position + initOffsetToPlayer + cameraAdjustmentVector * cameraPreview;
// Apply some smoothing to the camera movement
mainCameraTransform.position = Vector3.SmoothDamp (mainCameraTransform.position, cameraTargetPosition, cameraVelocity, cameraSmoothing);
// Save camera offset so we can use it in the next frame
cameraOffset = mainCameraTransform.position - character.position;
}
public static function PlaneRayIntersection (plane : Plane, ray : Ray) : Vector3 {
var dist : float;
plane.Raycast (ray, dist);
return ray.GetPoint (dist);
}
public static function ScreenPointToWorldPointOnPlane (screenPoint : Vector3, plane : Plane, camera : Camera) : Vector3 {
// Set up a ray corresponding to the screen position
var ray : Ray = camera.ScreenPointToRay (screenPoint);
// Find out where the ray intersects with the plane
return PlaneRayIntersection (plane, ray);
}
function HandleCursorAlignment (cursorWorldPosition : Vector3) {
if (!cursorObject)
return;
// HANDLE CURSOR POSITION
// Set the position of the cursor object
cursorObject.position = cursorWorldPosition;
#if !UNITY_FLASH
// Hide mouse cursor when within screen area, since we’re showing game cursor instead
Screen.showCursor = (Input.mousePosition.x < 0 || Input.mousePosition.x > Screen.width || Input.mousePosition.y < 0 || Input.mousePosition.y > Screen.height);
#endif
// HANDLE CURSOR ROTATION
var cursorWorldRotation : Quaternion = cursorObject.rotation;
if (motor.facingDirection != Vector3.zero)
cursorWorldRotation = Quaternion.LookRotation (motor.facingDirection);
// Calculate cursor billboard rotation
var cursorScreenspaceDirection : Vector3 = Input.mousePosition - mainCamera.WorldToScreenPoint (transform.position + character.up * cursorPlaneHeight);
cursorScreenspaceDirection.z = 0;
var cursorBillboardRotation : Quaternion = mainCameraTransform.rotation * Quaternion.LookRotation (cursorScreenspaceDirection, -Vector3.forward);
// Set cursor rotation
cursorObject.rotation = Quaternion.Slerp (cursorWorldRotation, cursorBillboardRotation, cursorFacingCamera);
// HANDLE CURSOR SCALING
// The cursor is placed in the world so it gets smaller with perspective.
// Scale it by the inverse of the distance to the camera plane to compensate for that.
var compensatedScale : float = 0.1 * Vector3.Dot (cursorWorldPosition - mainCameraTransform.position, mainCameraTransform.forward);
// Make the cursor smaller when close to character
var cursorScaleMultiplier : float = Mathf.Lerp (0.7, 1.0, Mathf.InverseLerp (0.5, 4.0, motor.facingDirection.magnitude));
// Set the scale of the cursor
cursorObject.localScale = Vector3.one * Mathf.Lerp (compensatedScale, 1, cursorSmallerWithDistance) * cursorScaleMultiplier;
// DEBUG - REMOVE LATER
if (Input.GetKey(KeyCode.O)) cursorFacingCamera += Time.deltaTime * 0.5;
if (Input.GetKey(KeyCode.P)) cursorFacingCamera -= Time.deltaTime * 0.5;
cursorFacingCamera = Mathf.Clamp01(cursorFacingCamera);
if (Input.GetKey(KeyCode.K)) cursorSmallerWithDistance += Time.deltaTime * 0.5;
if (Input.GetKey(KeyCode.L)) cursorSmallerWithDistance -= Time.deltaTime * 0.5;
cursorSmallerWithDistance = Mathf.Clamp01(cursorSmallerWithDistance);
}