save position in game

Hi,

I am coding a video game with Unity 3D


I want to save my player's positon , because I want my player to start the game where he stops ,when he close and open the game
There is my code:

Code (csharp):

1.  
2. // Require a character controller to be attached to the same game object
3. @script RequireComponent(CharacterController)
4.  
5. public var idleAnimation : AnimationClip;
6. public var walkAnimation : AnimationClip;
7. public var runAnimation : AnimationClip;
8. public var jumpPoseAnimation : AnimationClip;
9.  
10. public var walkMaxAnimationSpeed : float = 0.75;
11. public var trotMaxAnimationSpeed : float = 1.0;
12. public var runMaxAnimationSpeed : float = 1.0;
13. public var jumpAnimationSpeed : float = 1.15;
14. public var landAnimationSpeed : float = 1.0;
15.  
16. private var _animation : Animation;
17.  
18. enum CharacterState {
19.     Idle = 0,
20.     Walking = 1,
21.     Trotting = 2,
22.     Running = 3,
23.     Jumping = 4,
24. }
25.  
26. private var _characterState : CharacterState;
27.  
28. // The speed when walking
29. var walkSpeed = 2.0;
30. // after trotAfterSeconds of walking we trot with trotSpeed
31. var trotSpeed = 4.0;
32. // when pressing "Fire3" button (cmd) we start running
33. var runSpeed = 6.0;
34.  
35. var inAirControlAcceleration = 3.0;
36.  
37. // How high do we jump when pressing jump and letting go immediately
38. var jumpHeight = 0.5;
39.  
40. // The gravity for the character
41. var gravity = 20.0;
42. // The gravity in controlled descent mode
43. var speedSmoothing = 10.0;
44. var rotateSpeed = 500.0;
45. var trotAfterSeconds = 3.0;
46.  
47. var canJump = true;
48.  
49. private var jumpRepeatTime = 0.05;
50. private var jumpTimeout = 0.15;
51. private var groundedTimeout = 0.25;
52.  
53. // The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
54. private var lockCameraTimer = 0.0;
55.  
56. // The current move direction in x-z
57. private var moveDirection = Vector3.zero;
58. // The current vertical speed
59. private var verticalSpeed = 0.0;
60. // The current x-z move speed
61. private var moveSpeed = 0.0;
62.  
63. // The last collision flags returned from controller.Move
64. private var collisionFlags : CollisionFlags;
65.  
66. // Are we jumping? (Initiated with jump button and not grounded yet)
67. private var jumping = false;
68. private var jumpingReachedApex = false;
69.  
70. // Are we moving backwards (This locks the camera to not do a 180 degree spin)
71. private var movingBack = false;
72. // Is the user pressing any keys?
73. private var isMoving = false;
74. // When did the user start walking (Used for going into trot after a while)
75. private var walkTimeStart = 0.0;
76. // Last time the jump button was clicked down
77. private var lastJumpButtonTime = -10.0;
78. // Last time we performed a jump
79. private var lastJumpTime = -1.0;
80.  
81.  
82. // the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
83. private var lastJumpStartHeight = 0.0;
84.  
85.  
86. private var inAirVelocity = Vector3.zero;
87.  
88. private var lastGroundedTime = 0.0;
89.  
90.  
91. private var isControllable = true;
92.  
93. function Awake ()
94. {
95.     moveDirection = transform.TransformDirection(Vector3.forward);
96.    
97.     _animation = GetComponent(Animation);
98.     if(!_animation)
99.         Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");
100.    
101.     /*
102. public var idleAnimation : AnimationClip;
103. public var walkAnimation : AnimationClip;
104. public var runAnimation : AnimationClip;
105. public var jumpPoseAnimation : AnimationClip;  
106.     */
107.     if(!idleAnimation) {
108.         _animation = null;
109.         Debug.Log("No idle animation found. Turning off animations.");
110.     }
111.     if(!walkAnimation) {
112.         _animation = null;
113.         Debug.Log("No walk animation found. Turning off animations.");
114.     }
115.     if(!runAnimation) {
116.         _animation = null;
117.         Debug.Log("No run animation found. Turning off animations.");
118.     }
119.     if(!jumpPoseAnimation  canJump) {
120.         _animation = null;
121.         Debug.Log("No jump animation found and the character has canJump enabled. Turning off animations.");
122.     }
123.            
124. }
125.  
126.  
127. function UpdateSmoothedMovementDirection ()
128. {
129.     var cameraTransform = Camera.main.transform;
130.     var grounded = IsGrounded();
131.    
132.     // Forward vector relative to the camera along the x-z plane   
133.     var forward = cameraTransform.TransformDirection(Vector3.forward);
134.     forward.y = 0;
135.     forward = forward.normalized;
136.  
137.     // Right vector relative to the camera
138.     // Always orthogonal to the forward vector
139.     var right = Vector3(forward.z, 0, -forward.x);
140.  
141.     var v = Input.GetAxisRaw("Vertical");
142.     var h = Input.GetAxisRaw("Horizontal");
143.  
144.     // Are we moving backwards or looking backwards
145.     if (v < -0.2)
146.         movingBack = true;
147.     else
148.         movingBack = false;
149.    
150.     var wasMoving = isMoving;
151.     isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;
152.        
153.     // Target direction relative to the camera
154.     var targetDirection = h * right + v * forward;
155.    
156.     // Grounded controls
157.     if (grounded)
158.     {
159.         // Lock camera for short period when transitioning moving  standing still
160.         lockCameraTimer += Time.deltaTime;
161.         if (isMoving != wasMoving)
162.             lockCameraTimer = 0.0;
163.  
164.         // We store speed and direction seperately,
165.         // so that when the character stands still we still have a valid forward direction
166.         // moveDirection is always normalized, and we only update it if there is user input.
167.         if (targetDirection != Vector3.zero)
168.         {
169.             // If we are really slow, just snap to the target direction
170.             if (moveSpeed < walkSpeed * 0.9  grounded)
171.             {
172.                 moveDirection = targetDirection.normalized;
173.             }
174.             // Otherwise smoothly turn towards it
175.             else
176.             {
177.                 moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
178.                
179.                 moveDirection = moveDirection.normalized;
180.             }
181.         }
182.        
183.         // Smooth the speed based on the current target direction
184.         var curSmooth = speedSmoothing * Time.deltaTime;
185.        
186.         // Choose target speed
187.         //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
188.         var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);
189.    
190.         _characterState = CharacterState.Idle;
191.        
192.         // Pick speed modifier
193.         if (Input.GetKey (KeyCode.LeftShift) || Input.GetKey (KeyCode.RightShift))
194.         {
195.             targetSpeed *= runSpeed;
196.             _characterState = CharacterState.Running;
197.         }
198.         else if (Time.time - trotAfterSeconds > walkTimeStart)
199.         {
200.             targetSpeed *= trotSpeed;
201.             _characterState = CharacterState.Trotting;
202.         }
203.         else
204.         {
205.             targetSpeed *= walkSpeed;
206.             _characterState = CharacterState.Walking;
207.         }
208.        
209.         moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);
210.        
211.         // Reset walk time start when we slow down
212.         if (moveSpeed < walkSpeed * 0.3)
213.             walkTimeStart = Time.time;
214.     }
215.     // In air controls
216.     else
217.     {
218.         // Lock camera while in air
219.         if (jumping)
220.             lockCameraTimer = 0.0;
221.  
222.         if (isMoving)
223.             inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
224.     }
225.    
226.  
227.        
228. }
229.  
230.  
231. function ApplyJumping ()
232. {
233.     // Prevent jumping too fast after each other
234.     if (lastJumpTime + jumpRepeatTime > Time.time)
235.         return;
236.  
237.     if (IsGrounded()) {
238.         // Jump
239.         // - Only when pressing the button down
240.         // - With a timeout so you can press the button slightly before landing    
241.         if (canJump  Time.time < lastJumpButtonTime + jumpTimeout) {
242.             verticalSpeed = CalculateJumpVerticalSpeed (jumpHeight);
243.             SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
244.         }
245.     }
246. }
247.  
248.  
249. function ApplyGravity ()
250. {
251.     if (isControllable) // don't move player at all if not controllable.
252.     {
253.         // Apply gravity
254.         var jumpButton = Input.GetButton("Jump");
255.        
256.        
257.         // When we reach the apex of the jump we send out a message
258.         if (jumping  !jumpingReachedApex  verticalSpeed <= 0.0)
259.         {
260.             jumpingReachedApex = true;
261.             SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
262.         }
263.    
264.         if (IsGrounded ())
265.             verticalSpeed = 0.0;
266.         else
267.             verticalSpeed -= gravity * Time.deltaTime;
268.     }
269. }
270.  
271. function CalculateJumpVerticalSpeed (targetJumpHeight : float)
272. {
273.     // From the jump height and gravity we deduce the upwards speed
274.     // for the character to reach at the apex.
275.     return Mathf.Sqrt(2 * targetJumpHeight * gravity);
276. }
277.  
278. function DidJump ()
279. {
280.     jumping = true;
281.     jumpingReachedApex = false;
282.     lastJumpTime = Time.time;
283.     lastJumpStartHeight = transform.position.y;
284.     lastJumpButtonTime = -10;
285.    
286.     _characterState = CharacterState.Jumping;
287. }
288.  
289. function Update() {
290.    
291.     if (!isControllable)
292.     {
293.         // kill all inputs if not controllable.
294.         Input.ResetInputAxes();
295.     }
296.  
297.     if (Input.GetButtonDown ("Jump"))
298.     {
299.         lastJumpButtonTime = Time.time;
300.     }
301.  
302.     UpdateSmoothedMovementDirection();
303.    
304.     // Apply gravity
305.     // - extra power jump modifies gravity
306.     // - controlledDescent mode modifies gravity
307.     ApplyGravity ();
308.  
309.     // Apply jumping logic
310.     ApplyJumping ();
311.    
312.     // Calculate actual motion
313.     var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity;
314.     movement *= Time.deltaTime;
315.    
316.     // Move the controller
317.     var controller : CharacterController = GetComponent(CharacterController);
318.     collisionFlags = controller.Move(movement);
319.    
320.     // ANIMATION sector
321.     if(_animation) {
322.         if(_characterState == CharacterState.Jumping)
323.         {
324.             if(!jumpingReachedApex) {
325.                 _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
326.                 _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
327.                 _animation.CrossFade(jumpPoseAnimation.name);
328.             } else {
329.                 _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
330.                 _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
331.                 _animation.CrossFade(jumpPoseAnimation.name);              
332.             }
333.         }
334.         else
335.         {
336.             if(controller.velocity.sqrMagnitude < 0.1) {
337.                 _animation.CrossFade("stand");
338.             }
339.             else
340.             {
341.                 if(_characterState == CharacterState.Running) {
342.                     _animation["move"].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);
343.                     _animation.CrossFade("move");  
344.                 }
345.                 else if(_characterState == CharacterState.Trotting) {
346.                     _animation["move"].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, trotMaxAnimationSpeed);
347.                     _animation.CrossFade("move");  
348.                 }
349.                 else if(_characterState == CharacterState.Walking) {
350.                     _animation["move"].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed);
351.                     _animation.CrossFade("move");  
352.                 }
353.                
354.             }
355.         }
356.     }
357.     // ANIMATION sector
358.    
359.     // Set rotation to the move direction
360.     if (IsGrounded())
361.     {
362.        
363.         transform.rotation = Quaternion.LookRotation(moveDirection);
364.            
365.     }  
366.     else
367.     {
368.         var xzMove = movement;
369.         xzMove.y = 0;
370.         if (xzMove.sqrMagnitude > 0.001)
371.         {
372.             transform.rotation = Quaternion.LookRotation(xzMove);
373.         }
374.     }  
375.    
376.     // We are in jump mode but just became grounded
377.     if (IsGrounded())
378.     {
379.         lastGroundedTime = Time.time;
380.         inAirVelocity = Vector3.zero;
381.         if (jumping)
382.         {
383.             jumping = false;
384.             SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
385.         }
386.     }
387. }
388.  
389. function OnControllerColliderHit (hit : ControllerColliderHit )
390. {
391. //  Debug.DrawRay(hit.point, hit.normal);
392.     if (hit.moveDirection.y > 0.01)
393.         return;
394. }
395.  
396. function GetSpeed () {
397.     return moveSpeed;
398. }
399.  
400. function IsJumping () {
401.     return jumping;
402. }
403.  
404. function IsGrounded () {
405.     return (collisionFlags  CollisionFlags.CollidedBelow) != 0;
406. }
407.  
408. function GetDirection () {
409.     return moveDirection;
410. }
411.  
412. function IsMovingBackwards () {
413.     return movingBack;
414. }
415.  
416. function GetLockCameraTimer ()
417. {
418.     return lockCameraTimer;
419. }
420.  
421. function IsMoving ()  : boolean
422. {
423.     return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5;
424. }
425.  
426. function HasJumpReachedApex ()
427. {
428.     return jumpingReachedApex;
429. }
430.  
431. function IsGroundedWithTimeout ()
432. {
433.     return lastGroundedTime + groundedTimeout > Time.time;
434. }
435.  
436. function Reset ()
437. {
438.     gameObject.tag = "Player";
439. }
440.  
441.  

Thanks in advance

 

Code (csharp):

1.  
2. function onQuit(){
3. ///save player pos
4. Vector3 playerPos = player.position;
5. PlayerPrefs.SetFloat("playerXPos", playerPos.x);
6. PlayerPrefs.SetFloat("playerYPos", playerPos.y);
7. PlayerPrefs.SetFloat("playerZPos", playerPos.z);
8. }
9.  

Then use PlayerPrefs.GetFloat() to get the saved value on sStart().

 

Thanks I will try