diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..2b5a94b Binary files /dev/null and b/.DS_Store differ diff --git a/Assembly-CSharp-firstpass-vs.pidb b/Assembly-CSharp-firstpass-vs.pidb new file mode 100644 index 0000000..5f22f3e Binary files /dev/null and b/Assembly-CSharp-firstpass-vs.pidb differ diff --git a/Assembly-CSharp-firstpass.pidb b/Assembly-CSharp-firstpass.pidb new file mode 100644 index 0000000..3945593 Binary files /dev/null and b/Assembly-CSharp-firstpass.pidb differ diff --git a/Assembly-CSharp-vs.pidb b/Assembly-CSharp-vs.pidb new file mode 100644 index 0000000..cbe4faf Binary files /dev/null and b/Assembly-CSharp-vs.pidb differ diff --git a/Assembly-CSharp.pidb b/Assembly-CSharp.pidb new file mode 100644 index 0000000..0f4e2aa Binary files /dev/null and b/Assembly-CSharp.pidb differ diff --git a/Assembly-UnityScript-firstpass.pidb b/Assembly-UnityScript-firstpass.pidb new file mode 100644 index 0000000..71e5b2a Binary files /dev/null and b/Assembly-UnityScript-firstpass.pidb differ diff --git a/Assets/AnimationExample.unity b/Assets/AnimationExample.unity new file mode 100644 index 0000000..5765a98 Binary files /dev/null and b/Assets/AnimationExample.unity differ diff --git a/Assets/Fonts/8-BIT WONDER.TTF b/Assets/Fonts/8-BIT WONDER.TTF new file mode 100644 index 0000000..6d9b397 Binary files /dev/null and b/Assets/Fonts/8-BIT WONDER.TTF differ diff --git a/Assets/MainMenu.unity b/Assets/MainMenu.unity new file mode 100644 index 0000000..31591e4 Binary files /dev/null and b/Assets/MainMenu.unity differ diff --git a/Assets/Materials/Ground.mat b/Assets/Materials/Ground.mat new file mode 100644 index 0000000..5f21fd9 Binary files /dev/null and b/Assets/Materials/Ground.mat differ diff --git a/Assets/Materials/Player.mat b/Assets/Materials/Player.mat new file mode 100644 index 0000000..c4fac33 Binary files /dev/null and b/Assets/Materials/Player.mat differ diff --git a/Assets/Materials/PlayerSpriteSheet.mat b/Assets/Materials/PlayerSpriteSheet.mat new file mode 100644 index 0000000..3bdea2b Binary files /dev/null and b/Assets/Materials/PlayerSpriteSheet.mat differ diff --git a/Assets/Materials/PlayerSpriteSheet2.mat b/Assets/Materials/PlayerSpriteSheet2.mat new file mode 100644 index 0000000..ffef250 Binary files /dev/null and b/Assets/Materials/PlayerSpriteSheet2.mat differ diff --git a/Assets/Materials/bgTemp.mat b/Assets/Materials/bgTemp.mat new file mode 100644 index 0000000..e3ada6c Binary files /dev/null and b/Assets/Materials/bgTemp.mat differ diff --git a/Assets/Materials/nme.mat b/Assets/Materials/nme.mat new file mode 100644 index 0000000..4198994 Binary files /dev/null and b/Assets/Materials/nme.mat differ diff --git a/Assets/Materials/wormhole.mat b/Assets/Materials/wormhole.mat new file mode 100644 index 0000000..5b9fa18 Binary files /dev/null and b/Assets/Materials/wormhole.mat differ diff --git a/Assets/Prefabs/Background.prefab b/Assets/Prefabs/Background.prefab new file mode 100644 index 0000000..089ff65 Binary files /dev/null and b/Assets/Prefabs/Background.prefab differ diff --git a/Assets/Prefabs/FlyingEnemy.prefab b/Assets/Prefabs/FlyingEnemy.prefab new file mode 100644 index 0000000..b1a6476 Binary files /dev/null and b/Assets/Prefabs/FlyingEnemy.prefab differ diff --git a/Assets/Prefabs/Ground.prefab b/Assets/Prefabs/Ground.prefab new file mode 100644 index 0000000..121812f Binary files /dev/null and b/Assets/Prefabs/Ground.prefab differ diff --git a/Assets/Prefabs/GroundEnemy.prefab b/Assets/Prefabs/GroundEnemy.prefab new file mode 100644 index 0000000..c25a64b Binary files /dev/null and b/Assets/Prefabs/GroundEnemy.prefab differ diff --git a/Assets/Prefabs/Lighting.prefab b/Assets/Prefabs/Lighting.prefab new file mode 100644 index 0000000..d064a9c Binary files /dev/null and b/Assets/Prefabs/Lighting.prefab differ diff --git a/Assets/Prefabs/Main Camera.prefab b/Assets/Prefabs/Main Camera.prefab new file mode 100644 index 0000000..490bbcf Binary files /dev/null and b/Assets/Prefabs/Main Camera.prefab differ diff --git a/Assets/Prefabs/Player.prefab b/Assets/Prefabs/Player.prefab new file mode 100644 index 0000000..115339b Binary files /dev/null and b/Assets/Prefabs/Player.prefab differ diff --git a/Assets/Prefabs/PortalIn.prefab b/Assets/Prefabs/PortalIn.prefab new file mode 100644 index 0000000..c974668 Binary files /dev/null and b/Assets/Prefabs/PortalIn.prefab differ diff --git a/Assets/Prefabs/PortalOut.prefab b/Assets/Prefabs/PortalOut.prefab new file mode 100644 index 0000000..ee92d0a Binary files /dev/null and b/Assets/Prefabs/PortalOut.prefab differ diff --git a/Assets/Prefabs/Powerup.prefab b/Assets/Prefabs/Powerup.prefab new file mode 100644 index 0000000..25772b7 Binary files /dev/null and b/Assets/Prefabs/Powerup.prefab differ diff --git a/Assets/Scripts/Anim2D.cs b/Assets/Scripts/Anim2D.cs new file mode 100644 index 0000000..3282bb7 --- /dev/null +++ b/Assets/Scripts/Anim2D.cs @@ -0,0 +1,137 @@ +using UnityEngine; +using System.Collections; + +public class Anim2D : MonoBehaviour { + + // calculation variables + private Vector3 tempVector; + private Vector3 tempVector2; + private int i; + + // animation variables (variables used for processing aniamtion) + + public float sheetRows = 5; // Total columns in sprite sheet + public float sheetColumns = 4; // Total Rows in sprite sheet + + public float FrameRate = 11f; // how many frames to play per second + + private float frameNum = 1; // the current frame being played, + private string currentAnim; // the ID of the current animation being played + private float currentStart = 0; //Dynamic variable that tells the animation system what the first frame of the current animation is + private float currentEnd = 0; + private bool loopCheck; //Does this animation loop? + private float AnimTime = 0f; // time to pass before playing next animation + private Vector2 sheetPos; // the X, Y position of the frame + private Vector2 sheetOffset; // the offset value of the X, Y coordinate for the texture + + + //This Class allows us to create a bunch of data and store it in this specific container + [System.Serializable] + public class AnimClass + { + public string Name; + public bool looping; + public int anim_Min; + public int anim_Max; + } + + public AnimClass[] Animz; + + + + + // Use this for initialization + void Start () { + + //Telling this controller that Idle is the default animation so that it doesn't throw an error + currentAnim = "Idle"; + } + + + void Update () { + + HandleAnimation(); + KeyCommands(); + + } + + void HandleAnimation () // handles all animation + { + + FindAnimation(currentAnim); + ProcessAnimation(); + + } + + //Here we decide + void FindAnimation (string currentAnim) + { + + for (var i = 0; i < Animz.Length; i++){ + if ( Animz[i].Name == currentAnim){ + + loopCheck = Animz[i].looping; + currentStart = Animz[i].anim_Min; + currentEnd = Animz[i].anim_Max; + + i = Animz.Length; + } + } + } + + //These are dummy key input sensors. You should have a seperate player controller (or AI controller) that declares "currentAnim" to this script + void KeyCommands(){ + if (Input.GetKeyDown(KeyCode.UpArrow)){ + currentAnim = "Idle"; + } + if (Input.GetKeyDown(KeyCode.RightArrow)){ + currentAnim = "Kill"; + } + } + + + void ProcessAnimation () + { + + // AnimTime -= Time.deltaTime; subtract the number + // of seconds passed since the last frame, if the game + // is running at 30 frames per second the variable will + // subtract by 0.033 of a second (1/30) + + AnimTime -= Time.deltaTime; + + if (AnimTime <= 0) + { + frameNum += 1; + // one play animations (play from start to finish) + + frameNum = Mathf.Clamp(frameNum,currentStart,currentEnd+1); + + if ( loopCheck == true){ + if (frameNum > currentEnd){ + frameNum = currentStart; + } + } + + // if the FrameRate is 11, 1/11 is one eleventh of a second, that is the time we are waiting before we + //play the next frame. + + AnimTime += (1/FrameRate); + } + + sheetPos.y = 0; + + // find the number of frames down the animation is and set the y coordinate accordingly + for (i=(int)frameNum; i > 5; i-=5) + { + sheetPos.y += 1; + } + + sheetPos.x = i - 1; // find the X coordinate of the frame to play + sheetOffset = new Vector2(1 - (sheetPos.x/sheetRows),1 -(sheetPos.y/sheetColumns)); // find the X and Y coordinate of the frame to display + + renderer.material.SetTextureOffset ("_MainTex", sheetOffset); // offset the texture to display the correct frame + } + +} + diff --git a/Assets/Scripts/EnemyPhysics.cs b/Assets/Scripts/EnemyPhysics.cs new file mode 100644 index 0000000..06550b3 --- /dev/null +++ b/Assets/Scripts/EnemyPhysics.cs @@ -0,0 +1,148 @@ +using UnityEngine; +using System.Collections; + +[RequireComponent(typeof(BoxCollider))] +public class EnemyPhysics : MonoBehaviour { + + public LayerMask collisionMask; + + private BoxCollider colliderX; + private Vector3 s; + private Vector3 c; + public float EnemySpeed; + public float gravity; + private bool offScreen = false; + private string lastHit; + private float skin = .005f; + private float dirX; + private float dirY; + private float direction = -1; + private Vector3 movement; + + [HideInInspector] + public bool grounded; + [HideInInspector] + public bool movementStopped; + + Ray rayV; + Ray rayD; + Ray rayH; + RaycastHit hit; + + void Start(){ + colliderX = GetComponent(); + s = colliderX.size; + c = colliderX.center; + + } + public void move(Vector2 moveAmt) { + + float deltaY = moveAmt.y *Time.deltaTime; + float deltaX = moveAmt.x; + Vector2 p = transform.position; + + grounded= false; + for (int i = 0; i <3; i++) { + dirY = Mathf.Sign (deltaY); + float x = (p.x + c.x - s.x/2) + s.x/2 * i; + float y = p.y + c.y +s.y/2 * dirY; + + rayV = new Ray(new Vector2(x,y), new Vector2(0,dirY)); + Debug.DrawRay (rayV.origin, rayV.direction); + if (Physics.Raycast (rayV,out hit, Mathf.Abs (deltaY) + skin, collisionMask)) { + + float dst = Vector3.Distance (rayV.origin, hit.point); + + + if (dst > skin) { + deltaY = -dst - skin * dirY; + } + else{ + deltaY = 0; + } + grounded = true; + break; + + } + } + + movementStopped = false; + for (int i = 0; i <3; i++) { + dirX = Mathf.Sign (deltaX); + float x = p.x + c.x + s.x/2 * dirX; + float y = (p.y + c.y - s.y/2) + s.y/2 * i; + + rayH = new Ray(new Vector2(x,y), new Vector2(dirX,0)); + Debug.DrawRay (rayH.origin, rayH.direction); + if (Physics.Raycast (rayH,out hit, Mathf.Abs (deltaX) + skin, collisionMask)) { + + float dst = Vector3.Distance (rayH.origin, hit.point); + + + if (dst > skin) { + deltaX = dst * dirX - skin * dirX; + } + else{ + //deltaX = 0; + } + movementStopped = true; + break; + + } + } + if (!grounded && !movementStopped) { + Vector3 playerDir = new Vector3(deltaX,deltaY); + Vector3 o = new Vector3((p.x + c.x + s.x/2 * dirX),(p.y + c.y +s.y/2 * dirY)); + Debug.DrawRay (o, playerDir.normalized); + rayD = new Ray(o, playerDir.normalized); + if(Physics.Raycast (rayD,Mathf.Sqrt (deltaX*deltaX + deltaY*deltaY),collisionMask)){ + grounded = true; + deltaY = 0; + } + } + + Vector2 finalTransform = new Vector2 (deltaX,deltaY); + if (offScreen){ + transform.Translate (new Vector2 (moveAmt.x, deltaY), Space.World); + } + else{ + transform.Translate(finalTransform, Space.World); + } + + } + + + void OnTriggerEnter(Collider other) { + lastHit = other.tag; + if (lastHit =="Backboard"){Debug.Log (lastHit);} + } + + + void Update () { + + if (lastHit == "Backboard"){ + Invoke ("SelfDestruct", 3); + offScreen= true; + } + else if (movementStopped && !offScreen) { + direction *= -1; + } + else{} + + float amtToMove = EnemySpeed * Time.deltaTime * direction; + + movement.x = amtToMove; + movement.y -= gravity * Time.deltaTime; + + + move (movement); + + if (this.transform.position.y < -6){ + SelfDestruct(); + } + } + + void SelfDestruct(){ + DestroyObject (this.gameObject); + } +} diff --git a/Assets/Scripts/EntryPortal.cs b/Assets/Scripts/EntryPortal.cs new file mode 100644 index 0000000..48336e0 --- /dev/null +++ b/Assets/Scripts/EntryPortal.cs @@ -0,0 +1,14 @@ +using UnityEngine; +using System.Collections; + +public class EntryPortal : MonoBehaviour { + public float rotateSpeed = -3; + private Vector3 rotateZ; + + void Update () { + + rotateZ.z = rotateSpeed; + transform.Rotate(rotateZ, Space.World); + } + +} diff --git a/Assets/Scripts/GameCamera.cs b/Assets/Scripts/GameCamera.cs new file mode 100644 index 0000000..b6bf5bd --- /dev/null +++ b/Assets/Scripts/GameCamera.cs @@ -0,0 +1,56 @@ +using UnityEngine; +using System.Collections; + +public class GameCamera : MonoBehaviour { + + private Transform target; + private float maxX = 0f; + private int buttonWidth = 400; + private int buttonHeight = 100; + private bool buttonShown=false; + public int currentLevel = 0; + public int nextLevel = 0; + public OutPortal exit; + public GUIStyle gStyle; + + + public void setTarget(Transform t) { + target = t; + } + + void OnGUI() { + if (!exit.hitP){ + if(!target){ + Invoke ("showButton", 1.55f); + } + if (buttonShown && !target){ + if (GUI.Button (new Rect(Screen.width /2 - buttonWidth/2, Screen.height /2 - buttonHeight/2, buttonWidth, buttonHeight), "YOU HAVE DIED", gStyle)) { + Application.LoadLevel (currentLevel); + } + } + else{ + buttonShown=false; + } + } + else{ + if (GUI.Button (new Rect(Screen.width /2 - buttonWidth/2, Screen.height /2 - buttonHeight/2, buttonWidth, buttonHeight), "LEVEL COMPLETE", gStyle)) { + Application.LoadLevel (nextLevel); + } + + } + } + + void showButton(){ + buttonShown=true; + } + + void LateUpdate() { + if (target) { + float x = target.position.x; + if (x > maxX) { + transform.position = new Vector3(x,transform.position.y,transform.position.z); + maxX = x; + } + } + } +} diff --git a/Assets/Scripts/GameManager.cs b/Assets/Scripts/GameManager.cs new file mode 100644 index 0000000..5cdc83e --- /dev/null +++ b/Assets/Scripts/GameManager.cs @@ -0,0 +1,28 @@ +using UnityEngine; +using System.Collections; + +public class GameManager : MonoBehaviour { + + public GameObject player; + public GameObject portal; + private GameCamera cam; + + // Use this for initialization + void Start () { + cam = GetComponent(); + SpawnStart (); + + } + + + private void SpawnStart () { + Instantiate (portal, portal.transform.position, portal.transform.rotation); + Invoke ("SpawnPlayer", 1.5f); + + } + + private void SpawnPlayer () { + GameObject merp = (Instantiate (player, player.transform.position,player.transform.rotation) as GameObject); + cam.setTarget (merp.transform); + } +} diff --git a/Assets/Scripts/MainMenu.cs b/Assets/Scripts/MainMenu.cs new file mode 100644 index 0000000..b9ed5f8 --- /dev/null +++ b/Assets/Scripts/MainMenu.cs @@ -0,0 +1,30 @@ +using UnityEngine; +using System.Collections; + +public class MainMenu : MonoBehaviour { + + public Texture backgroundTexture; + //private string instructionText = "Instructions:\nPress Left and Right Arrows to move.\nPress Spacebar to fire."; + private int buttonWidth = 200; + private int buttonHeight = 50; + + // Use this for initialization + void Start () { + + } + + // Update is called once per frame + void Update () { + + } + + void OnGUI() { + + GUI.DrawTexture (new Rect(0,0,Screen.width,Screen.height), backgroundTexture); + //GUI.Label (new Rect(10,10,240,200),instructionText); + if (GUI.Button (new Rect(Screen.width /2 - buttonWidth/2, Screen.height /2 - buttonHeight/2, buttonWidth, buttonHeight), "Start Game")) { + Application.LoadLevel (1); + } + + } +} diff --git a/Assets/Scripts/OutPortal.cs b/Assets/Scripts/OutPortal.cs new file mode 100644 index 0000000..07e78be --- /dev/null +++ b/Assets/Scripts/OutPortal.cs @@ -0,0 +1,52 @@ +using UnityEngine; +using System.Collections; + +public class OutPortal : MonoBehaviour { + public float rotateSpeed; + private Vector3 rotateZ; + public bool hitP = false; + private int counter = 0; + private ParticleSystem particles; + + void Start() { + particles = GetComponent (); + } + + void OnTriggerEnter(Collider other) { + hitP=true; + particles.emissionRate *= 3; + rotateSpeed *= 3; + } + + void Update () { + counter ++; + + if (counter == 50){ counter = 0;} + int colorpick = counter%10; + if (hitP){ + switch (colorpick) { + + case 0: + particles.startColor = new Color(0.9f, 0.3f, 0.3f); + break; + case 1: + particles.startColor = new Color(0.9f, 0.9f, 0.3f); + break; + case 2: + particles.startColor = new Color(0.3f, 0.9f, .3f); + break; + case 3: + particles.startColor = new Color(0.3f, 0.9f, 0.9f); + break; + case 4: + particles.startColor = new Color(0.3f, 0.3f, 0.9f); + break; + case 5: + particles.startColor = new Color(0.9f, 0.3f, 0.9f); + break; + } + } + rotateZ.z = rotateSpeed; + transform.Rotate(rotateZ, Space.World); + } +} \ No newline at end of file diff --git a/Assets/Scripts/PlayerController.cs b/Assets/Scripts/PlayerController.cs new file mode 100644 index 0000000..fe52f62 --- /dev/null +++ b/Assets/Scripts/PlayerController.cs @@ -0,0 +1,67 @@ +using UnityEngine; +using System.Collections; + +[RequireComponent(typeof(PlayerPhysics))] +public class PlayerController : MonoBehaviour { + public float gravity = 20; + public float PlayerSpeed = 6; + //public float acceleration; + public float jumpHeight = 12; + //public GameObject portal; + + [HideInInspector] + public bool pDead = false; + private Vector2 movement; + private float playerHP = 1; + private PlayerPhysics playerPhysics; + + void Start () { + + playerPhysics = GetComponent(); + } + + void OnTriggerEnter(Collider other) { + string derp = other.tag; + + if (derp == "Powerup"){ + playerHP++; + Debug.Log ("Powered up!"); + } + + else if (derp == "EndPortal"){ + DestroyObject (this.gameObject); + Debug.Log ("hit portal"); + } + else if (derp == "Backboard"){} + else{ + playerHP--; + Debug.Log ("phit"); + } + } + void playerDead() { + DestroyObject(this.gameObject); + pDead = true; + print (pDead); + } + void Update () { + float amtToMove = Input.GetAxisRaw ("Horizontal") * PlayerSpeed * Time.deltaTime; + + if(playerPhysics.grounded) { + movement.y = 0; + if(Input.GetButtonDown ("Jump")) { + movement.y = jumpHeight; + } + } + + movement.x = amtToMove; + movement.y -= gravity * Time.deltaTime; + + + playerPhysics.move (movement); + + if (playerHP == 0) { + playerDead (); + } + } + +} diff --git a/Assets/Scripts/PlayerPhysics.cs b/Assets/Scripts/PlayerPhysics.cs new file mode 100644 index 0000000..57ed17e --- /dev/null +++ b/Assets/Scripts/PlayerPhysics.cs @@ -0,0 +1,103 @@ +using UnityEngine; +using System.Collections; + +[RequireComponent(typeof(BoxCollider))] +public class PlayerPhysics : MonoBehaviour { + + public LayerMask collisionMask; + + private BoxCollider colliderX; + private Vector3 s; + private Vector3 c; + + private float skin = .005f; + private float dirX; + private float dirY; + + [HideInInspector] + public bool grounded; + [HideInInspector] + public bool movementStopped; + + Ray rayV; + Ray rayD; + Ray rayH; + RaycastHit hit; + + void Start(){ + colliderX = GetComponent(); + s = new Vector3(1f,1f,1f); + c = colliderX.center; + + } + public void move(Vector2 moveAmt) { + + float deltaY = moveAmt.y *Time.deltaTime; + float deltaX = moveAmt.x; + Vector2 p = transform.position; + + grounded= false; + for (int i = 0; i <3; i++) { + dirY = Mathf.Sign (deltaY); + float x = (p.x + c.x - s.x/2) + s.x/2 * i; + float y = p.y + c.y +s.y/2 * dirY; + + rayV = new Ray(new Vector2(x,y), new Vector2(0,dirY)); + Debug.DrawRay (rayV.origin, rayV.direction); + if (Physics.Raycast (rayV,out hit, Mathf.Abs (deltaY) + skin, collisionMask)) { + + float dst = Vector3.Distance (rayV.origin, hit.point); + + + if (dst > skin) { + deltaY = -dst - skin * dirY; + } + else{ + deltaY = 0; + } + grounded = true; + break; + + } + } + + movementStopped = false; + for (int i = 0; i <3; i++) { + dirX = Mathf.Sign (deltaX); + float x = p.x + c.x + s.x/2 * dirX; + float y = (p.y + c.y - s.y/2) + s.y/2 * i; + + rayH = new Ray(new Vector2(x,y), new Vector2(dirX,0)); + Debug.DrawRay (rayH.origin, rayH.direction); + if (Physics.Raycast (rayH,out hit, Mathf.Abs (deltaX) + skin, collisionMask)) { + + float dst = Vector3.Distance (rayH.origin, hit.point); + + + if (dst > skin) { + deltaX = dst * dirX - skin * dirX; + } + else{ + deltaX = 0; + } + movementStopped = true; + break; + + } + } + if (!grounded && !movementStopped) { + Vector3 playerDir = new Vector3(deltaX,deltaY); + Vector3 o = new Vector3((p.x + c.x + s.x/2 * dirX),(p.y + c.y +s.y/2 * dirY)); + Debug.DrawRay (o, playerDir.normalized); + rayD = new Ray(o, playerDir.normalized); + if(Physics.Raycast (rayD,Mathf.Sqrt (deltaX*deltaX + deltaY*deltaY),collisionMask)){ + grounded = true; + deltaY = 0; + } + } + + Vector2 finalTransform = new Vector2 (deltaX,deltaY); + transform.Translate(finalTransform, Space.World); + + } +} \ No newline at end of file diff --git a/Assets/Scripts/Powerups.cs b/Assets/Scripts/Powerups.cs new file mode 100644 index 0000000..aed2728 --- /dev/null +++ b/Assets/Scripts/Powerups.cs @@ -0,0 +1,11 @@ +using UnityEngine; +using System.Collections; + +public class Powerups : MonoBehaviour { + + void OnTriggerEnter(Collider other) { + if (other.tag=="Player"){ + DestroyObject (this.gameObject); + } + } +} diff --git a/Assets/Scripts/enemyCollide.cs b/Assets/Scripts/enemyCollide.cs new file mode 100644 index 0000000..fbfccdd --- /dev/null +++ b/Assets/Scripts/enemyCollide.cs @@ -0,0 +1,9 @@ +using UnityEngine; +using System.Collections; + +public class enemyCollide : MonoBehaviour { + + void OnTriggerEnter(Collider other) { + Debug.Log ("hit"); + } +} diff --git a/Assets/Standard Assets/Character Controllers/3rd Person Controller.prefab b/Assets/Standard Assets/Character Controllers/3rd Person Controller.prefab new file mode 100644 index 0000000..df7ab5d Binary files /dev/null and b/Assets/Standard Assets/Character Controllers/3rd Person Controller.prefab differ diff --git a/Assets/Standard Assets/Character Controllers/First Person Controller.prefab b/Assets/Standard Assets/Character Controllers/First Person Controller.prefab new file mode 100644 index 0000000..5a34be5 Binary files /dev/null and b/Assets/Standard Assets/Character Controllers/First Person Controller.prefab differ diff --git a/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Constructor.FBX b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Constructor.FBX new file mode 100644 index 0000000..b3ee8f3 Binary files /dev/null and b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Constructor.FBX differ diff --git a/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Materials/constructor_done.mat b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Materials/constructor_done.mat new file mode 100644 index 0000000..9b8dff8 Binary files /dev/null and b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Materials/constructor_done.mat differ diff --git a/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_diffuse.png b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_diffuse.png new file mode 100644 index 0000000..59fef90 Binary files /dev/null and b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_diffuse.png differ diff --git a/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_normals.png b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_normals.png new file mode 100644 index 0000000..b312669 Binary files /dev/null and b/Assets/Standard Assets/Character Controllers/Sources/PrototypeCharacter/Textures/constructor_normals.png differ diff --git a/Assets/Standard Assets/Character Controllers/Sources/Scripts/CharacterMotor.js b/Assets/Standard Assets/Character Controllers/Sources/Scripts/CharacterMotor.js new file mode 100644 index 0000000..7e01c2e --- /dev/null +++ b/Assets/Standard Assets/Character Controllers/Sources/Scripts/CharacterMotor.js @@ -0,0 +1,587 @@ +#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) + - movingPlatform.lastMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint) + ) / Time.deltaTime; + } + movingPlatform.lastMatrix = movingPlatform.activePlatform.localToWorldMatrix; + movingPlatform.newPlatform = false; + } + else { + movingPlatform.platformVelocity = Vector3.zero; + } + } + + 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") diff --git a/Assets/Standard Assets/Character Controllers/Sources/Scripts/FPSInputController.js b/Assets/Standard Assets/Character Controllers/Sources/Scripts/FPSInputController.js new file mode 100644 index 0000000..3b00bff --- /dev/null +++ b/Assets/Standard Assets/Character Controllers/Sources/Scripts/FPSInputController.js @@ -0,0 +1,37 @@ +private var motor : CharacterMotor; + +// Use this for initialization +function Awake () { + motor = GetComponent(CharacterMotor); +} + +// Update is called once per frame +function Update () { + // Get the input vector from kayboard or analog stick + var 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 + var 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 + motor.inputMoveDirection = transform.rotation * directionVector; + motor.inputJump = Input.GetButton("Jump"); +} + +// Require a character controller to be attached to the same game object +@script RequireComponent (CharacterMotor) +@script AddComponentMenu ("Character/FPS Input Controller") diff --git a/Assets/Standard Assets/Character Controllers/Sources/Scripts/MouseLook.cs b/Assets/Standard Assets/Character Controllers/Sources/Scripts/MouseLook.cs new file mode 100644 index 0000000..6374449 --- /dev/null +++ b/Assets/Standard Assets/Character Controllers/Sources/Scripts/MouseLook.cs @@ -0,0 +1,63 @@ +using UnityEngine; +using System.Collections; + +/// MouseLook rotates the transform based on the mouse delta. +/// Minimum and Maximum values can be used to constrain the possible rotation + +/// To make an FPS style character: +/// - Create a capsule. +/// - Add the MouseLook script to the capsule. +/// -> Set the mouse look to use LookX. (You want to only turn character but not tilt it) +/// - Add FPSInputController script to the capsule +/// -> A CharacterMotor and a CharacterController component will be automatically added. + +/// - Create a camera. Make the camera a child of the capsule. Reset it's transform. +/// - Add a MouseLook script to the camera. +/// -> Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.) +[AddComponentMenu("Camera-Control/Mouse Look")] +public class MouseLook : MonoBehaviour { + + public enum RotationAxes { MouseXAndY = 0, MouseX = 1, MouseY = 2 } + public RotationAxes axes = RotationAxes.MouseXAndY; + public float sensitivityX = 15F; + public float sensitivityY = 15F; + + public float minimumX = -360F; + public float maximumX = 360F; + + public float minimumY = -60F; + public float maximumY = 60F; + + float rotationY = 0F; + + void Update () + { + if (axes == RotationAxes.MouseXAndY) + { + float rotationX = transform.localEulerAngles.y + Input.GetAxis("Mouse X") * sensitivityX; + + rotationY += Input.GetAxis("Mouse Y") * sensitivityY; + rotationY = Mathf.Clamp (rotationY, minimumY, maximumY); + + transform.localEulerAngles = new Vector3(-rotationY, rotationX, 0); + } + else if (axes == RotationAxes.MouseX) + { + transform.Rotate(0, Input.GetAxis("Mouse X") * sensitivityX, 0); + } + else + { + rotationY += Input.GetAxis("Mouse Y") * sensitivityY; + rotationY = Mathf.Clamp (rotationY, minimumY, maximumY); + + transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, 0); + } + } + + void Start () + { + // Make the rigid body not change rotation + if (rigidbody) + rigidbody.freezeRotation = true; + } +} \ No newline at end of file diff --git a/Assets/Standard Assets/Character Controllers/Sources/Scripts/PlatformInputController.js b/Assets/Standard Assets/Character Controllers/Sources/Scripts/PlatformInputController.js new file mode 100644 index 0000000..08691f0 --- /dev/null +++ b/Assets/Standard Assets/Character Controllers/Sources/Scripts/PlatformInputController.js @@ -0,0 +1,68 @@ +// This makes the character turn to face the current movement speed per default. +var autoRotate : boolean = true; +var maxRotationSpeed : float = 360; + +private var motor : CharacterMotor; + +// Use this for initialization +function Awake () { + motor = GetComponent(CharacterMotor); +} + +// Update is called once per frame +function Update () { + // Get the input vector from kayboard or analog stick + var directionVector = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), 0); + + 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 + var 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; + } + + // Rotate the input vector into camera space so up is camera's up and right is camera's right + directionVector = Camera.main.transform.rotation * directionVector; + + // Rotate input vector to be perpendicular to character's up vector + var camToCharacterSpace = Quaternion.FromToRotation(-Camera.main.transform.forward, transform.up); + directionVector = (camToCharacterSpace * directionVector); + + // Apply the direction to the CharacterMotor + motor.inputMoveDirection = directionVector; + motor.inputJump = Input.GetButton("Jump"); + + // Set rotation to the move direction + if (autoRotate && directionVector.sqrMagnitude > 0.01) { + var newForward : Vector3 = ConstantSlerp( + transform.forward, + directionVector, + maxRotationSpeed * Time.deltaTime + ); + newForward = ProjectOntoPlane(newForward, transform.up); + transform.rotation = Quaternion.LookRotation(newForward, transform.up); + } +} + +function ProjectOntoPlane (v : Vector3, normal : Vector3) { + return v - Vector3.Project(v, normal); +} + +function ConstantSlerp (from : Vector3, to : Vector3, angle : float) { + var value : float = Mathf.Min(1, angle / Vector3.Angle(from, to)); + return Vector3.Slerp(from, to, value); +} + +// Require a character controller to be attached to the same game object +@script RequireComponent (CharacterMotor) +@script AddComponentMenu ("Character/Platform Input Controller") diff --git a/Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonCamera.js b/Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonCamera.js new file mode 100644 index 0000000..425e7c1 --- /dev/null +++ b/Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonCamera.js @@ -0,0 +1,230 @@ + + +var cameraTransform : Transform; +private var _target : Transform; + +// The distance in the x-z plane to the target + +var distance = 7.0; + +// the height we want the camera to be above the target +var height = 3.0; + +var angularSmoothLag = 0.3; +var angularMaxSpeed = 15.0; + +var heightSmoothLag = 0.3; + +var snapSmoothLag = 0.2; +var snapMaxSpeed = 720.0; + +var clampHeadPositionScreenSpace = 0.75; + +var lockCameraTimeout = 0.2; + +private var headOffset = Vector3.zero; +private var centerOffset = Vector3.zero; + +private var heightVelocity = 0.0; +private var angleVelocity = 0.0; +private var snap = false; +private var controller : ThirdPersonController; +private var targetHeight = 100000.0; + +function Awake () +{ + if(!cameraTransform && Camera.main) + cameraTransform = Camera.main.transform; + if(!cameraTransform) { + Debug.Log("Please assign a camera to the ThirdPersonCamera script."); + enabled = false; + } + + + _target = transform; + if (_target) + { + controller = _target.GetComponent(ThirdPersonController); + } + + if (controller) + { + var characterController : CharacterController = _target.collider; + centerOffset = characterController.bounds.center - _target.position; + headOffset = centerOffset; + headOffset.y = characterController.bounds.max.y - _target.position.y; + } + else + Debug.Log("Please assign a target to the camera that has a ThirdPersonController script attached."); + + + Cut(_target, centerOffset); +} + +function DebugDrawStuff () +{ + Debug.DrawLine(_target.position, _target.position + headOffset); + +} + +function AngleDistance (a : float, b : float) +{ + a = Mathf.Repeat(a, 360); + b = Mathf.Repeat(b, 360); + + return Mathf.Abs(b - a); +} + +function Apply (dummyTarget : Transform, dummyCenter : Vector3) +{ + // Early out if we don't have a target + if (!controller) + return; + + var targetCenter = _target.position + centerOffset; + var targetHead = _target.position + headOffset; + +// DebugDrawStuff(); + + // Calculate the current & target rotation angles + var originalTargetAngle = _target.eulerAngles.y; + var currentAngle = cameraTransform.eulerAngles.y; + + // Adjust real target angle when camera is locked + var targetAngle = originalTargetAngle; + + // When pressing Fire2 (alt) the camera will snap to the target direction real quick. + // It will stop snapping when it reaches the target + if (Input.GetButton("Fire2")) + snap = true; + + if (snap) + { + // We are close to the target, so we can stop snapping now! + if (AngleDistance (currentAngle, originalTargetAngle) < 3.0) + snap = false; + + currentAngle = Mathf.SmoothDampAngle(currentAngle, targetAngle, angleVelocity, snapSmoothLag, snapMaxSpeed); + } + // Normal camera motion + else + { + if (controller.GetLockCameraTimer () < lockCameraTimeout) + { + targetAngle = currentAngle; + } + + // Lock the camera when moving backwards! + // * It is really confusing to do 180 degree spins when turning around. + if (AngleDistance (currentAngle, targetAngle) > 160 && controller.IsMovingBackwards ()) + targetAngle += 180; + + currentAngle = Mathf.SmoothDampAngle(currentAngle, targetAngle, angleVelocity, angularSmoothLag, angularMaxSpeed); + } + + + // When jumping don't move camera upwards but only down! + if (controller.IsJumping ()) + { + // We'd be moving the camera upwards, do that only if it's really high + var newTargetHeight = targetCenter.y + height; + if (newTargetHeight < targetHeight || newTargetHeight - targetHeight > 5) + targetHeight = targetCenter.y + height; + } + // When walking always update the target height + else + { + targetHeight = targetCenter.y + height; + } + + // Damp the height + var currentHeight = cameraTransform.position.y; + currentHeight = Mathf.SmoothDamp (currentHeight, targetHeight, heightVelocity, heightSmoothLag); + + // Convert the angle into a rotation, by which we then reposition the camera + var currentRotation = Quaternion.Euler (0, currentAngle, 0); + + // Set the position of the camera on the x-z plane to: + // distance meters behind the target + cameraTransform.position = targetCenter; + cameraTransform.position += currentRotation * Vector3.back * distance; + + // Set the height of the camera + cameraTransform.position.y = currentHeight; + + // Always look at the target + SetUpRotation(targetCenter, targetHead); +} + +function LateUpdate () { + Apply (transform, Vector3.zero); +} + +function Cut (dummyTarget : Transform, dummyCenter : Vector3) +{ + var oldHeightSmooth = heightSmoothLag; + var oldSnapMaxSpeed = snapMaxSpeed; + var oldSnapSmooth = snapSmoothLag; + + snapMaxSpeed = 10000; + snapSmoothLag = 0.001; + heightSmoothLag = 0.001; + + snap = true; + Apply (transform, Vector3.zero); + + heightSmoothLag = oldHeightSmooth; + snapMaxSpeed = oldSnapMaxSpeed; + snapSmoothLag = oldSnapSmooth; +} + +function SetUpRotation (centerPos : Vector3, headPos : Vector3) +{ + // Now it's getting hairy. The devil is in the details here, the big issue is jumping of course. + // * When jumping up and down we don't want to center the guy in screen space. + // This is important to give a feel for how high you jump and avoiding large camera movements. + // + // * At the same time we dont want him to ever go out of screen and we want all rotations to be totally smooth. + // + // So here is what we will do: + // + // 1. We first find the rotation around the y axis. Thus he is always centered on the y-axis + // 2. When grounded we make him be centered + // 3. When jumping we keep the camera rotation but rotate the camera to get him back into view if his head is above some threshold + // 4. When landing we smoothly interpolate towards centering him on screen + var cameraPos = cameraTransform.position; + var offsetToCenter = centerPos - cameraPos; + + // Generate base rotation only around y-axis + var yRotation = Quaternion.LookRotation(Vector3(offsetToCenter.x, 0, offsetToCenter.z)); + + var relativeOffset = Vector3.forward * distance + Vector3.down * height; + cameraTransform.rotation = yRotation * Quaternion.LookRotation(relativeOffset); + + // Calculate the projected center position and top position in world space + var centerRay = cameraTransform.camera.ViewportPointToRay(Vector3(.5, 0.5, 1)); + var topRay = cameraTransform.camera.ViewportPointToRay(Vector3(.5, clampHeadPositionScreenSpace, 1)); + + var centerRayPos = centerRay.GetPoint(distance); + var topRayPos = topRay.GetPoint(distance); + + var centerToTopAngle = Vector3.Angle(centerRay.direction, topRay.direction); + + var heightToAngle = centerToTopAngle / (centerRayPos.y - topRayPos.y); + + var extraLookAngle = heightToAngle * (centerRayPos.y - centerPos.y); + if (extraLookAngle < centerToTopAngle) + { + extraLookAngle = 0; + } + else + { + extraLookAngle = extraLookAngle - centerToTopAngle; + cameraTransform.rotation *= Quaternion.Euler(-extraLookAngle, 0, 0); + } +} + +function GetCenterOffset () +{ + return centerOffset; +} diff --git a/Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonController.js b/Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonController.js new file mode 100644 index 0000000..219b84d --- /dev/null +++ b/Assets/Standard Assets/Character Controllers/Sources/Scripts/ThirdPersonController.js @@ -0,0 +1,440 @@ + +// Require a character controller to be attached to the same game object +@script RequireComponent(CharacterController) + +public var idleAnimation : AnimationClip; +public var walkAnimation : AnimationClip; +public var runAnimation : AnimationClip; +public var jumpPoseAnimation : AnimationClip; + +public var walkMaxAnimationSpeed : float = 0.75; +public var trotMaxAnimationSpeed : float = 1.0; +public var runMaxAnimationSpeed : float = 1.0; +public var jumpAnimationSpeed : float = 1.15; +public var landAnimationSpeed : float = 1.0; + +private var _animation : Animation; + +enum CharacterState { + Idle = 0, + Walking = 1, + Trotting = 2, + Running = 3, + Jumping = 4, +} + +private var _characterState : CharacterState; + +// The speed when walking +var walkSpeed = 2.0; +// after trotAfterSeconds of walking we trot with trotSpeed +var trotSpeed = 4.0; +// when pressing "Fire3" button (cmd) we start running +var runSpeed = 6.0; + +var inAirControlAcceleration = 3.0; + +// How high do we jump when pressing jump and letting go immediately +var jumpHeight = 0.5; + +// The gravity for the character +var gravity = 20.0; +// The gravity in controlled descent mode +var speedSmoothing = 10.0; +var rotateSpeed = 500.0; +var trotAfterSeconds = 3.0; + +var canJump = true; + +private var jumpRepeatTime = 0.05; +private var jumpTimeout = 0.15; +private var groundedTimeout = 0.25; + +// The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around. +private var lockCameraTimer = 0.0; + +// The current move direction in x-z +private var moveDirection = Vector3.zero; +// The current vertical speed +private var verticalSpeed = 0.0; +// The current x-z move speed +private var moveSpeed = 0.0; + +// The last collision flags returned from controller.Move +private var collisionFlags : CollisionFlags; + +// Are we jumping? (Initiated with jump button and not grounded yet) +private var jumping = false; +private var jumpingReachedApex = false; + +// Are we moving backwards (This locks the camera to not do a 180 degree spin) +private var movingBack = false; +// Is the user pressing any keys? +private var isMoving = false; +// When did the user start walking (Used for going into trot after a while) +private var walkTimeStart = 0.0; +// Last time the jump button was clicked down +private var lastJumpButtonTime = -10.0; +// Last time we performed a jump +private var lastJumpTime = -1.0; + + +// the height we jumped from (Used to determine for how long to apply extra jump power after jumping.) +private var lastJumpStartHeight = 0.0; + + +private var inAirVelocity = Vector3.zero; + +private var lastGroundedTime = 0.0; + + +private var isControllable = true; + +function Awake () +{ + moveDirection = transform.TransformDirection(Vector3.forward); + + _animation = GetComponent(Animation); + if(!_animation) + Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird."); + + /* +public var idleAnimation : AnimationClip; +public var walkAnimation : AnimationClip; +public var runAnimation : AnimationClip; +public var jumpPoseAnimation : AnimationClip; + */ + 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."); + } + +} + + +function UpdateSmoothedMovementDirection () +{ + var cameraTransform = Camera.main.transform; + var grounded = IsGrounded(); + + // Forward vector relative to the camera along the x-z plane + var forward = cameraTransform.TransformDirection(Vector3.forward); + forward.y = 0; + forward = forward.normalized; + + // Right vector relative to the camera + // Always orthogonal to the forward vector + var right = Vector3(forward.z, 0, -forward.x); + + var v = Input.GetAxisRaw("Vertical"); + var h = Input.GetAxisRaw("Horizontal"); + + // Are we moving backwards or looking backwards + if (v < -0.2) + movingBack = true; + else + movingBack = false; + + var wasMoving = isMoving; + isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1; + + // Target direction relative to the camera + var targetDirection = h * right + v * forward; + + // Grounded controls + if (grounded) + { + // Lock camera for short period when transitioning moving & standing still + lockCameraTimer += Time.deltaTime; + if (isMoving != wasMoving) + lockCameraTimer = 0.0; + + // We store speed and direction seperately, + // so that when the character stands still we still have a valid forward direction + // moveDirection is always normalized, and we only update it if there is user input. + if (targetDirection != Vector3.zero) + { + // If we are really slow, just snap to the target direction + if (moveSpeed < walkSpeed * 0.9 && 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 + var curSmooth = speedSmoothing * Time.deltaTime; + + // Choose target speed + //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways + var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0); + + _characterState = CharacterState.Idle; + + // Pick speed modifier + 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.3) + walkTimeStart = Time.time; + } + // In air controls + else + { + // Lock camera while in air + if (jumping) + lockCameraTimer = 0.0; + + if (isMoving) + inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration; + } + + + +} + + +function 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); + } + } +} + + +function ApplyGravity () +{ + if (isControllable) // don't move player at all if not controllable. + { + // Apply gravity + var jumpButton = Input.GetButton("Jump"); + + + // When we reach the apex of the jump we send out a message + if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0) + { + jumpingReachedApex = true; + SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver); + } + + if (IsGrounded ()) + verticalSpeed = 0.0; + else + verticalSpeed -= gravity * Time.deltaTime; + } +} + +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 * gravity); +} + +function DidJump () +{ + jumping = true; + jumpingReachedApex = false; + lastJumpTime = Time.time; + lastJumpStartHeight = transform.position.y; + lastJumpButtonTime = -10; + + _characterState = CharacterState.Jumping; +} + +function Update() { + + if (!isControllable) + { + // kill all inputs if not controllable. + Input.ResetInputAxes(); + } + + 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 + var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity; + movement *= Time.deltaTime; + + // Move the controller + var controller : CharacterController = GetComponent(CharacterController); + collisionFlags = controller.Move(movement); + + // 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(controller.velocity.sqrMagnitude < 0.1) { + _animation.CrossFade(idleAnimation.name); + } + else + { + if(_characterState == CharacterState.Running) { + _animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, runMaxAnimationSpeed); + _animation.CrossFade(runAnimation.name); + } + else if(_characterState == CharacterState.Trotting) { + _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, trotMaxAnimationSpeed); + _animation.CrossFade(walkAnimation.name); + } + else if(_characterState == CharacterState.Walking) { + _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed); + _animation.CrossFade(walkAnimation.name); + } + + } + } + } + // ANIMATION sector + + // Set rotation to the move direction + if (IsGrounded()) + { + + transform.rotation = Quaternion.LookRotation(moveDirection); + + } + else + { + var xzMove = movement; + xzMove.y = 0; + if (xzMove.sqrMagnitude > 0.001) + { + 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); + } + } +} + +function OnControllerColliderHit (hit : ControllerColliderHit ) +{ +// Debug.DrawRay(hit.point, hit.normal); + if (hit.moveDirection.y > 0.01) + return; +} + +function GetSpeed () { + return moveSpeed; +} + +function IsJumping () { + return jumping; +} + +function IsGrounded () { + return (collisionFlags & CollisionFlags.CollidedBelow) != 0; +} + +function GetDirection () { + return moveDirection; +} + +function IsMovingBackwards () { + return movingBack; +} + +function GetLockCameraTimer () +{ + return lockCameraTimer; +} + +function IsMoving () : boolean +{ + return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5; +} + +function HasJumpReachedApex () +{ + return jumpingReachedApex; +} + +function IsGroundedWithTimeout () +{ + return lastGroundedTime + groundedTimeout > Time.time; +} + +function Reset () +{ + gameObject.tag = "Player"; +} + diff --git a/Assets/Standard Assets/Particles/Dust/Dust Storm.prefab b/Assets/Standard Assets/Particles/Dust/Dust Storm.prefab new file mode 100644 index 0000000..08073ff Binary files /dev/null and b/Assets/Standard Assets/Particles/Dust/Dust Storm.prefab differ diff --git a/Assets/Standard Assets/Particles/Fire/Fire1.prefab b/Assets/Standard Assets/Particles/Fire/Fire1.prefab new file mode 100644 index 0000000..3aef138 Binary files /dev/null and b/Assets/Standard Assets/Particles/Fire/Fire1.prefab differ diff --git a/Assets/Standard Assets/Particles/Fire/Flame.prefab b/Assets/Standard Assets/Particles/Fire/Flame.prefab new file mode 100644 index 0000000..2fd12d7 Binary files /dev/null and b/Assets/Standard Assets/Particles/Fire/Flame.prefab differ diff --git a/Assets/Standard Assets/Particles/Legacy Particles/Small explosion.prefab b/Assets/Standard Assets/Particles/Legacy Particles/Small explosion.prefab new file mode 100644 index 0000000..7202532 Binary files /dev/null and b/Assets/Standard Assets/Particles/Legacy Particles/Small explosion.prefab differ diff --git a/Assets/Standard Assets/Particles/Legacy Particles/Sparks.prefab b/Assets/Standard Assets/Particles/Legacy Particles/Sparks.prefab new file mode 100644 index 0000000..f477141 Binary files /dev/null and b/Assets/Standard Assets/Particles/Legacy Particles/Sparks.prefab differ diff --git a/Assets/Standard Assets/Particles/Legacy Particles/TimedObjectDestructor.js b/Assets/Standard Assets/Particles/Legacy Particles/TimedObjectDestructor.js new file mode 100644 index 0000000..ad3bb52 --- /dev/null +++ b/Assets/Standard Assets/Particles/Legacy Particles/TimedObjectDestructor.js @@ -0,0 +1,15 @@ +var timeOut = 1.0; +var detachChildren = false; + +function Awake () +{ + Invoke ("DestroyNow", timeOut); +} + +function DestroyNow () +{ + if (detachChildren) { + transform.DetachChildren (); + } + DestroyObject (gameObject); +} \ No newline at end of file diff --git a/Assets/Standard Assets/Particles/Legacy Particles/explosion.prefab b/Assets/Standard Assets/Particles/Legacy Particles/explosion.prefab new file mode 100644 index 0000000..b8566b2 Binary files /dev/null and b/Assets/Standard Assets/Particles/Legacy Particles/explosion.prefab differ diff --git a/Assets/Standard Assets/Particles/Legacy Particles/large flames.prefab b/Assets/Standard Assets/Particles/Legacy Particles/large flames.prefab new file mode 100644 index 0000000..1cbe330 Binary files /dev/null and b/Assets/Standard Assets/Particles/Legacy Particles/large flames.prefab differ diff --git a/Assets/Standard Assets/Particles/Legacy Particles/small flames.prefab b/Assets/Standard Assets/Particles/Legacy Particles/small flames.prefab new file mode 100644 index 0000000..6160917 Binary files /dev/null and b/Assets/Standard Assets/Particles/Legacy Particles/small flames.prefab differ diff --git a/Assets/Standard Assets/Particles/Misc/Fireworks.prefab b/Assets/Standard Assets/Particles/Misc/Fireworks.prefab new file mode 100644 index 0000000..837c322 Binary files /dev/null and b/Assets/Standard Assets/Particles/Misc/Fireworks.prefab differ diff --git a/Assets/Standard Assets/Particles/Misc/Light Snow.prefab b/Assets/Standard Assets/Particles/Misc/Light Snow.prefab new file mode 100644 index 0000000..ca70496 Binary files /dev/null and b/Assets/Standard Assets/Particles/Misc/Light Snow.prefab differ diff --git a/Assets/Standard Assets/Particles/Misc/Soap Bubbles.prefab b/Assets/Standard Assets/Particles/Misc/Soap Bubbles.prefab new file mode 100644 index 0000000..b9bb956 Binary files /dev/null and b/Assets/Standard Assets/Particles/Misc/Soap Bubbles.prefab differ diff --git a/Assets/Standard Assets/Particles/Misc/Sparks.prefab b/Assets/Standard Assets/Particles/Misc/Sparks.prefab new file mode 100644 index 0000000..5f0c658 Binary files /dev/null and b/Assets/Standard Assets/Particles/Misc/Sparks.prefab differ diff --git a/Assets/Standard Assets/Particles/Smoke/Detailed Smoke.prefab b/Assets/Standard Assets/Particles/Smoke/Detailed Smoke.prefab new file mode 100644 index 0000000..838f42a Binary files /dev/null and b/Assets/Standard Assets/Particles/Smoke/Detailed Smoke.prefab differ diff --git a/Assets/Standard Assets/Particles/Smoke/Fluffy Smoke Large.prefab b/Assets/Standard Assets/Particles/Smoke/Fluffy Smoke Large.prefab new file mode 100644 index 0000000..a1581aa Binary files /dev/null and b/Assets/Standard Assets/Particles/Smoke/Fluffy Smoke Large.prefab differ diff --git a/Assets/Standard Assets/Particles/Smoke/Fluffy Smoke.prefab b/Assets/Standard Assets/Particles/Smoke/Fluffy Smoke.prefab new file mode 100644 index 0000000..da1cd30 Binary files /dev/null and b/Assets/Standard Assets/Particles/Smoke/Fluffy Smoke.prefab differ diff --git a/Assets/Standard Assets/Particles/Smoke/Smoke Trail.prefab b/Assets/Standard Assets/Particles/Smoke/Smoke Trail.prefab new file mode 100644 index 0000000..3766934 Binary files /dev/null and b/Assets/Standard Assets/Particles/Smoke/Smoke Trail.prefab differ diff --git a/Assets/Standard Assets/Particles/Sources/Animations/Light explosion.anim b/Assets/Standard Assets/Particles/Sources/Animations/Light explosion.anim new file mode 100644 index 0000000..82f4866 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Animations/Light explosion.anim differ diff --git a/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting ,5 sec.anim b/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting ,5 sec.anim new file mode 100644 index 0000000..8a7b49b Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting ,5 sec.anim differ diff --git a/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting 1 sec.anim b/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting 1 sec.anim new file mode 100644 index 0000000..5bf1fb7 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting 1 sec.anim differ diff --git a/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting 2 sec.anim b/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting 2 sec.anim new file mode 100644 index 0000000..ca541ad Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Animations/Stop Emitting 2 sec.anim differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Dust Material 1.mat b/Assets/Standard Assets/Particles/Sources/Materials/Dust Material 1.mat new file mode 100644 index 0000000..b2cf8e8 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Dust Material 1.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Fairy Dust.mat b/Assets/Standard Assets/Particles/Sources/Materials/Fairy Dust.mat new file mode 100644 index 0000000..aea13e9 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Fairy Dust.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Fire Add.mat b/Assets/Standard Assets/Particles/Sources/Materials/Fire Add.mat new file mode 100644 index 0000000..4190c83 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Fire Add.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Fire Smoke.mat b/Assets/Standard Assets/Particles/Sources/Materials/Fire Smoke.mat new file mode 100644 index 0000000..4ba68b7 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Fire Smoke.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/FlameA.mat b/Assets/Standard Assets/Particles/Sources/Materials/FlameA.mat new file mode 100644 index 0000000..36819d5 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/FlameA.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/FlameB.mat b/Assets/Standard Assets/Particles/Sources/Materials/FlameB.mat new file mode 100644 index 0000000..00df316 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/FlameB.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/FlameC.mat b/Assets/Standard Assets/Particles/Sources/Materials/FlameC.mat new file mode 100644 index 0000000..62225d0 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/FlameC.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/FlameD.mat b/Assets/Standard Assets/Particles/Sources/Materials/FlameD.mat new file mode 100644 index 0000000..5061524 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/FlameD.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/FlameE.mat b/Assets/Standard Assets/Particles/Sources/Materials/FlameE.mat new file mode 100644 index 0000000..0efa913 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/FlameE.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Poof1.mat b/Assets/Standard Assets/Particles/Sources/Materials/Poof1.mat new file mode 100644 index 0000000..dd17f8c Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Poof1.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Smoke Trail.mat b/Assets/Standard Assets/Particles/Sources/Materials/Smoke Trail.mat new file mode 100644 index 0000000..86fa872 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Smoke Trail.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Smoke.mat b/Assets/Standard Assets/Particles/Sources/Materials/Smoke.mat new file mode 100644 index 0000000..02cfafe Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Smoke.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Smoke1.mat b/Assets/Standard Assets/Particles/Sources/Materials/Smoke1.mat new file mode 100644 index 0000000..22fa88b Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Smoke1.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Smoke2.mat b/Assets/Standard Assets/Particles/Sources/Materials/Smoke2.mat new file mode 100644 index 0000000..564412f Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Smoke2.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Smoke3.mat b/Assets/Standard Assets/Particles/Sources/Materials/Smoke3.mat new file mode 100644 index 0000000..1c89f45 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Smoke3.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Smoke4.mat b/Assets/Standard Assets/Particles/Sources/Materials/Smoke4.mat new file mode 100644 index 0000000..b710382 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Smoke4.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Snowflake.mat b/Assets/Standard Assets/Particles/Sources/Materials/Snowflake.mat new file mode 100644 index 0000000..020843b Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Snowflake.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/SoapBubble.mat b/Assets/Standard Assets/Particles/Sources/Materials/SoapBubble.mat new file mode 100644 index 0000000..3591277 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/SoapBubble.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Spark.mat b/Assets/Standard Assets/Particles/Sources/Materials/Spark.mat new file mode 100644 index 0000000..f484403 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Spark.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Sparkles1.mat b/Assets/Standard Assets/Particles/Sources/Materials/Sparkles1.mat new file mode 100644 index 0000000..d69ddf5 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Sparkles1.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Sparkles2.mat b/Assets/Standard Assets/Particles/Sources/Materials/Sparkles2.mat new file mode 100644 index 0000000..7fbce8d Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Sparkles2.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Water Splash1.mat b/Assets/Standard Assets/Particles/Sources/Materials/Water Splash1.mat new file mode 100644 index 0000000..b1722d5 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Water Splash1.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Materials/Water Splash2.mat b/Assets/Standard Assets/Particles/Sources/Materials/Water Splash2.mat new file mode 100644 index 0000000..6b4dc07 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Materials/Water Splash2.mat differ diff --git a/Assets/Standard Assets/Particles/Sources/Shaders/Particle Alpha Blend (Queue +100).shader b/Assets/Standard Assets/Particles/Sources/Shaders/Particle Alpha Blend (Queue +100).shader new file mode 100644 index 0000000..c0573df --- /dev/null +++ b/Assets/Standard Assets/Particles/Sources/Shaders/Particle Alpha Blend (Queue +100).shader @@ -0,0 +1,87 @@ +Shader "Hidden/Particles/Alpha Blended +100" { +Properties { + _TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5) + _MainTex ("Particle Texture", 2D) = "white" {} +} + +Category { + Tags { "Queue"="Transparent +100" "IgnoreProjector"="True" "RenderType"="Transparent" } + Blend SrcAlpha OneMinusSrcAlpha + AlphaTest Greater .01 + ColorMask RGB + Cull Off Lighting Off ZWrite Off Fog { Color (0,0,0,0) } + BindChannels { + Bind "Color", color + Bind "Vertex", vertex + Bind "TexCoord", texcoord + } + + // ---- Fragment program cards + SubShader { + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma fragmentoption ARB_precision_hint_fastest + #pragma fragmentoption ARB_fog_exp2 + + #include "UnityCG.cginc" + + sampler2D _MainTex; + float4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + float4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : POSITION; + float4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t v) + { + v2f o; + o.vertex = mul(UNITY_MATRIX_MVP, v.vertex); + o.color = v.color; + o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex); + return o; + } + + half4 frag (v2f i) : COLOR + { + return 2.0f * i.color * _TintColor * tex2D(_MainTex, i.texcoord); + } + ENDCG + } + } + + // ---- Dual texture cards + SubShader { + Pass { + SetTexture [_MainTex] { + constantColor [_TintColor] + combine constant * primary + } + SetTexture [_MainTex] { + combine texture * previous DOUBLE + } + } + } + + // ---- Single texture cards (does not do color tint) + SubShader { + Pass { + SetTexture [_MainTex] { + combine texture * primary + } + } + } +} +} diff --git a/Assets/Standard Assets/Particles/Sources/Textures/ColorFlare.png b/Assets/Standard Assets/Particles/Sources/Textures/ColorFlare.png new file mode 100644 index 0000000..5ba39f0 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/ColorFlare.png differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/DustPoof.psd b/Assets/Standard Assets/Particles/Sources/Textures/DustPoof.psd new file mode 100644 index 0000000..4335621 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/DustPoof.psd differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/Fireball.psd b/Assets/Standard Assets/Particles/Sources/Textures/Fireball.psd new file mode 100644 index 0000000..8bc7c79 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/Fireball.psd differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/Snowflake.tif b/Assets/Standard Assets/Particles/Sources/Textures/Snowflake.tif new file mode 100644 index 0000000..81ab8dc Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/Snowflake.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/Star02.png b/Assets/Standard Assets/Particles/Sources/Textures/Star02.png new file mode 100644 index 0000000..8ab98d1 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/Star02.png differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/SteamBlur.png b/Assets/Standard Assets/Particles/Sources/Textures/SteamBlur.png new file mode 100644 index 0000000..e5f1f40 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/SteamBlur.png differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/fairydust.tif b/Assets/Standard Assets/Particles/Sources/Textures/fairydust.tif new file mode 100644 index 0000000..c90fd20 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/fairydust.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/fire3.psd b/Assets/Standard Assets/Particles/Sources/Textures/fire3.psd new file mode 100644 index 0000000..fa81952 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/fire3.psd differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/fire4.psd b/Assets/Standard Assets/Particles/Sources/Textures/fire4.psd new file mode 100644 index 0000000..ba59803 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/fire4.psd differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/flameA.tif b/Assets/Standard Assets/Particles/Sources/Textures/flameA.tif new file mode 100644 index 0000000..b2fbb32 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/flameA.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/flameB.tif b/Assets/Standard Assets/Particles/Sources/Textures/flameB.tif new file mode 100644 index 0000000..7fa15b1 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/flameB.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/flameC.tif b/Assets/Standard Assets/Particles/Sources/Textures/flameC.tif new file mode 100644 index 0000000..11df92a Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/flameC.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/flameD.tif b/Assets/Standard Assets/Particles/Sources/Textures/flameD.tif new file mode 100644 index 0000000..6123969 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/flameD.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/flameE.tif b/Assets/Standard Assets/Particles/Sources/Textures/flameE.tif new file mode 100644 index 0000000..99954a0 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/flameE.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/flametemplate.tif b/Assets/Standard Assets/Particles/Sources/Textures/flametemplate.tif new file mode 100644 index 0000000..cd0c867 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/flametemplate.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/foam.tga b/Assets/Standard Assets/Particles/Sources/Textures/foam.tga new file mode 100644 index 0000000..b481618 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/foam.tga differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/smoke.tif b/Assets/Standard Assets/Particles/Sources/Textures/smoke.tif new file mode 100644 index 0000000..527bfc6 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/smoke.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/smoke2.tif b/Assets/Standard Assets/Particles/Sources/Textures/smoke2.tif new file mode 100644 index 0000000..ad9dc48 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/smoke2.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/smoke3.tif b/Assets/Standard Assets/Particles/Sources/Textures/smoke3.tif new file mode 100644 index 0000000..fa6b99a Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/smoke3.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/smoke4.tif b/Assets/Standard Assets/Particles/Sources/Textures/smoke4.tif new file mode 100644 index 0000000..4ec870d Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/smoke4.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/smokepuff1.psd b/Assets/Standard Assets/Particles/Sources/Textures/smokepuff1.psd new file mode 100644 index 0000000..aeb382d Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/smokepuff1.psd differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/smoketest2.psd b/Assets/Standard Assets/Particles/Sources/Textures/smoketest2.psd new file mode 100644 index 0000000..be7356d Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/smoketest2.psd differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/soapbubble.tif b/Assets/Standard Assets/Particles/Sources/Textures/soapbubble.tif new file mode 100644 index 0000000..5b12714 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/soapbubble.tif differ diff --git a/Assets/Standard Assets/Particles/Sources/Textures/spark.tif b/Assets/Standard Assets/Particles/Sources/Textures/spark.tif new file mode 100644 index 0000000..dfe8c94 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sources/Textures/spark.tif differ diff --git a/Assets/Standard Assets/Particles/Sparkles/Sparkle Rising.prefab b/Assets/Standard Assets/Particles/Sparkles/Sparkle Rising.prefab new file mode 100644 index 0000000..52ca158 Binary files /dev/null and b/Assets/Standard Assets/Particles/Sparkles/Sparkle Rising.prefab differ diff --git a/Assets/Standard Assets/Particles/Water/Water Fountain.prefab b/Assets/Standard Assets/Particles/Water/Water Fountain.prefab new file mode 100644 index 0000000..250c23e Binary files /dev/null and b/Assets/Standard Assets/Particles/Water/Water Fountain.prefab differ diff --git a/Assets/Standard Assets/Particles/Water/Water Surface Splash.prefab b/Assets/Standard Assets/Particles/Water/Water Surface Splash.prefab new file mode 100644 index 0000000..f9b1899 Binary files /dev/null and b/Assets/Standard Assets/Particles/Water/Water Surface Splash.prefab differ diff --git a/Assets/Standard Assets/Particles/Water/WaterFall.prefab b/Assets/Standard Assets/Particles/Water/WaterFall.prefab new file mode 100644 index 0000000..121e992 Binary files /dev/null and b/Assets/Standard Assets/Particles/Water/WaterFall.prefab differ diff --git a/Assets/Standard Assets/Physic Materials/Bouncy.physicmaterial b/Assets/Standard Assets/Physic Materials/Bouncy.physicmaterial new file mode 100644 index 0000000..046c1f7 Binary files /dev/null and b/Assets/Standard Assets/Physic Materials/Bouncy.physicmaterial differ diff --git a/Assets/Standard Assets/Physic Materials/Ice.physicmaterial b/Assets/Standard Assets/Physic Materials/Ice.physicmaterial new file mode 100644 index 0000000..48ee159 Binary files /dev/null and b/Assets/Standard Assets/Physic Materials/Ice.physicmaterial differ diff --git a/Assets/Standard Assets/Physic Materials/Metal.physicmaterial b/Assets/Standard Assets/Physic Materials/Metal.physicmaterial new file mode 100644 index 0000000..c16329d Binary files /dev/null and b/Assets/Standard Assets/Physic Materials/Metal.physicmaterial differ diff --git a/Assets/Standard Assets/Physic Materials/Rubber.physicmaterial b/Assets/Standard Assets/Physic Materials/Rubber.physicmaterial new file mode 100644 index 0000000..ba964a2 Binary files /dev/null and b/Assets/Standard Assets/Physic Materials/Rubber.physicmaterial differ diff --git a/Assets/Standard Assets/Physic Materials/Wood.physicmaterial b/Assets/Standard Assets/Physic Materials/Wood.physicmaterial new file mode 100644 index 0000000..bd63581 Binary files /dev/null and b/Assets/Standard Assets/Physic Materials/Wood.physicmaterial differ diff --git a/Assets/TestLevel.unity b/Assets/TestLevel.unity new file mode 100644 index 0000000..28ee194 Binary files /dev/null and b/Assets/TestLevel.unity differ diff --git a/Assets/TestLevel2.unity b/Assets/TestLevel2.unity new file mode 100644 index 0000000..fe3c631 Binary files /dev/null and b/Assets/TestLevel2.unity differ diff --git a/Assets/Textures/PlayerSpriteSheet.png b/Assets/Textures/PlayerSpriteSheet.png new file mode 100644 index 0000000..789417c Binary files /dev/null and b/Assets/Textures/PlayerSpriteSheet.png differ diff --git a/Assets/Textures/PlayerSpriteSheet2.png b/Assets/Textures/PlayerSpriteSheet2.png new file mode 100644 index 0000000..98eb90d Binary files /dev/null and b/Assets/Textures/PlayerSpriteSheet2.png differ diff --git a/Assets/Textures/TSK.png b/Assets/Textures/TSK.png new file mode 100644 index 0000000..d25c497 Binary files /dev/null and b/Assets/Textures/TSK.png differ diff --git a/Assets/Textures/labTempbg.png b/Assets/Textures/labTempbg.png new file mode 100644 index 0000000..a27b38b Binary files /dev/null and b/Assets/Textures/labTempbg.png differ diff --git a/Assets/Textures/wormhole1.png b/Assets/Textures/wormhole1.png new file mode 100644 index 0000000..7f880d3 Binary files /dev/null and b/Assets/Textures/wormhole1.png differ diff --git a/Platformer-csharp.userprefs b/Platformer-csharp.userprefs new file mode 100644 index 0000000..a312eeb --- /dev/null +++ b/Platformer-csharp.userprefs @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/Platformer.userprefs b/Platformer.userprefs new file mode 100644 index 0000000..eb8c596 --- /dev/null +++ b/Platformer.userprefs @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ProjectSettings/AudioManager.asset b/ProjectSettings/AudioManager.asset new file mode 100644 index 0000000..4a53580 Binary files /dev/null and b/ProjectSettings/AudioManager.asset differ diff --git a/ProjectSettings/DynamicsManager.asset b/ProjectSettings/DynamicsManager.asset new file mode 100644 index 0000000..80501dd Binary files /dev/null and b/ProjectSettings/DynamicsManager.asset differ diff --git a/ProjectSettings/EditorBuildSettings.asset b/ProjectSettings/EditorBuildSettings.asset new file mode 100644 index 0000000..55ced49 Binary files /dev/null and b/ProjectSettings/EditorBuildSettings.asset differ diff --git a/ProjectSettings/EditorSettings.asset b/ProjectSettings/EditorSettings.asset new file mode 100644 index 0000000..e00820f Binary files /dev/null and b/ProjectSettings/EditorSettings.asset differ diff --git a/ProjectSettings/GraphicsSettings.asset b/ProjectSettings/GraphicsSettings.asset new file mode 100644 index 0000000..dee8929 Binary files /dev/null and b/ProjectSettings/GraphicsSettings.asset differ diff --git a/ProjectSettings/InputManager.asset b/ProjectSettings/InputManager.asset new file mode 100644 index 0000000..0cfe188 Binary files /dev/null and b/ProjectSettings/InputManager.asset differ diff --git a/ProjectSettings/NavMeshLayers.asset b/ProjectSettings/NavMeshLayers.asset new file mode 100644 index 0000000..3d80127 Binary files /dev/null and b/ProjectSettings/NavMeshLayers.asset differ diff --git a/ProjectSettings/NetworkManager.asset b/ProjectSettings/NetworkManager.asset new file mode 100644 index 0000000..23be143 Binary files /dev/null and b/ProjectSettings/NetworkManager.asset differ diff --git a/ProjectSettings/ProjectSettings.asset b/ProjectSettings/ProjectSettings.asset new file mode 100644 index 0000000..a886494 Binary files /dev/null and b/ProjectSettings/ProjectSettings.asset differ diff --git a/ProjectSettings/QualitySettings.asset b/ProjectSettings/QualitySettings.asset new file mode 100644 index 0000000..a0f5b52 Binary files /dev/null and b/ProjectSettings/QualitySettings.asset differ diff --git a/ProjectSettings/TagManager.asset b/ProjectSettings/TagManager.asset new file mode 100644 index 0000000..9f1bf43 Binary files /dev/null and b/ProjectSettings/TagManager.asset differ diff --git a/ProjectSettings/TimeManager.asset b/ProjectSettings/TimeManager.asset new file mode 100644 index 0000000..6560090 Binary files /dev/null and b/ProjectSettings/TimeManager.asset differ