using UnityEngine;
/// <summary>
/// 摄像机跟随玩家
/// </summary>
public class CameraFollow : MonoBehaviour
{
/// <summary>
/// 目标
/// </summary>
public Transform target;
/// <summary>
/// 和目标之间的偏移
/// </summary>
);
/// <summary>
/// 是否锁定旋转
/// </summary>
public bool lockRotation;
/// <summary>
/// 跟随速度
/// </summary>
;
/// <summary>
/// 围绕目标旋转的速度
/// </summary>
;
/// <summary>
/// 是否可以由鼠标控制旋转(只有在相机没有被固定的情况下)
/// </summary>
public bool mouseFreelook;
/// <summary>
/// 旋转阻尼
/// </summary>
;
/// <summary>
/// 摄像机在水中时的过滤物体
/// </summary>
public GameObject waterFilter;
/// <summary>
///
/// </summary>
public string[] avoidClippingTags;
/// <summary>
/// Camera Target
/// </summary>
private Transform followTarget;
/// <summary>
/// 暂未用到
/// </summary>
private bool camColliding;
//setup objects
void Awake()
{
//创建跟随物体(Camera Target)
followTarget = new GameObject().transform;
followTarget.name = "Camera Target";
if(waterFilter)
waterFilter.GetComponent<Renderer>().enabled = false;
if(!target)
Debug.LogError("'CameraFollow script' has no target assigned to it", transform);
//如果用鼠标控制旋转,旋转阻尼为0
if(mouseFreelook)
rotateDamping = 0f;
}
void Update()
{
//没有目标不处理
if (!target)
return;
//平滑跟随
SmoothFollow ();
//平滑朝向玩家
)
SmoothLookAt();
//直接朝向玩家
else
transform.LookAt(target.position);
}
void OnTriggerEnter(Collider other)
{
//打开水遮罩
if (other.tag == "Water" && waterFilter)
waterFilter.GetComponent<Renderer>().enabled = true;
}
void OnTriggerExit(Collider other)
{
//关闭水遮罩
if (other.tag == "Water" && waterFilter)
waterFilter.GetComponent<Renderer>().enabled = false;
}
/// <summary>
/// 平滑朝向目标
/// </summary>
void SmoothLookAt()
{
Quaternion rotation = Quaternion.LookRotation (target.position - transform.position);
transform.rotation = Quaternion.Slerp (transform.rotation, rotation, rotateDamping * Time.deltaTime);
}
/// <summary>
/// 平滑跟随目标
/// </summary>
void SmoothFollow()
{
followTarget.position = target.position;
followTarget.Translate(targetOffset, Space.Self);
if (lockRotation)
followTarget.rotation = target.rotation;
//鼠标控制围绕目标旋转
if(mouseFreelook)
{
float axisX = Input.GetAxis ("Mouse X") * inputRotationSpeed * Time.deltaTime;
followTarget.RotateAround (target.position,Vector3.up, axisX);
float axisY = Input.GetAxis ("Mouse Y") * inputRotationSpeed * Time.deltaTime;
followTarget.RotateAround (target.position, transform.right, -axisY);
}
//键盘控制围绕目标旋转
else
{
float axis = Input.GetAxis ("CamHorizontal") * inputRotationSpeed * Time.deltaTime;
followTarget.RotateAround (target.position, Vector3.up, axis);
}
//计算相机的下一帧位置
Vector3 nextFramePosition = Vector3.Lerp(transform.position, followTarget.position, followSpeed * Time.deltaTime);
Vector3 direction = nextFramePosition - target.position;
//射线检测这个位置
RaycastHit hit;
if(Physics.Raycast (target.position, direction, out hit, direction.magnitude + 0.3f))
{
transform.position = nextFramePosition;
foreach(string tag in avoidClippingTags)
//如果这个位置有物体,修改相机位置
if(hit.transform.tag == tag)
transform.position = hit.point - direction.normalized * 0.3f;
}
else
{
//直接修改相机位置
transform.position = nextFramePosition;
}
}
}CameraFollow
using UnityEngine;
/// <summary>
/// 角色移动
/// </summary>
[RequireComponent(typeof(Rigidbody))]
public class CharacterMotor:MonoBehaviour {
/// <summary>
/// 是否冻结z轴的移动
/// </summary>
public bool sidescroller;
/// <summary>
/// 当前速度
/// </summary>
[HideInInspector]
public Vector3 currentSpeed;
/// <summary>
/// 到目标的距离
/// </summary>
[HideInInspector]
public float DistanceToTarget;
/// <summary>
/// 刚体
/// </summary>
private Rigidbody rigid;
void Awake() {
//设置rigidbody
rigid = GetComponent<Rigidbody>();
rigid.interpolation = RigidbodyInterpolation.Interpolate;
if(sidescroller)
rigid.constraints = RigidbodyConstraints.FreezeRotation | RigidbodyConstraints.FreezePositionZ;
else
rigid.constraints = RigidbodyConstraints.FreezeRotation;
//添加光滑的物理材质
if(GetComponent<Collider>().material.name == "Default (Instance)") {
PhysicMaterial pMat = new PhysicMaterial();
pMat.name = "Frictionless";
pMat.frictionCombine = PhysicMaterialCombine.Multiply;
pMat.bounceCombine = PhysicMaterialCombine.Multiply;
pMat.dynamicFriction = 0f;
pMat.staticFriction = 0f;
GetComponent<Collider>().material = pMat;
Debug.LogWarning("No physics material found for CharacterMotor, a frictionless one has been created and assigned",transform);
}
}
/// <summary>
/// 移动刚体到指定位置
/// </summary>
public bool MoveTo(Vector3 destination,float acceleration,float stopDistance,bool ignoreY) {
Vector3 relativePos = (destination - transform.position);
//忽略y轴?
if(ignoreY)
relativePos.y = ;
DistanceToTarget = relativePos.magnitude;
if(DistanceToTarget <= stopDistance)
return true;
else
rigid.AddForce(relativePos.normalized * acceleration * Time.deltaTime,ForceMode.VelocityChange);
return false;
}
/// <summary>
/// 旋转刚体朝向当前速度
/// </summary>
public void RotateToVelocity(float turnSpeed,bool ignoreY) {
Vector3 dir;
if(ignoreY)
dir = new Vector3(rigid.velocity.x,0f,rigid.velocity.z);
else
dir = rigid.velocity;
if(dir.magnitude > 0.1) {
Quaternion dirQ = Quaternion.LookRotation(dir);
Quaternion slerp = Quaternion.Slerp(transform.rotation,dirQ,dir.magnitude * turnSpeed * Time.deltaTime);
rigid.MoveRotation(slerp);
}
}
/// <summary>
/// 旋转刚体朝向指定方向
/// </summary>
public void RotateToDirection(Vector3 lookDir,float turnSpeed,bool ignoreY) {
Vector3 characterPos = transform.position;
//忽略y轴?
if(ignoreY) {
characterPos.y = ;
lookDir.y = ;
}
Vector3 newDir = lookDir - characterPos;
Quaternion dirQ = Quaternion.LookRotation(newDir);
Quaternion slerp = Quaternion.Slerp(transform.rotation,dirQ,turnSpeed * Time.deltaTime);
rigid.MoveRotation(slerp);
}
/// <summary>
/// 管理速度
/// </summary>
public void ManageSpeed(float deceleration,float maxSpeed,bool ignoreY) {
currentSpeed = rigid.velocity;
//忽略y轴
if(ignoreY)
currentSpeed.y = ;
) {
rigid.AddForce((currentSpeed * -) * deceleration * Time.deltaTime,ForceMode.VelocityChange);
if(rigid.velocity.magnitude > maxSpeed)
rigid.AddForce((currentSpeed * -) * deceleration * Time.deltaTime,ForceMode.VelocityChange);
}
}
}CharacterMotor
using UnityEngine;
/// <summary>
/// 检查点
/// </summary>
[RequireComponent(typeof(CapsuleCollider))]
[RequireComponent(typeof(AudioSource))]
public class Checkpoint : MonoBehaviour
{
/// <summary>
/// 激活颜色
/// </summary>
public Color activeColor = Color.green;
/// <summary>
/// 激活时的不透明度
/// </summary>
public float activeColorOpacity = 0.4f;
/// <summary>
/// 生命
/// </summary>
private Health health;
/// <summary>
/// 默认颜色
/// </summary>
private Color defColor;
/// <summary>
/// 检查点列表
/// </summary>
private GameObject[] checkpoints;
/// <summary>
/// 渲染器
/// </summary>
private Renderer render;
/// <summary>
/// AudioSource
/// </summary>
private AudioSource aSource;
void Awake()
{
render = GetComponent<Renderer>();
aSource = GetComponent<AudioSource>();
//标签不是Respawn,自动修改标签
if(tag != "Respawn")
{
tag = "Respawn";
Debug.LogWarning ("'Checkpoint' script attached to object without the 'Respawn' tag, tag has been assigned automatically", transform);
}
GetComponent<Collider>().isTrigger = true;
//设置默认颜色和不透明度
if(render)
defColor = render.material.color;
activeColor.a = activeColorOpacity;
}
void Start()
{
checkpoints = GameObject.FindGameObjectsWithTag("Respawn");
health = GameObject.FindGameObjectWithTag("Player").GetComponent<Health>();
if(!health)
Debug.LogError("For Checkpoint to work, the Player needs 'Health' script attached", transform);
}
void OnTriggerEnter(Collider other)
{
//如果碰到玩家
if(other.transform.tag == "Player" && health)
{
health.respawnPos = transform.position;
if(render.material.color != activeColor)
{
foreach (GameObject checkpoint in checkpoints)
checkpoint.GetComponent<Renderer>().material.color = defColor;
aSource.Play();
render.material.color = activeColor;
}
}
}
}Checkpoint
using UnityEngine;
/// <summary>
/// 金币
/// </summary>
[RequireComponent(typeof(SphereCollider))]
public class Coin : MonoBehaviour
{
/// <summary>
/// 被收集时的声音
/// </summary>
public AudioClip collectSound;
/// <summary>
/// 旋转
/// </summary>
, , );
/// <summary>
/// 玩家靠近时,增加的旋转
/// </summary>
, , );
/// <summary>
/// 金币向玩家移动的速度
/// </summary>
public float startSpeed = 3f;
/// <summary>
/// 金币向玩家移动的加速度
/// </summary>
public float speedGain = 0.2f;
/// <summary>
/// 是否被搜集
/// </summary>
private bool collected;
/// <summary>
/// 玩家
/// </summary>
private Transform player;
/// <summary>
/// 子物体的触发器
/// </summary>
private TriggerParent triggerParent;
/// <summary>
/// GUI
/// </summary>
private GUIManager gui;
void Awake()
{
gui = FindObjectOfType(typeof(GUIManager)) as GUIManager ;
if(tag != "Coin")
{
tag = "Coin";
Debug.LogWarning ("'Coin' script attached to object not tagged 'Coin', tag added automatically", transform);
}
GetComponent<Collider>().isTrigger = true;
triggerParent = GetComponentInChildren<TriggerParent>();
//添加bounds子物体
if(!triggerParent)
{
GameObject bounds = new GameObject();
bounds.name = "Bounds";
bounds.AddComponent<SphereCollider>();
bounds.GetComponent<SphereCollider>().radius = 7f;
bounds.GetComponent<SphereCollider>().isTrigger = true;
bounds.transform.parent = transform;
bounds.transform.position = transform.position;
bounds.AddComponent<TriggerParent>();
triggerParent = GetComponentInChildren<TriggerParent>();
triggerParent.tagsToCheck = ];
triggerParent.tagsToCheck[] = "Player";
Debug.LogWarning ("No pickup radius 'bounds' trigger attached to coin: " + transform.name + ", one has been added automatically", bounds);
}
}
void Start()
{
player = GameObject.FindGameObjectWithTag("Player").transform;
}
void Update()
{
transform.Rotate (rotation * Time.deltaTime, Space.World);
if(triggerParent.collided)
collected = true;
//增加金币的旋转速度和移动速度,将金币移向玩家
if (collected)
{
startSpeed += speedGain;
rotation += rotationGain;
transform.position = Vector3.Lerp (transform.position, player.position, startSpeed * Time.deltaTime);
}
}
void OnTriggerEnter(Collider other)
{
if (other.tag == "Player")
CoinGet();
}
/// <summary>
/// 获取金币
/// </summary>
void CoinGet()
{
if(collectSound)
AudioSource.PlayClipAtPoint(collectSound, transform.position);
if (gui)
gui.coinsCollected ++;
Destroy(gameObject);
}
}Coin
using UnityEngine;
/// <summary>
/// 处理伤害
/// </summary>
public class DealDamage : MonoBehaviour
{
/// <summary>
/// 受害人的生命
/// </summary>
private Health health;
/// <summary>
/// 攻击
/// </summary>
public void Attack(GameObject victim, int dmg, float pushHeight, float pushForce)
{
health = victim.GetComponent<Health>();
//推物体
Vector3 pushDir = (victim.transform.position - transform.position);
pushDir.y = 0f;
pushDir.y = pushHeight * 0.1f;
if (victim.GetComponent<Rigidbody>() && !victim.GetComponent<Rigidbody>().isKinematic)
{
victim.GetComponent<Rigidbody>().velocity = , , );
victim.GetComponent<Rigidbody>().AddForce (pushDir.normalized * pushForce, ForceMode.VelocityChange);
victim.GetComponent<Rigidbody>().AddForce (Vector3.up * pushHeight, ForceMode.VelocityChange);
}
//应用伤害
if(health && !health.flashing)
health.currentHealth -= dmg;
}
}DealDamage
using UnityEngine;
using System.Collections;
/// <summary>
/// 摧毁物体
/// </summary>
public class DestroyObject : MonoBehaviour
{
/// <summary>
/// 摧毁声音
/// </summary>
public AudioClip destroySound;
/// <summary>
/// 延迟
/// </summary>
public float delay;
/// <summary>
/// 是否分离子物体并且不摧毁子物体
/// </summary>
public bool destroyChildren;
/// <summary>
/// 从父物体中心推开子物体的数量
/// </summary>
public float pushChildAmount;
void Start()
{
//获取子物体列表
Transform[] children = new Transform[transform.childCount];
; i < transform.childCount; i++)
children[i] = transform.GetChild(i);
//分离子物体
if (!destroyChildren)
transform.DetachChildren();
//给子物体添加一个推力和旋转
foreach (Transform child in children)
{
Rigidbody rigid = child.GetComponent<Rigidbody>();
)
{
Vector3 pushDir = child.position - transform.position;
rigid.AddForce(pushDir * pushChildAmount, ForceMode.Force);
rigid.AddTorque(Random.insideUnitSphere, ForceMode.Force);
}
}
//删除父物体
if(destroySound)
AudioSource.PlayClipAtPoint(destroySound, transform.position);
Destroy (gameObject, delay);
}
}DestroyObject
using UnityEngine;
using System.Collections;
/// <summary>
/// 敌人AI
/// </summary>
[RequireComponent(typeof(CharacterMotor))]
[RequireComponent(typeof(DealDamage))]
public class EnemyAI : MonoBehaviour
{
/// <summary>
/// 移动加速度
/// </summary>
public float acceleration = 35f;
/// <summary>
/// 移动减速度
/// </summary>
public float deceleration = 8f;
/// <summary>
/// 旋转速度
/// </summary>
public float rotateSpeed = 0.7f;
/// <summary>
/// 速度极限
/// </summary>
public float speedLimit = 10f;
/// <summary>
/// 玩家跳到敌人头上时应用到玩家身上的力
/// </summary>
, , );
/// <summary>
/// 玩家跳到敌人头上时的声音
/// </summary>
public AudioClip bounceSound;
/// <summary>
/// 玩家碰到敌人时受到的推力
/// </summary>
public float pushForce = 10f;
/// <summary>
/// 玩家碰到敌人时玩家的高度
/// </summary>
public float pushHeight = 7f;
/// <summary>
/// 敌人对玩家的伤害
/// </summary>
;
/// <summary>
/// 是否追逐视野内的目标
/// </summary>
public bool chase = true;
/// <summary>
/// 追逐时是否忽略y轴
/// </summary>
public bool ignoreY = true;
/// <summary>
/// 追逐停止的距离
/// </summary>
public float chaseStopDistance = 0.7f;
/// <summary>
/// 视野范围
/// </summary>
public GameObject sightBounds;
/// <summary>
/// 攻击范围
/// </summary>
public GameObject attackBounds;
/// <summary>
/// Animator
/// </summary>
public Animator animatorController;
/// <summary>
/// 移动到路标点
/// </summary>
public MoveToPoints moveToPointsScript;
/// <summary>
/// 视野触发器
/// </summary>
private TriggerParent sightTrigger;
/// <summary>
/// 攻击触发器
/// </summary>
private TriggerParent attackTrigger;
/// <summary>
/// 玩家移动
/// </summary>
private PlayerMove playerMove;
/// <summary>
/// 角色移动
/// </summary>
private CharacterMotor characterMotor;
/// <summary>
/// 处理伤害
/// </summary>
private DealDamage dealDamage;
void Awake()
{
characterMotor = GetComponent<CharacterMotor>();
dealDamage = GetComponent<DealDamage>();
if(tag != "Enemy")
{
tag = "Enemy";
Debug.LogWarning("'EnemyAI' script attached to object without 'Enemy' tag, it has been assign automatically", transform);
}
if(sightBounds)
{
sightTrigger = sightBounds.GetComponent<TriggerParent>();
if(!sightTrigger)
Debug.LogError("'TriggerParent' script needs attaching to enemy 'SightBounds'", sightBounds);
}
if(!sightBounds)
Debug.LogWarning("Assign a trigger with 'TriggerParent' script attached, to 'SightBounds' or enemy will not be able to see", transform);
if(attackBounds)
{
attackTrigger = attackBounds.GetComponent<TriggerParent>();
if(!attackTrigger)
Debug.LogError("'TriggerParent' script needs attaching to enemy 'attackBounds'", attackBounds);
}
else
Debug.LogWarning("Assign a trigger with 'TriggerParent' script attached, to 'AttackBounds' or enemy will not be able to attack", transform);
}
void Update()
{
//追逐
if (sightTrigger && sightTrigger.colliding && chase && sightTrigger.hitObject != null && sightTrigger.hitObject.activeInHierarchy)
{
characterMotor.MoveTo (sightTrigger.hitObject.transform.position, acceleration, chaseStopDistance, ignoreY);
if(animatorController)
animatorController.SetBool("Moving", true);
if(moveToPointsScript)
moveToPointsScript.enabled = false;
}
else
{
if(animatorController)
animatorController.SetBool("Moving", false);
if(moveToPointsScript)
moveToPointsScript.enabled = true;
}
//攻击
if (attackTrigger && attackTrigger.collided)
{
dealDamage.Attack(attackTrigger.hitObject, attackDmg, pushHeight, pushForce);
if(animatorController)
animatorController.SetBool("Attacking", true);
}
else if(animatorController)
animatorController.SetBool("Attacking", false);
}
void FixedUpdate()
{
characterMotor.ManageSpeed(deceleration, speedLimit, ignoreY);
characterMotor.RotateToVelocity (rotateSpeed, ignoreY);
}
/// <summary>
/// 弹开玩家
/// </summary>
public void BouncedOn()
{
if(!playerMove)
playerMove = GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerMove>();
if (bounceSound)
AudioSource.PlayClipAtPoint(bounceSound, transform.position);
if(playerMove)
{
Vector3 bounceMultiplier = new Vector3(0f, 1.5f, 0f) * playerMove.onEnemyBounce;
playerMove.Jump (bounceForce + bounceMultiplier);
}
else
Debug.LogWarning("'Player' tagged object landed on enemy, but without playerMove script attached, is unable to bounce");
}
}EnemyAI
using UnityEngine;
/// <summary>
/// 关卡目标
/// </summary>
[RequireComponent(typeof(CapsuleCollider))]
public class Goal : MonoBehaviour
{
/// <summary>
/// 举起玩家的力
/// </summary>
public float lift;
/// <summary>
/// 加载下一个关卡的等待时间
/// </summary>
public float loadDelay;
/// <summary>
/// 下一个场景的索引
/// </summary>
public int nextLevelIndex;
/// <summary>
/// 计时器
/// </summary>
private float counter;
void Awake()
{
GetComponent<Collider>().isTrigger = true;
}
void OnTriggerStay(Collider other)
{
Rigidbody rigid = other.GetComponent<Rigidbody>();
if(rigid)
rigid.AddForce(Vector3.up * lift, ForceMode.Force);
if (other.tag == "Player")
{
counter += Time.deltaTime;
if(counter > loadDelay)
Application.LoadLevel (nextLevelIndex);
}
}
void OnTriggerExit(Collider other)
{
if (other.tag == "Player")
counter = 0f;
}
}Goal
using UnityEngine;
using System.Collections;
/// <summary>
/// GUI
/// </summary>
public class GUIManager : MonoBehaviour
{
/// <summary>
/// GUISkin
/// </summary>
public GUISkin guiSkin;
/// <summary>
/// 已收集的金币
/// </summary>
[HideInInspector]
public int coinsCollected;
/// <summary>
/// 场景中的金币数量
/// </summary>
private int coinsInLevel;
/// <summary>
/// 生命
/// </summary>
private Health health;
void Start()
{
coinsInLevel = GameObject.FindGameObjectsWithTag("Coin").Length;
health = GameObject.FindGameObjectWithTag("Player").GetComponent<Health>();
}
void OnGUI()
{
GUI.skin = guiSkin;
GUILayout.Space(5f);
if(health)
GUILayout.Label ("Health: " + health.currentHealth);
)
GUILayout.Label ("Cubes: " + coinsCollected + " / " + coinsInLevel);
}
}GUIManager
using UnityEngine;
using System.Collections;
/// <summary>
/// 障碍
/// </summary>
[RequireComponent(typeof(DealDamage))]
[RequireComponent(typeof(AudioSource))]
public class Hazard : MonoBehaviour
{
/// <summary>
/// 推开受害者的力
/// </summary>
public float pushForce = 25f;
/// <summary>
/// 向上推的力
/// </summary>
public float pushHeight = 6f;
/// <summary>
/// 照成的伤害
/// </summary>
;
/// <summary>
/// 是否是触发
/// </summary>
public bool triggerEnter;
/// <summary>
/// 是否是碰撞
/// </summary>
public bool collisionEnter = true;
/// <summary>
/// 影响的单位的标签
/// </summary>
public string[] effectedTags = {"Player"};
/// <summary>
/// 碰撞声音
/// </summary>
public AudioClip hitSound;
/// <summary>
/// 处理伤害
/// </summary>
private DealDamage dealDamage;
/// <summary>
/// AudioSource
/// </summary>
private AudioSource aSource;
//setup
void Awake()
{
aSource = GetComponent<AudioSource>();
aSource.playOnAwake = false;
dealDamage = GetComponent<DealDamage>();
}
void OnCollisionEnter(Collision col)
{
//不是碰撞
if(!collisionEnter)
return;
//遍历检查标签
foreach(string tag in effectedTags)
//标签相等
if(col.transform.tag == tag)
{
//处理伤害
dealDamage.Attack (col.gameObject, damage, pushHeight, pushForce);
//播放声音
if (hitSound)
{
aSource.clip = hitSound;
aSource.Play();
}
}
}
void OnTriggerEnter(Collider other)
{
//不是触发器
if(!triggerEnter)
return;
//遍历标签
foreach(string tag in effectedTags)
//标签相等
if(other.transform.tag == tag)
//处理伤害
dealDamage.Attack (other.gameObject, damage, pushHeight, pushForce);
}
}Hazard
using UnityEngine;
using System.Collections;
/// <summary>
/// 生命
/// </summary>
[RequireComponent(typeof(AudioSource))]
public class Health : MonoBehaviour
{
/// <summary>
/// 撞击声音
/// </summary>
public AudioClip impactSound;
/// <summary>
/// 受到伤害时的声音
/// </summary>
public AudioClip hurtSound;
/// <summary>
/// 死亡声音
/// </summary>
public AudioClip deadSound;
/// <summary>
/// 当前生命
/// </summary>
;
/// <summary>
/// 是否能受到撞击伤害
/// </summary>
public bool takeImpactDmg;
/// <summary>
/// 是否只能受到刚体伤害
/// </summary>
public bool onlyRigidbodyImpact;
/// <summary>
/// 是否可以重生
/// </summary>
public bool respawn;
/// <summary>
/// 不会受到撞击伤害的标签
/// </summary>
public string[] impactFilterTag;
/// <summary>
/// 受到伤害时的闪烁延迟
/// </summary>
public float hitFlashDelay = 0.1f;
/// <summary>
/// 闪烁持续时间
/// </summary>
public float flashDuration = 0.9f;
/// <summary>
/// 受到伤害时的闪烁颜色
/// </summary>
public Color hitFlashColor = Color.red;
/// <summary>
/// 闪烁的物体
/// </summary>
public Transform flashObject;
/// <summary>
///
/// </summary>
public GameObject[] spawnOnDeath;
/// <summary>
/// 是否死亡,是否闪烁
/// </summary>
[HideInInspector]
public bool dead, flashing;
/// <summary>
/// 重生位置
/// </summary>
[HideInInspector]
public Vector3 respawnPos;
/// <summary>
/// 原始颜色
/// </summary>
private Color originalColor;
/// <summary>
///
/// </summary>
private int defHealth, h, hitForce;
private bool hitColor = false;
/// <summary>
/// 下一个闪烁,停止闪烁时间
/// </summary>
private float nextFlash, stopFlashTime;
/// <summary>
/// 扔物体
/// </summary>
private Throwing throwing;
/// <summary>
/// 闪烁渲染器
/// </summary>
private Renderer flashRender;
/// <summary>
/// AudioSource
/// </summary>
private AudioSource aSource;
void Awake()
{
aSource = GetComponent<AudioSource>();
)
Debug.LogWarning(transform.name + " has 'currentHealth' set to 0 or less in 'Health' script: it has died upon scene start");
aSource.playOnAwake = false;
if(flashObject == null)
flashObject = transform;
flashRender = flashObject.GetComponent<Renderer>();
originalColor = flashRender.material.color;
defHealth = currentHealth;
respawnPos = transform.position;
}
void Update()
{
//受到伤害,闪烁
if (currentHealth < h)
{
flashing = true;
stopFlashTime = Time.time + flashDuration;
if (hurtSound)
AudioSource.PlayClipAtPoint(hurtSound, transform.position);
}
h = currentHealth;
if (flashing)
{
Flash ();
if (Time.time > stopFlashTime)
{
flashRender.material.color = originalColor;
flashing = false;
}
}
dead = (currentHealth <= ) ? true : false;
if (dead)
Death();
}
/// <summary>
/// 闪烁
/// </summary>
void Flash()
{
flashRender.material.color = (hitColor) ? hitFlashColor : originalColor;
if(Time.time > nextFlash)
{
hitColor = !hitColor;
nextFlash = Time.time + hitFlashDelay;
}
}
/// <summary>
/// 死亡
/// </summary>
void Death()
{
if(tag == "Player")
throwing = GetComponent<Throwing>();
if(throwing && throwing.heldObj && throwing.heldObj.tag == "Pickup")
throwing.ThrowPickup();
if (deadSound)
AudioSource.PlayClipAtPoint(deadSound, transform.position);
flashing = false;
flashObject.GetComponent<Renderer>().material.color = originalColor;
if(respawn)
{
Rigidbody rigid = GetComponent<Rigidbody>();
if(rigid)
rigid.velocity *= ;
transform.position = respawnPos;
dead = false;
currentHealth = defHealth;
}
else
Destroy (gameObject);
)
foreach(GameObject obj in spawnOnDeath)
Instantiate(obj, transform.position, Quaternion.Euler(Vector3.zero));
}
void OnCollisionEnter(Collision col)
{
//播放撞击声音
if(!aSource.isPlaying && impactSound)
{
aSource.clip = impactSound;
aSource.volume = col.relativeVelocity.magnitude/;
aSource.Play();
}
//不会受到撞击伤害,返回
if (!takeImpactDmg)
return;
//找到标签,返回
foreach(string tag in impactFilterTag)
if(col.transform.tag == tag)
return;
//只能受到刚体撞击且没有刚体,返回
if(onlyRigidbodyImpact && !col.rigidbody)
return;
//计算受到的伤害
if(col.rigidbody)
hitForce = ( * col.rigidbody.mass);
else
hitForce = (;
currentHealth -= hitForce;
//print (transform.name + " took: " + hitForce + " dmg in collision with " + col.transform.name);
}
}Health
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
/// <summary>
/// 移动到指定的点
/// </summary>
[RequireComponent(typeof(Rigidbody))]
public class MoveToPoints:MonoBehaviour {
/// <summary>
/// 移动速度
/// </summary>
public float speed;
/// <summary>
/// 延迟
/// </summary>
public float delay;
/// <summary>
/// 移动类型
/// </summary>
public type movementType;
/// <summary>
/// 移动类型
/// </summary>
public enum type {
/// <summary>
/// 在最后一个路标停止
/// </summary>
PlayOnce,
/// <summary>
/// 转圈
/// </summary>
Loop,
/// <summary>
/// 来回
/// </summary>
PingPong
}
/// <summary>
/// 当前路标索引
/// </summary>
private int currentWp;
/// <summary>
/// 到达时间
/// </summary>
private float arrivalTime;
/// <summary>
/// 是否向前,是否到达
/// </summary>
private bool forward = true, arrived = false;
/// <summary>
/// 路标列表
/// </summary>
private List<Transform> waypoints = new List<Transform>();
/// <summary>
/// 角色移动
/// </summary>
private CharacterMotor characterMotor;
/// <summary>
/// 敌人AI
/// </summary>
private EnemyAI enemyAI;
/// <summary>
/// 刚体
/// </summary>
private Rigidbody rigid;
void Awake() {
//标签不是Enemy
if(transform.tag != "Enemy") {
//没有刚体,添加刚体
if(!GetComponent<Rigidbody>())
gameObject.AddComponent<Rigidbody>();
//动力学
GetComponent<Rigidbody>().isKinematic = true;
//不使用重力
GetComponent<Rigidbody>().useGravity = false;
//修改插值类型
GetComponent<Rigidbody>().interpolation = RigidbodyInterpolation.Interpolate;
} else {
//角色移动
characterMotor = GetComponent<CharacterMotor>();
//获取敌人AI
enemyAI = GetComponent<EnemyAI>();
}
//获取刚体
rigid = GetComponent<Rigidbody>();
//遍历子物体
foreach(Transform child in transform)
//添加路标
if(child.tag == "Waypoint")
waypoints.Add(child);
//分离路标
foreach(Transform waypoint in waypoints)
waypoint.parent = null;
)
Debug.LogError("No waypoints found for 'MoveToPoints' script. To add waypoints: add child gameObjects with the tag 'Waypoint'",transform);
}
void Update() {
//路标数量大于0
) {
//没有到达
if(!arrived) {
//与下一个路标的距离小于0.3
if(Vector3.Distance(transform.position,waypoints[currentWp].position) < 0.3f) {
//设置到达时间
arrivalTime = Time.time;
//修改到达标志位
arrived = true;
}
//到达
} else {
//当前时间大于到达时间加延迟
if(Time.time > arrivalTime + delay) {
//获取下一个路标
GetNextWP();
//修改到达标志位
arrived = false;
}
}
}
//标签是Enemy,路标数量大于0
) {
//没有到达位置
if(!arrived) {
//玩家移动到指定路标
characterMotor.MoveTo(waypoints[currentWp].position,enemyAI.acceleration,0.1f,enemyAI.ignoreY);
//播放动画
if(enemyAI.animatorController)
enemyAI.animatorController.SetBool("Moving",true);
//到达位置
} else
//播放动画
if(enemyAI.animatorController)
enemyAI.animatorController.SetBool("Moving",false);
}
}
void FixedUpdate() {
//标签为Enemy
if(transform.tag != "Enemy") {
//没有到达且路标数量大于0
) {
//计算和路标的距离
Vector3 direction = waypoints[currentWp].position - transform.position;
//刚体移动
rigid.MovePosition(transform.position + (direction.normalized * speed * Time.fixedDeltaTime));
}
}
}
/// <summary>
/// 获取下一个路标
/// </summary>
private void GetNextWP() {
//一次
if(movementType == type.PlayOnce) {
currentWp++;
if(currentWp == waypoints.Count)
enabled = false;
}
//循环
if(movementType == type.Loop)
currentWp = (currentWp == waypoints.Count - ) ? : currentWp += ;
//来回
if(movementType == type.PingPong) {
)
forward = false;
)
forward = true;
currentWp = (forward) ? currentWp += : currentWp -= ;
}
}
void OnDrawGizmos() {
Gizmos.color = Color.cyan;
foreach(Transform child in transform) {
if(child.tag == "Waypoint")
Gizmos.DrawSphere(child.position,.7f);
}
}
}MoveToPoints
using UnityEngine;
using System.Collections;
/// <summary>
/// 玩家移动
/// </summary>
[RequireComponent(typeof(CharacterMotor))]
[RequireComponent(typeof(DealDamage))]
[RequireComponent(typeof(AudioSource))]
[RequireComponent(typeof(Rigidbody))]
public class PlayerMove:MonoBehaviour {
/// <summary>
/// 是否是卷轴模式
/// </summary>
public bool sidescroller;
/// <summary>
/// 主相机,FloorChecks游戏物体Transform
/// </summary>
public Transform mainCam, floorChecks;
/// <summary>
/// Animator
/// </summary>
public Animator animator;
/// <summary>
/// 跳跃声音
/// </summary>
public AudioClip jumpSound;
/// <summary>
/// 着陆声音
/// </summary>
public AudioClip landSound;
/// <summary>
/// 加速度
/// </summary>
public float accel = 70f;
/// <summary>
/// 空中加速度
/// </summary>
public float airAccel = 18f;
/// <summary>
/// 减速度
/// </summary>
public float decel = 7.6f;
/// <summary>
/// 空中减速度
/// </summary>
public float airDecel = 1.1f;
/// <summary>
/// 旋转速度,空中旋转速度
/// </summary>
[Range(0f,5f)]
public float rotateSpeed = 0.7f, airRotateSpeed = 0.4f;
/// <summary>
/// 最高移动速度
/// </summary>
;
/// <summary>
/// 最大坡度,最大滑坡速度
/// </summary>
, slideAmount = ;
/// <summary>
/// 移动平台的摩擦力
/// </summary>
public float movingPlatformFriction = 7.7f;
/// <summary>
/// 常规跳跃力
/// </summary>
,,);
/// <summary>
/// 2连跳力
/// </summary>
,,);
/// <summary>
/// 3连跳力
/// </summary>
,,);
/// <summary>
/// 两次跳跃间的延迟
/// </summary>
public float jumpDelay = 0.1f;
/// <summary>
/// 着陆前仍然可以按下跳跃的时间
/// </summary>
public float jumpLeniancy = 0.17f;
[HideInInspector]
public int onEnemyBounce;
/// <summary>
/// 跳跃类型
/// </summary>
private int onJump;
/// <summary>
/// 是否着陆
/// </summary>
private bool grounded;
/// <summary>
/// 检查是否着陆的Transform列表(玩家身体的下面9个点)
/// </summary>
private Transform[] floorCheckers;
/// <summary>
///
/// </summary>
private Quaternion screenMovementSpace;
/// <summary>
/// 按下跳跃的时间,着陆后的时间,当前加速度,当前减速度,当前旋转速度,斜率
/// </summary>
private float airPressTime, groundedCount, curAccel, curDecel, curRotateSpeed, slope;
/// <summary>
/// 方向,移动方向,屏幕向前移动,屏幕向右移动,移动物体的速度
/// </summary>
private Vector3 direction, moveDirection, screenMovementForward, screenMovementRight, movingObjSpeed;
/// <summary>
/// 角色移动
/// </summary>
private CharacterMotor characterMotor;
/// <summary>
/// 敌人AI
/// </summary>
private EnemyAI enemyAI;
/// <summary>
/// 处理伤害
/// </summary>
private DealDamage dealDamage;
/// <summary>
/// Rigidbody
/// </summary>
private Rigidbody rigid;
/// <summary>
/// AudioSource
/// </summary>
private AudioSource aSource;
void Awake() {
//没有检查列表
if(!floorChecks) {
//添加
floorChecks = new GameObject().transform;
floorChecks.name = "FloorChecks";
floorChecks.parent = transform;
floorChecks.position = transform.position;
//添加单个子物体
GameObject check = new GameObject();
check.name = "Check1";
check.transform.parent = floorChecks;
check.transform.position = transform.position;
Debug.LogWarning("No 'floorChecks' assigned to PlayerMove script, so a single floorcheck has been created",floorChecks);
}
//标签不是Player
if(tag != "Player") {
//标签改为Player
tag = "Player";
Debug.LogWarning("PlayerMove script assigned to object without the tag 'Player', tag has been assigned automatically",transform);
}
//获取主摄像机
mainCam = GameObject.FindGameObjectWithTag("MainCamera").transform;
//获取处理伤害
dealDamage = GetComponent<DealDamage>();
//获取角色移动
characterMotor = GetComponent<CharacterMotor>();
//获取刚体
rigid = GetComponent<Rigidbody>();
//获取AudioSource
aSource = GetComponent<AudioSource>();
//设置检查列表
floorCheckers = new Transform[floorChecks.childCount];
;i < floorCheckers.Length;i++)
floorCheckers[i] = floorChecks.GetChild(i);
}
void Update() {
//激活刚体
rigid.WakeUp();
//计算跳跃
JumpCalculations();
//根据玩家是否着地设置当前加速度
curAccel = (grounded) ? accel : airAccel;
//根据玩家是否着地设置当前减速度
curDecel = (grounded) ? decel : airDecel;
//根据玩家是否着地设置当前旋转速度
curRotateSpeed = (grounded) ? rotateSpeed : airRotateSpeed;
screenMovementSpace = Quaternion.Euler(,mainCam.eulerAngles.y,);
screenMovementForward = screenMovementSpace * Vector3.forward;
screenMovementRight = screenMovementSpace * Vector3.right;
float h = Input.GetAxisRaw("Horizontal");
float v = Input.GetAxisRaw("Vertical");
//不是卷轴模式
if(!sidescroller)
direction = (screenMovementForward * v) + (screenMovementRight * h);
//是卷轴模式
else
//方向等于水平轴的输入*Vector3.right
direction = Vector3.right * h;
//移动方向等于当前位置加方向
moveDirection = transform.position + direction;
}
void FixedUpdate() {
//检查是否着地
grounded = IsGrounded();
//角色移动
characterMotor.MoveTo(moveDirection,curAccel,0.7f,true);
//旋转角色
&& direction.magnitude != )
characterMotor.RotateToDirection(moveDirection,curRotateSpeed * ,true);
//管理角色速度
characterMotor.ManageSpeed(curDecel,maxSpeed + movingObjSpeed.magnitude,true);
//播放动画
if(animator) {
animator.SetFloat("DistanceToTarget",characterMotor.DistanceToTarget);
animator.SetBool("Grounded",grounded);
animator.SetFloat("YVelocity",GetComponent<Rigidbody>().velocity.y);
}
}
void OnCollisionStay(Collision other) {
if(other.collider.tag != "Untagged" || grounded == false)
return;
//在小坡度上停止下滑
&& slope < slopeLimit && rigid.velocity.magnitude < ) {
rigid.velocity = Vector3.zero;
}
}
/// <summary>
/// 检查是否着陆
/// </summary>
private bool IsGrounded() {
//计算距离
float dist = GetComponent<Collider>().bounds.extents.y;
//遍历所有检查点
foreach(Transform check in floorCheckers) {
RaycastHit hit;
//向下发射射线
if(Physics.Raycast(check.position,Vector3.down,out hit,dist + 0.05f)) {
//如果不是触发器
if(!hit.transform.GetComponent<Collider>().isTrigger) {
//计算斜率
slope = Vector3.Angle(hit.normal,Vector3.up);
//斜率大于最大斜率,不是Pushable
if(slope > slopeLimit && hit.transform.tag != "Pushable") {
//计算滑动方向
Vector3 slide = new Vector3(0f,-slideAmount,0f);
//刚体施加滑动力
rigid.AddForce(slide,ForceMode.Force);
}
//碰到敌人,y轴速度小于0
) {
//获取敌人AI
enemyAI = hit.transform.GetComponent<EnemyAI>();
//弹开玩家
enemyAI.BouncedOn();
//
onEnemyBounce++;
//处理伤害
dealDamage.Attack(hit.transform.gameObject,,0f,0f);
} else
//
onEnemyBounce = ;
//移动平台或Pushable
if(hit.transform.tag == "MovingPlatform" || hit.transform.tag == "Pushable") {
//移动物体的速度为刚体的速度
movingObjSpeed = hit.transform.GetComponent<Rigidbody>().velocity;
//移动物体的y轴速度为0
movingObjSpeed.y = 0f;
//根据移动物体的速度和摩檫力给玩家刚体添加力
rigid.AddForce(movingObjSpeed * movingPlatformFriction * Time.fixedDeltaTime,ForceMode.VelocityChange);
} else {
//移动物体的速度归0
movingObjSpeed = Vector3.zero;
}
return true;
}
}
}
//移动物体的速度归0
movingObjSpeed = Vector3.zero;
return false;
}
/// <summary>
/// 计算跳跃
/// </summary>
private void JumpCalculations() {
//保存着陆后的时间
groundedCount = (grounded) ? groundedCount += Time.deltaTime : 0f;
//着陆时间小于0.25并且不等于0,正在播放声音,y轴的速度小于1
&& !GetComponent<AudioSource>().isPlaying && landSound && GetComponent<Rigidbody>().velocity.y < ) {
//根据y轴的速度修改音量
aSource.volume = Mathf.Abs(GetComponent<Rigidbody>().velocity.y) / ;
//修改声音
aSource.clip = landSound;
//播放声音
aSource.Play();
}
//按下jump且没有着陆
if(Input.GetButtonDown("Jump") && !grounded)
//修改按下跳跃的时间为当前时间
airPressTime = Time.time;
//着陆,斜率小于最大斜率
if(grounded && slope < slopeLimit) {
//按下Jump
if(Input.GetButtonDown("Jump") || airPressTime + jumpLeniancy > Time.time) {
//切换跳跃类型
onJump = (groundedCount < jumpDelay) ? Mathf.Min(,onJump + ) : ;
)
Jump(jumpForce);
)
Jump(secondJumpForce);
) {
Jump(thirdJumpForce);
onJump--;
}
}
}
}
/// <summary>
/// 跳跃
/// </summary>
public void Jump(Vector3 jumpVelocity) {
//播放跳跃声音
if(jumpSound) {
aSource.volume = ;
aSource.clip = jumpSound;
aSource.Play();
}
//改变刚体的y轴速度
rigid.velocity = new Vector3(rigid.velocity.x,0f,rigid.velocity.z);
//给刚体添加力
rigid.AddRelativeForce(jumpVelocity,ForceMode.Impulse);
//重置按下跳跃的时间
airPressTime = 0f;
}
}PlayerMove
using UnityEngine;
using System.Collections;
/// <summary>
/// 让玩家拾取,扔,推物体
/// </summary>
[RequireComponent(typeof(AudioSource))]
[RequireComponent(typeof(Rigidbody))]
[RequireComponent(typeof(PlayerMove))]
public class Throwing : MonoBehaviour
{
/// <summary>
/// 拾取声音
/// </summary>
public AudioClip pickUpSound;
/// <summary>
/// 扔声音
/// </summary>
public AudioClip throwSound;
/// <summary>
/// 用来抓物体的子游戏物体
/// </summary>
public GameObject grabBox;
/// <summary>
/// 举起物体的偏移
/// </summary>
public Vector3 holdOffset;
/// <summary>
/// 扔的力
/// </summary>
, , );
/// <summary>
/// 转向物体的速度
/// </summary>
;
/// <summary>
/// 检查玩家头部的范围
/// </summary>
public float checkRadius = 0.5f;
/// <summary>
/// 拾取物体的重量
/// </summary>
[Range(0.1f, 1f)]
public float weightChange = 0.3f;
/// <summary>
/// 未用
/// </summary>
[Range(10f, 1000f)]
, holdingBreakTorque = ;
/// <summary>
/// Animator
/// </summary>
public Animator animator;
/// <summary>
/// 手臂动画层
/// </summary>
public int armsAnimationLayer;
/// <summary>
/// 举起或抓住的物体
/// </summary>
[HideInInspector]
public GameObject heldObj;
/// <summary>
/// 举起物体的位置
/// </summary>
private Vector3 holdPos;
/// <summary>
/// 连接物体和角色的关节
/// </summary>
private FixedJoint joint;
/// <summary>
/// 举起物体的时间,扔物体的时间,默认旋转速度
/// </summary>
private float timeOfPickup, timeOfThrow, defRotateSpeed;
/// <summary>
/// gizmo颜色
/// </summary>
private Color gizmoColor;
/// <summary>
/// AudioSource
/// </summary>
private AudioSource aSource;
/// <summary>
/// 玩家移动
/// </summary>
private PlayerMove playerMove;
/// <summary>
/// 父物体下的子物体的触发器
/// </summary>
private TriggerParent triggerParent;
/// <summary>
/// 默认刚体插值类型
/// </summary>
private RigidbodyInterpolation objectDefInterpolation;
void Awake()
{
//获取AudioSource
aSource = GetComponent<AudioSource>();
//没有抓物体的子物体
if(!grabBox)
{
//新建
grabBox = new GameObject();
//添加碰撞器
grabBox.AddComponent<BoxCollider>();
//设置为触发器
grabBox.GetComponent<Collider>().isTrigger = true;
//设置玩家为父物体
grabBox.transform.parent = transform;
//修改局部坐标
grabBox.transform.localPosition = new Vector3(0f, 0f, 0.5f);
//修改层(Ignore Raycast)
grabBox.layer = ;
Debug.LogWarning("No grabBox object assigned to 'Throwing' script, one has been created and assigned for you", grabBox);
}
//获取玩家移动脚本
playerMove = GetComponent<PlayerMove>();
//设置默认旋转速度
defRotateSpeed = playerMove.rotateSpeed;
//Animator不为空
if(animator)
//设置手臂动画层的权重
animator.SetLayerWeight(armsAnimationLayer, );
}
void Update()
{
//按下Grab键,有举起或抓住的物体,当前时间比举起物体的时间大0.1f
if (Input.GetButtonDown ("Grab") && heldObj && Time.time > timeOfPickup + 0.1f)
{
//举起物体的标签为"Pickup"
if(heldObj.tag == "Pickup")
//扔掉举起的物体
ThrowPickup();
}
//有Animator
if(animator)
//有举起的物体且物体标签为"Pickup"
if(heldObj && heldObj.tag == "Pickup")
animator.SetBool ("HoldingPickup", true);
else
animator.SetBool ("HoldingPickup", false);
//有抓住的物体且物体标签为"Pushable"
if(heldObj && heldObj.tag == "Pushable")
animator.SetBool ("HoldingPushable", true);
else
animator.SetBool ("HoldingPushable", false);
//有抓住的物体且物体标签为"Pushable"
if (heldObj && heldObj.tag == "Pushable")
{
//按下Grab
if(Input.GetButtonUp ("Grab"))
{
//丢弃物体
DropPushable();
}
//没有关节
if(!joint)
{
//丢弃物体
DropPushable();
print ("'Pushable' object dropped because the 'holdingBreakForce' or 'holdingBreakTorque' was exceeded");
}
}
}
void OnTriggerStay(Collider other)
{
//按下Grab
if(Input.GetButton("Grab"))
{
//标签为"Pickup",没有举起的物体,当前时间大于扔物体的时间加0.2
if(other.tag == "Pickup" && heldObj == null && timeOfThrow + 0.2f < Time.time)
//举起物体
LiftPickup(other);
//标签为"Pushable",没有抓住的物体,当前时间大于扔物体的时间加0.2
if(other.tag == "Pushable" && heldObj == null && timeOfThrow + 0.2f < Time.time)
//抓物体
GrabPushable(other);
}
}
/// <summary>
/// 抓住物体
/// </summary>
private void GrabPushable(Collider other)
{
//抓住的物体为碰撞的物体
heldObj = other.gameObject;
//获取物体的插值类型
objectDefInterpolation = heldObj.GetComponent<Rigidbody>().interpolation;
//修改物体的插值为内插值
heldObj.GetComponent<Rigidbody>().interpolation = RigidbodyInterpolation.Interpolate;
//添加关节,连接玩家和物体
AddJoint ();
//设置破坏关节的力为无限
joint.breakForce = Mathf.Infinity;
//设置破坏关节的扭矩力为无限
joint.breakTorque = Mathf.Infinity;
//设置玩家移动的旋转速度为0
playerMove.rotateSpeed = ;
}
/// <summary>
/// 举起物体
/// </summary>
private void LiftPickup(Collider other)
{
//获取物体的网格
Mesh otherMesh = other.GetComponent<MeshFilter>().mesh;
//计算举起的位置
holdPos = transform.position + transform.forward * holdOffset.z + transform.right * holdOffset.x + transform.up * holdOffset.y;
//举起的位置的y值加碰撞器的范围的y值加碰撞物体网格的范围的y值
holdPos.y += (GetComponent<Collider>().bounds.extents.y) + (otherMesh.bounds.extents.y);
//检测举起位置的圆形范围
if(!Physics.CheckSphere(holdPos,checkRadius)) {
//修改gizmo颜色
gizmoColor = Color.green;
//缓存举起的物体
heldObj = other.gameObject;
//修改默认插值类型
objectDefInterpolation = heldObj.GetComponent<Rigidbody>().interpolation;
//修改举起物体的插值类型
heldObj.GetComponent<Rigidbody>().interpolation = RigidbodyInterpolation.Interpolate;
//修改举起物体的位置
heldObj.transform.position = holdPos;
//修改举起物体的旋转
heldObj.transform.rotation = transform.rotation;
//添加关节,连接物体和玩家
AddJoint();
//修改举起物体的质量
heldObj.GetComponent<Rigidbody>().mass *= weightChange;
//修改举起物体的时间为当前时间
timeOfPickup = Time.time;
} else {
//修改gizmo颜色
gizmoColor = Color.red;
print("Can't lift object here. If nothing is above the player, perhaps you need to add a layerMask parameter to line 136 of the code in this script," +
"the CheckSphere function, in order to make sure it isn't detecting something above the players head that is invisible");
}
}
/// <summary>
/// 放下物体
/// </summary>
private void DropPushable()
{
//修改抓住物体的插值类型
heldObj.GetComponent<Rigidbody>().interpolation = objectDefInterpolation;
//销毁关节
Destroy (joint);
//修改玩家移动的旋转速度为默认旋转速度
playerMove.rotateSpeed = defRotateSpeed;
heldObj = null;
timeOfThrow = Time.time;
}
/// <summary>
/// 扔掉物体
/// </summary>
public void ThrowPickup()
{
//播放扔物体声音
if(throwSound)
{
aSource.volume = ;
aSource.clip = throwSound;
aSource.Play ();
}
//删除关节
Destroy (joint);
//获取举起物体的刚体
Rigidbody r = heldObj.GetComponent<Rigidbody>();
//恢复物体的插值类型
r.interpolation = objectDefInterpolation;
//恢复物体的质量
r.mass /= weightChange;
//给刚体添加力
r.AddRelativeForce (throwForce, ForceMode.VelocityChange);
heldObj = null;
timeOfThrow = Time.time;
}
/// <summary>
/// 添加关节,连接玩家和物体
/// </summary>
private void AddJoint()
{
//如果有物体
if (heldObj)
{
//播放拾取声音
if(pickUpSound)
{
aSource.volume = ;
aSource.clip = pickUpSound;
aSource.Play ();
}
//在物体上添加关节
joint = heldObj.AddComponent<FixedJoint>();
//设置关节的连接物体为玩家的刚体
joint.connectedBody = GetComponent<Rigidbody>();
}
}
void OnDrawGizmosSelected()
{
Gizmos.color = gizmoColor;
Gizmos.DrawSphere (holdPos, checkRadius);
}
}Throwing
using UnityEngine;
using System.Collections;
/// <summary>
/// 父物体下的子物体的触发器
/// </summary>
public class TriggerParent:MonoBehaviour {
/// <summary>
/// 要检查的标签列表
/// </summary>
public string[] tagsToCheck;
/// <summary>
/// 是否发生了碰撞,是否在碰撞中
/// </summary>
[HideInInspector]
public bool collided, colliding;
/// <summary>
/// 撞击的物体
/// </summary>
[HideInInspector]
public GameObject hitObject;
void Awake() {
//没有Collider或有Collider但不是触发器
if(!GetComponent<Collider>() || (GetComponent<Collider>() && !GetComponent<Collider>().isTrigger))
Debug.LogError("'TriggerParent' script attached to object which does not have a trigger collider",transform);
}
void OnTriggerEnter(Collider other) {
//标签列表长度大于0且没有碰撞过
&& !collided) {
//遍历标签
foreach(string tag in tagsToCheck) {
//找到标签
if(other.tag == tag) {
//已发生碰撞
collided = true;
//存储碰撞物体
hitObject = other.gameObject;
break;
}
}
} else
//已发生碰撞
collided = true;
//存储碰撞物体
hitObject = other.gameObject;
}
void OnTriggerStay(Collider other) {
//标签列表长度大于0
) {
//遍历标签
foreach(string tag in tagsToCheck) {
//找到标签
if(other.tag == tag) {
//正在碰撞
colliding = true;
//存储碰撞物体
hitObject = other.gameObject;
break;
}
}
} else {
//存储碰撞物体
hitObject = other.gameObject;
//正在碰撞
colliding = true;
}
}
void OnTriggerExit(Collider other) {
//标签列表长度大于0
) {
//遍历标签
foreach(string tag in tagsToCheck) {
//找到标签
if(other.tag == tag) {
colliding = false;
hitObject = null;
break;
}
}
} else
return;
}
void LateUpdate() {
//重置collided,hitObject
if(collided) {
collided = false;
hitObject = null;
}
}
}TriggerParent
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
/// <summary>
/// 水
/// </summary>
[RequireComponent(typeof(BoxCollider))]
public class Water:MonoBehaviour {
/// <summary>
/// 玩家进水的声音
/// </summary>
public AudioClip splashSound;
/// <summary>
/// 水的推力
/// </summary>
,);
/// <summary>
/// 玩家是否会受到水的阻力影响
/// </summary>
public bool effectPlayerDrag;
/// <summary>
/// 刚体受到的水的阻力(不包含玩家)
/// </summary>
public float resistance = 0.4f;
/// <summary>
/// 刚体受到的角阻力(不包含玩家)
/// </summary>
public float angularResistance = 0.2f;
/// <summary>
/// 刚体受到的阻力字典
/// </summary>
private Dictionary<GameObject,float> dragStore = new Dictionary<GameObject,float>();
/// <summary>
/// 刚体受到的角阻力字典
/// </summary>
private Dictionary<GameObject,float> angularStore = new Dictionary<GameObject,float>();
void Awake() {
//自动修改"Water"标签
if(tag != "Water") {
tag = "Water";
Debug.LogWarning("'Water' script attached to an object not tagged 'Water', it been assigned the tag 'Water'",transform);
}
//设置Trigger
GetComponent<Collider>().isTrigger = true;
}
void OnTriggerEnter(Collider other) {
//获取物体的刚体
Rigidbody r = other.GetComponent<Rigidbody>();
//刚体不为空
if(r) {
//播放入水声音
if(splashSound) {
;
AudioSource.PlayClipAtPoint(splashSound,other.transform.position,volume);
}
//是玩家且不受水的阻力影响
if(r.tag == "Player" && !effectPlayerDrag)
return;
//存储受到的阻力
dragStore.Add(r.gameObject,r.drag);
//存储受到的角阻力
angularStore.Add(r.gameObject,r.angularDrag);
//修改刚体受到的阻力
r.drag = resistance;
//修改刚体受到的角阻力
r.angularDrag = angularResistance;
} else if(splashSound)
//播放入水声音
AudioSource.PlayClipAtPoint(splashSound,other.transform.position);
}
void OnTriggerStay(Collider other) {
//计算表面高度
float surface = transform.position.y + GetComponent<Collider>().bounds.extents.y;
Rigidbody rigid = other.GetComponent<Rigidbody>();
if(rigid) {
//计算物体相对于表面高度的深度
float depth = surface - other.transform.position.y;
//深度大于0.4
if(depth > 0.4f)
//用一个较小的力往上推刚体
rigid.AddForce(force,ForceMode.Force);
//深度小于等于0.4
else
//用一个较大的力往上推刚体
rigid.AddForce(force * (depth * ),ForceMode.Force);
}
}
void OnTriggerExit(Collider other) {
//获取物体的刚体
Rigidbody r = other.GetComponent<Rigidbody>();
//有刚体
if(r) {
//是玩家且不受阻力水的阻力影响
if(r.tag == "Player" && !effectPlayerDrag)
return;
//阻力和角阻力字典包含刚体的游戏物体
if(dragStore.ContainsKey(r.gameObject) && angularStore.ContainsKey(r.gameObject)) {
//恢复阻力
r.drag = dragStore[r.gameObject];
//恢复角阻力
r.angularDrag = angularStore[r.gameObject];
//移除阻力
dragStore.Remove(r.gameObject);
//移除角阻力
angularStore.Remove(r.gameObject);
} else {
//重置阻力
r.drag = 0f;
//重置角阻力
r.angularDrag = 0.05f;
print("Object left water: couldn't get drag values, restored to defaults");
}
}
}
}Water
视频:https://pan.baidu.com/s/1mhF7hmo
项目:https://pan.baidu.com/s/1pL6nMTP