public bool RayCast(Ray castRay, float maxDistance, out PECapsuleHitResult result)
{
UpdateInfo();
bool getpos = false;
result = null;
float minDis = maxDistance;
Vector3 rayPos1 = castRay.origin, rayPos2 = castRay.origin + castRay.direction.normalized * maxDistance;
PECapsuleHitResult findResult;
for (int i = 0; i < defenceParts.Length; i++)
{
if (!defenceParts[i].capsule.enable)
{
continue;
}
if (defenceParts[i].capsule.CheckCollision(rayPos1, rayPos2, out findResult))
{
getpos = true;
float dis = Vector3.Magnitude(rayPos1 - findResult.hitPos);
if (dis < minDis)
{
minDis = dis;
result = findResult;
result.hitDefenceType = defenceParts[i].defenceType;
result.damageScale = defenceParts[i].damageScale;
result.distance = Vector3.Distance(findResult.hitPos, castRay.origin);
}
}
}
return(getpos);
}
// return : checkpos inside the Capsule
public bool GetClosestPos(Vector3 pos, out PECapsuleHitResult result)
{
result = new PECapsuleHitResult();
result.hitPos = Vector3.zero;
result.hitDir = Vector3.zero;
result.selfTrans = trans;
result.hitTrans = trans;
result.distance = Mathf.Infinity;
if (null != trans)
{
Vector3 closestPos = WhiteCat.Utility.ClosestPoint(m_CenterPos1, m_CenterPos2, pos);
Vector3 dir = closestPos - pos;
float dis = dir.magnitude;
result.hitDir = dir.normalized;
if (dis < scaledRadius)
{
result.hitPos = pos;
result.distance = 0;
return(true);
}
result.hitPos = closestPos - result.hitDir * scaledRadius;
result.distance = dis - scaledRadius;
return(false);
}
return(false);
}
void OnHitTrigger(PEDefenceTrigger hitTrigger, PECapsuleHitResult result)
{
if (hitTrigger.transform.IsChildOf(motionMgr.transform))
{
return;
}
animScaleStartTime = Time.time;
// PESkEntity skEntity = hitTrigger.GetComponentInParent<PESkEntity>();
}
public bool GetClosest(Vector3 pos, float maxDistance, out PECapsuleHitResult result)
{
UpdateInfo();
bool getpos = false;
float minDis = maxDistance;
result = null;
PECapsuleHitResult findResult;
for (int i = 0; i < defenceParts.Length; i++)
{
if (!defenceParts[i].capsule.enable)
{
continue;
}
if (defenceParts[i].capsule.GetClosestPos(pos, out findResult))
{
findResult.hitDir = Vector3.Normalize(centerBone.position - pos);
findResult.hitDefenceType = defenceParts[i].defenceType;
findResult.damageScale = defenceParts[i].damageScale;
result = findResult;
return(true);
}
else
{
bool isCenterBone = (defenceParts[i].capsule.trans == centerBone);
if (isCenterBone ? (findResult.distance > maxDistance) : (findResult.distance > minDis))
{
continue;
}
findResult.hitDefenceType = defenceParts[i].defenceType;
findResult.damageScale = defenceParts[i].damageScale;
result = findResult;
if (isCenterBone)
{
return(true);
}
minDis = findResult.distance;
getpos = true;
}
}
return(getpos);
}
void OnHit(PEDefenceTrigger defenceTrigger, PECapsuleHitResult result)
{
if (null != m_PEEntity && m_PEEntity.IsDeath())
{
return;
}
if (null != defenceTrigger)
{
SkEntity hitEntity = defenceTrigger.GetComponentInParent <SkEntity>();
bool isTerrain = PETools.PEUtil.IsVoxelOrBlock45(hitEntity);
if (isTerrain || PETools.PEUtil.CanDamage(m_SkEntity, hitEntity))
{
if (null != onHitSkEntity)
{
onHitSkEntity(hitEntity);
}
}
else
{
return;
}
}
if (null != onHitTrigger)
{
onHitTrigger(defenceTrigger, result);
}
if (null != m_SkEntity)
{
m_SkEntity.CollisionCheck(result);
}
if (null != m_PEEntity)
{
m_PEEntity.SendMsg(EMsg.Battle_AttackHit, result);
}
#if UNITY_EDITOR
if (showDebugInfo)
{
DrawArrow arrow = new DrawArrow();
arrow.pos = result.hitPos;
arrow.rot = Quaternion.LookRotation(result.hitDir);
hitResults.Add(arrow);
}
#endif
}
public bool CheckCollision(PECapsuleTrigger other, out PECapsuleHitResult result)
{
int count1 = Mathf.FloorToInt(0.5f * moveDir1.magnitude / scaledRadius) + 1;
int count2 = Mathf.FloorToInt(0.5f * moveDir2.magnitude / scaledRadius) + 1;
//Vector3 normalizedMoveDir1 = moveDir1.normalized;
//Vector3 normalizedMoveDir2 = moveDir2.normalized;
float radius11 = Vector3.Distance(m_LastCenterPos1, m_ParentCenterPos);
float radius12 = Vector3.Distance(m_CenterPos1, m_ParentCenterPos);
float radius21 = Vector3.Distance(m_LastCenterPos2, m_ParentCenterPos);
float radius22 = Vector3.Distance(m_CenterPos2, m_ParentCenterPos);
int count = Mathf.Max(count1, count2);
float pCount = count > 1 ? count - 1 : count;
for (int i = 0; i < count; ++i)
{
float p = i / pCount;
Vector3 checkPoint1 = Vector3.Lerp(m_LastCenterPos1, m_CenterPos1, p);
Vector3 checkPoint2 = Vector3.Lerp(m_LastCenterPos2, m_CenterPos2, p);
if (m_ParentCenterPos != Vector3.zero)
{
if (checkPoint1 != m_ParentCenterPos)
{
checkPoint1 = m_ParentCenterPos + (checkPoint1 - m_ParentCenterPos).normalized * Mathf.Lerp(radius11, radius12, p);
}
if (checkPoint2 != m_ParentCenterPos)
{
checkPoint2 = m_ParentCenterPos + (checkPoint2 - m_ParentCenterPos).normalized * Mathf.Lerp(radius21, radius22, p);
}
}
if (CheckCollision(checkPoint1, checkPoint2, other, out result))
{
return(true);
}
}
result = null;
return(false);
}
//
public bool CheckCollision(Vector3 pos1, Vector3 pos2, out PECapsuleHitResult result)
{
Vector3 closestPosSelf;
Vector3 closestPosOther;
WhiteCat.Utility.ClosestPoint(m_CenterPos1, m_CenterPos2, pos1, pos2, out closestPosSelf, out closestPosOther);
Vector3 dir = closestPosOther - closestPosSelf;
if (dir.sqrMagnitude < scaledRadius * scaledRadius)
{
result = new PECapsuleHitResult();
result.selfTrans = trans;
result.hitTrans = trans;
result.hitDir = Vector3.Normalize(pos2 - pos1);
result.hitPos = closestPosOther - result.hitDir * Mathf.Sqrt(scaledRadius * scaledRadius - dir.sqrMagnitude);
result.distance = 0;
return(true);
}
result = null;
return(false);
}
bool CheckCollision(Vector3 pos1, Vector3 pos2, PECapsuleTrigger other, out PECapsuleHitResult result)
{
Vector3 closestPosSelf;
Vector3 closestPosOther;
WhiteCat.Utility.ClosestPoint(pos1, pos2, other.m_CenterPos1, other.m_CenterPos2, out closestPosSelf, out closestPosOther);
Vector3 dir = closestPosOther - closestPosSelf;
float radiusSum = scaledRadius + other.scaledRadius;
if (dir.sqrMagnitude < radiusSum * radiusSum)
{
result = new PECapsuleHitResult();
result.selfTrans = trans;
result.hitTrans = other.trans;
result.hitPos = closestPosSelf + dir * scaledRadius / radiusSum;
result.hitDir = (moveDir1 + moveDir2 + dir).normalized;
result.distance = 0;
return(true);
}
result = null;
return(false);
}
bool CheckHit(PEDefenceTrigger defenceTrigger)
{
defenceTrigger.UpdateInfo();
PECapsuleHitResult mostCross = null;
for (int i = 0; i < attackParts.Length; i++)
{
if (attackParts[i].capsule.enable)
{
for (int j = 0; j < defenceTrigger.defenceParts.Length; j++)
{
if (defenceTrigger.defenceParts[j].capsule.enable)
{
PECapsuleHitResult result;
if (attackParts[i].capsule.CheckCollision(defenceTrigger.defenceParts[j].capsule, out result))
{
result.selfAttackForm = attackParts[i].attackForm;
result.hitDefenceType = defenceTrigger.defenceParts[j].defenceType;
result.damageScale = defenceTrigger.defenceParts[j].damageScale;
if (null == mostCross || mostCross.distance < result.distance)
{
mostCross = result;
}
}
}
}
}
}
if (null != mostCross)
{
OnHit(defenceTrigger, mostCross);
return(true);
}
return(false);
}
void OnHitCollider(Collider other)
{
if (null == m_SkEntity)
{
return;
}
if (null != m_PEEntity && m_PEEntity.IsDeath())
{
return;
}
SkEntity hitEntity = other.gameObject.GetComponentInParent <SkEntity>();
bool isTerrain = PETools.PEUtil.IsVoxelOrBlock45(hitEntity);
if (null == hitEntity || m_HitEntitys.Contains(hitEntity) || (!isTerrain && !PETools.PEUtil.CanDamage(m_SkEntity, hitEntity)))
{
return;
}
m_HitEntitys.Add(hitEntity);
PECapsuleHitResult result = null;
bool getpos = false;
float minDis = 100f;
PECapsuleHitResult findResult;
for (int i = 0; i < attackParts.Length; i++)
{
if (!attackParts[i].capsule.enable)
{
continue;
}
if (attackParts[i].capsule.GetClosestPos(other.transform.position, out findResult))
{
result = findResult;
result.selfAttackForm = attackParts[i].attackForm;
result.hitTrans = other.transform;
result.damageScale = 1f;
return;
}
else if (findResult.distance < minDis)
{
minDis = findResult.distance;
result = findResult;
result.hitTrans = other.transform;
result.selfAttackForm = attackParts[i].attackForm;
result.damageScale = 1f;
getpos = true;
}
}
if (getpos)
{
m_SkEntity.CollisionCheck(result);
if (null != onHitSkEntity)
{
onHitSkEntity(hitEntity);
}
}
}
void OnCollisionEnter(Collision colInfo)
{
GameObject go = colInfo.collider.gameObject;
if (go.layer == Layer.TreeStatic)
{
// Proceed one each time
/*
* ContactPoint point = colInfo.contacts[0];
* Vector3 vPt = point.point;
* int x = Mathf.CeilToInt(vPt.x);
* int y = Mathf.CeilToInt(vPt.y);
* int z = Mathf.CeilToInt(vPt.z);
* for(int dx = 0; dx < 2; dx++) {
* for(int dy = 0; dx < 2; dx++) {
* for(int dx = 0; dx < 2; dx++) {
* }
* }
* }
*/
}
else if (go.layer == Layer.NearTreePhysics)
{
if (Pathea.PeGameMgr.IsStory || Pathea.PeGameMgr.IsAdventure)
{
PeEntity entity = GetComponentInParent <PeEntity>();
if (Pathea.PeGameMgr.IsStory)
{
if (entity != null)
{
if (entity.Field == MovementField.Sky && entity.commonCmpt.entityProto.proto == EEntityProto.Monster)
{
if (entity.maxRadius < MinCmpt(colInfo.collider.bounds.extents) * 2f)
{
return;
}
}
else if (entity.carrier)
{
if (colInfo.relativeVelocity.magnitude * entity.carrier.rigidbody.mass
< MinCmpt(colInfo.collider.bounds.extents) * PEVCConfig.instance.treeHardness)
{
return;
}
}
GlobalTreeInfo tree = LSubTerrainMgr.TryGetTreeInfo(go);
if (tree != null)
{
LSubTerrainMgr.DeleteTree(go);
LSubTerrainMgr.RefreshAllLayerTerrains();
SkEntitySubTerrain.Instance.SetTreeHp(tree.WorldPos, 0);
StroyManager.Instance.TreeCutDown(entity.position, tree._treeInfo, tree.WorldPos);
}
}
}
else // Pathea.PeGameMgr.IsAdventure
{
if (entity != null)
{
if (entity.Field == MovementField.Sky && entity.commonCmpt.entityProto.proto == EEntityProto.Monster)
{
if (entity.maxRadius < MinCmpt(colInfo.collider.bounds.extents) * 2f)
{
return;
}
}
else if (entity.carrier)
{
if (colInfo.relativeVelocity.magnitude * entity.carrier.rigidbody.mass
< MinCmpt(colInfo.collider.bounds.extents) * PEVCConfig.instance.treeHardness)
{
return;
}
}
TreeInfo tree = RSubTerrainMgr.TryGetTreeInfo(go);
if (tree != null)
{
RSubTerrainMgr.DeleteTree(go);
RSubTerrainMgr.RefreshAllLayerTerrains();
SkEntitySubTerrain.Instance.SetTreeHp(tree.m_pos, 0);
StroyManager.Instance.TreeCutDown(entity.position, tree, tree.m_pos);
}
}
}
}
}
//50吨以15米/秒速度撞击的伤害缩放为1 50 * 15 * 15 = 11250
else if (go.layer == Layer.AIPlayer || go.layer == Layer.Player)
{
PeEntity target = go.GetComponentInParent <PeEntity>();
if (target != null && m_Entity != null && m_Entity.carrier != null && colInfo.relativeVelocity.sqrMagnitude > 2.0f * 2.0f)
{
NetCmpt net = m_Entity.GetComponent <NetCmpt>();
if (net == null || net.IsController)
{
float scale = 1.0f / 11250.0f;
float mass = m_Entity.carrier.creationController.creationData.m_Attribute.m_Weight * 0.001f;
float speed = colInfo.relativeVelocity.sqrMagnitude;
float damageScale = Mathf.Clamp(mass * speed * scale, 0.0f, 2.0f);
//Debug.LogError("Mass:" + mass + " Speed:" + speed + " Scale:" + damageScale);
if (m_RigidBody == null || m_RigidBody.velocity.sqrMagnitude < 5.0f * 5.0f || damageScale < 0.01)
{
damageScale = 0.0f;
}
else
{
PECapsuleHitResult hitResult = new PECapsuleHitResult();
hitResult.selfTrans = transform;
hitResult.hitTrans = go.transform;
hitResult.hitPos = colInfo.contacts[0].point;
hitResult.hitDir = -colInfo.contacts[0].normal;
hitResult.damageScale = damageScale;
m_Entity.skEntity.CollisionCheck(hitResult);
//if(go.layer == Layer.Player && target.NpcCmpt != null && speed > 10.0f*10.0f)
//{
// if(target.biologyViewCmpt != null)
// {
// RagdollHitInfo hitInfo = new RagdollHitInfo();
// hitInfo.hitTransform = target.biologyViewCmpt.monoRagdollCtrlr.ragdollRootBone;
// hitInfo.hitPoint = colInfo.contacts[0].point;
// hitInfo.hitNormal = colInfo.contacts[0].normal;
// hitInfo.hitForce = colInfo.impulse;
// target.biologyViewCmpt.ActivateRagdoll(hitInfo);
// }
//}
}
}
}
}
//50吨以15米/秒速度撞击的伤害缩放为1 50 * 15 * 15 = 11250
if (go.layer == Layer.VFVoxelTerrain ||
go.layer == Layer.TreeStatic
//|| go.layer == Layer.NearTreePhysics
|| go.layer == Layer.Building ||
go.layer == Layer.SceneStatic ||
go.layer == Layer.Unwalkable ||
go.layer == Layer.GIEProductLayer)
{
bool isWheel = false;
if (go.layer == Layer.VFVoxelTerrain)
{
for (int i = 0; i < colInfo.contacts.Length; i++)
{
if (colInfo.contacts[i].thisCollider.gameObject.GetComponentInParent <VCPVehicleWheel>() != null)
{
isWheel = true;
}
}
}
if (!isWheel && m_Entity != null && m_Entity.carrier != null && colInfo.relativeVelocity.sqrMagnitude > 2.0f * 2.0f)
{
NetCmpt net = m_Entity.GetComponent <NetCmpt>();
if (net == null || net.IsController)
{
float scale = 1.0f / 11250.0f;
float mass = m_Entity.carrier.creationController.creationData.m_Attribute.m_Weight * 0.001f;
float speed = colInfo.relativeVelocity.sqrMagnitude;
float damageScale = Mathf.Clamp(mass * speed * scale, 0.0f, 2.0f);
Vector3 v = m_RigidBody.velocity;
float curSpeed = Mathf.Sqrt(v.x * v.x + v.z * v.z) * 3.6f;
//Debug.LogError("Mass:" + mass + " Speed:" + speed + " Scale:" + damageScale);
if (curSpeed < 45f || damageScale < 0.01)
{
damageScale = 0.0f;
}
else
{
SkillSystem.SkEntity.MountBuff(m_Entity.skEntity, 30200174, new List <int> {
0
}, new List <float>()
{
damageScale
});
//PECapsuleHitResult hitResult = new PECapsuleHitResult();
//hitResult.selfTrans = transform;
//hitResult.hitTrans = go.transform;
//hitResult.hitPos = colInfo.contacts[0].point;
//hitResult.hitDir = -colInfo.contacts[0].normal;
//hitResult.damageScale = damageScale;
//m_Entity.skEntity.CollisionCheck(hitResult);
//Debug.LogError(go.name + " --> " + colInfo.relativeVelocity.magnitude);
}
}
}
}
}
