private void UpdateCollisions(CameraStateOutputNewComponent calsOut, CameraFinalOutputNewComponent camera,
Vector3 punchRotation)
{
Vector3 lToCamera = calsOut.Offset;
float lNewDistance = lToCamera.magnitude;
bool collided = false;
var archorRotation = Quaternion.Euler(0, calsOut.ArchorEulerAngle.y, 0);
var postOffsetFactor = ActualStartingPosition(
calsOut.ArchorPosition + archorRotation * calsOut.ArchorOffset, archorRotation,
calsOut.ArchorPostOffset + calsOut.PostOffset, _collisionLayers);
var startingPosition = calsOut.FinalArchorPosition =
calsOut.ArchorPosition + archorRotation * (calsOut.ArchorOffset +
calsOut.ArchorPostOffset * postOffsetFactor +
calsOut.PostOffset * postOffsetFactor);
var startingRotation = Quaternion.Euler(calsOut.ArchorEulerAngle + calsOut.EulerAngle + punchRotation);
float actualDistance = ActualDistance(startingRotation, startingPosition, lNewDistance, _collisionLayers);
var factor = 1f;
if (actualDistance < lNewDistance)
{
if (actualDistance < _collisionOffsetStartDistance)
{
factor = actualDistance / lNewDistance;
startingPosition = calsOut.ArchorPosition + archorRotation * (calsOut.ArchorOffset +
calsOut.ArchorPostOffset * factor *
postOffsetFactor +
calsOut.PostOffset * postOffsetFactor *
factor);
actualDistance = ActualDistance(startingRotation, startingPosition, lNewDistance, _collisionLayers);
}
}
camera.PlayerFocusPosition = startingPosition;
camera.Position = startingPosition + startingRotation * (calsOut.Offset.normalized * actualDistance);
camera.EulerAngle = calsOut.ArchorEulerAngle + calsOut.EulerAngle + punchRotation;
camera.EulerAngle.x = YawPitchUtility.Normalize(camera.EulerAngle.x);
camera.EulerAngle.y = YawPitchUtility.Normalize(camera.EulerAngle.y);
camera.EulerAngle.z = YawPitchUtility.Normalize(camera.EulerAngle.z);
camera.Fov = calsOut.Fov;
camera.Far = calsOut.Far;
camera.Near = calsOut.Near;
#if UNITY_EDITOR
var p1 = calsOut.ArchorPosition;
var p2 = calsOut.ArchorPosition + archorRotation * calsOut.ArchorOffset;
var p3 = calsOut.ArchorPosition +
archorRotation * (calsOut.ArchorOffset + calsOut.ArchorPostOffset * factor * postOffsetFactor);
var p4 = calsOut.ArchorPosition +
archorRotation * (calsOut.ArchorOffset + calsOut.ArchorPostOffset * factor * postOffsetFactor +
calsOut.PostOffset * postOffsetFactor * factor);
var p5 = p4 + startingRotation * (calsOut.Offset.normalized * actualDistance);
Debug.DrawLine(p1, p2, Color.red);
Debug.DrawLine(p2, p3, Color.green);
Debug.DrawLine(p3, p4, Color.blue);
Debug.DrawLine(p4, p5, Color.yellow);
#endif
}
private void UpdateCollisions(CameraStateOutputNewComponent calsOut, CameraFinalOutputNewComponent camera,
Vector3 punchRotation, PlayerEntity player)
{
Vector3 lToCamera = calsOut.Offset;
var clientTime = player.time.ClientTime;
float lNewDistance = lToCamera.magnitude;
bool collided = false;
var startingRotation = Quaternion.Euler(calsOut.ArchorEulerAngle + calsOut.EulerAngle + punchRotation);
var realArchorStart = calsOut.ArchorOffset;
if (player.stateInterface.State.GetActionState() != ActionInConfig.Gliding &&
player.stateInterface.State.GetActionState() != ActionInConfig.Parachuting &&
player.gamePlay.GameState != Components.GameState.AirPlane)
{
TestArchorOffset(calsOut, player, ref realArchorStart);
}
var archorRotation = Quaternion.Euler(0, calsOut.ArchorEulerAngle.y, 0);
var postOffsetFactor = ActualStartingPosition(
calsOut.ArchorPosition + archorRotation * realArchorStart, archorRotation,
calsOut.ArchorPostOffset + calsOut.PostOffset, _collisionLayers);
var startingPosition = calsOut.FinalArchorPosition =
calsOut.ArchorPosition + archorRotation * (realArchorStart +
calsOut.ArchorPostOffset * postOffsetFactor +
calsOut.PostOffset * postOffsetFactor);
float actualDistance = ActualDistance(startingRotation, startingPosition, lNewDistance, _collisionLayers);
var factor = 1f;
if (actualDistance < lNewDistance)
{
collided = true;
if (actualDistance < _collisionOffsetStartDistance)
{
factor = Mathf.Lerp(_collisionOffsetStartDistance, actualDistance, actualDistance / lNewDistance) / lNewDistance;
startingPosition = calsOut.ArchorPosition + archorRotation * (realArchorStart +
calsOut.ArchorPostOffset * factor *
postOffsetFactor +
calsOut.PostOffset * postOffsetFactor *
factor);
actualDistance = ActualDistance(startingRotation, startingPosition, lNewDistance, _collisionLayers);
if (actualDistance >= lNewDistance)
{
collided = false;
}
}
}
var finalPostOffset = calsOut.Offset.normalized * actualDistance;
if (collided && !player.appearanceInterface.Appearance.IsFirstPerson)
{
camera.LastCollisionOffset = finalPostOffset;
camera.LastCollisionTime = clientTime;
}
else if (clientTime - camera.LastCollisionTime < camera.PostTransitionTime &&
!player.appearanceInterface.Appearance.IsFirstPerson)
{
finalPostOffset = PositionLerp(camera.LastCollisionOffset, finalPostOffset,
(float)(clientTime - camera.LastCollisionTime) / camera.PostTransitionTime);
}
camera.PlayerFocusPosition = startingPosition;
camera.Position = startingPosition + startingRotation * (finalPostOffset);
camera.EulerAngle = calsOut.ArchorEulerAngle + calsOut.EulerAngle + punchRotation;
camera.EulerAngle.x = YawPitchUtility.Normalize(camera.EulerAngle.x);
camera.EulerAngle.y = YawPitchUtility.Normalize(camera.EulerAngle.y);
camera.EulerAngle.z = YawPitchUtility.Normalize(camera.EulerAngle.z);
camera.Fov = calsOut.Fov;
camera.Far = calsOut.Far;
camera.Near = calsOut.Near;
#if UNITY_EDITOR
var p1 = calsOut.ArchorPosition;
var p2 = calsOut.ArchorPosition + archorRotation * calsOut.ArchorOffset;
var p3 = calsOut.ArchorPosition +
archorRotation * (calsOut.ArchorOffset + calsOut.ArchorPostOffset * factor * postOffsetFactor);
var p4 = calsOut.ArchorPosition +
archorRotation * (calsOut.ArchorOffset + calsOut.ArchorPostOffset * factor * postOffsetFactor +
calsOut.PostOffset * postOffsetFactor * factor);
var p5 = p4 + startingRotation * (calsOut.Offset.normalized * actualDistance);
Debug.DrawLine(p1, p2, Color.red);
Debug.DrawLine(p2, p3, Color.green);
Debug.DrawLine(p3, p4, Color.blue);
Debug.DrawLine(p4, p5, Color.yellow);
#endif
}
private void UpdateTransform(PlayerEntity player)
{
//rootMotion控制人物移动
if (!player.thirdPersonAnimator.UnityAnimator.applyRootMotion)
{
player.playerMoveByAnimUpdate.NeedUpdate = false;
return;
}
var parent = player.RootGo().transform;
var child = player.thirdPersonModel.Value.transform;
parent.Translate(Vector3.right * child.localPosition.x);
parent.Translate(Vector3.up * child.localPosition.y);
parent.Translate(Vector3.forward * child.localPosition.z);
child.localPosition = Vector3.zero;
child.localRotation = Quaternion.identity;
player.playerMoveByAnimUpdate.NeedUpdate = true;
player.playerMoveByAnimUpdate.Position = player.position.Value = parent.position;
player.playerMoveByAnimUpdate.ModelPitch = player.orientation.ModelPitch = YawPitchUtility.Normalize(parent.rotation.eulerAngles.x);
player.playerMoveByAnimUpdate.ModelYaw = player.orientation.ModelYaw = YawPitchUtility.Normalize(parent.rotation.eulerAngles.y);
if (player.hasPlayerMove)
{
player.playerMove.Velocity = Vector3.zero;
}
if (player.hasMoveUpdate)
{
player.moveUpdate.Velocity = Vector3.zero;
}
}
private Vector3 CalcSkyMovePlayerRotation(ref Vector3 originAngles, bool isGliding,
Vector3 forwardMove, Vector3 rightMove, float deltaTime)
{
originAngles.x = YawPitchUtility.Normalize(originAngles.x);
originAngles.y = YawPitchUtility.Normalize(originAngles.y);
originAngles.z = YawPitchUtility.Normalize(originAngles.z);
var rotation = Quaternion.Euler(originAngles);
//roll move (around z)
var right = rotation.Right();
var rollFrac = Vector3.Dot(right, rightMove);
var targetRoll = -rollFrac * MaxRollAngle;
var rspeed = targetRoll * originAngles.z < 0 || Mathf.Abs(targetRoll) < Mathf.Abs(originAngles.z) ? RollBackSpeed : RollSpeed;
var roll = Mathf.MoveTowards(originAngles.z, targetRoll, rspeed * deltaTime);
//pitch move (around x)
var forward = rotation.Forward();
var pitchFrac = Vector3.Dot(forward, forwardMove);
var pitchUpAngle = MaxPitchUpAngle;
var pitchDownAngle = MaxPitchDownAngle;
float targetPitch = 0;
if (pitchFrac <= 0)
{
targetPitch = pitchFrac * pitchUpAngle;
}
else
{
if (isGliding)
{
var forwardMoveDir = forwardMove.normalized;
targetPitch = Mathf.Acos(Vector3.Dot(-Vector3.up, forwardMoveDir)) * Mathf.Rad2Deg;
if (targetPitch + IdlePitchAngle > 90)
{
targetPitch = pitchFrac * pitchDownAngle;
}
else
{
targetPitch = 90 - targetPitch - IdlePitchAngle;
targetPitch = Mathf.Clamp(targetPitch, 0, MaxPitchDownAngle);
}
}
else
{
targetPitch = pitchFrac * pitchDownAngle;
}
}
targetPitch += IdlePitchAngle;
// Debug.LogFormat("targetpitch is {0} {1}", targetPitch, originAngles.x);
var ptichSpeedFrac = (originAngles.x <= IdlePitchAngle ? Mathf.Abs(pitchUpAngle) : Mathf.Abs(pitchDownAngle)) /
(Mathf.Abs(pitchUpAngle) + Mathf.Abs(pitchDownAngle));
var pitch = Mathf.MoveTowards(originAngles.x, targetPitch, ptichSpeedFrac * PitchSpeed * deltaTime);
//yaw move (around y)
var yaw = originAngles.y - YawSpeed * roll / MaxRollAngle;
return(new Vector3(pitch, yaw, roll));
}
public void ExecuteUserCmd(IPlayerUserCmdGetter getter, IUserCmd cmd)
{
if (cmd.IsUseAction && cmd.UseType == (int)EUseActionType.Door)
{
var entity =
_mapContext.GetEntityWithEntityKey(new EntityKey(cmd.UseEntityId, (int)EEntityType.MapObject));
if (getter.OwnerEntity != null)
{
var player = (PlayerEntity)getter.OwnerEntity;
if (player != null && player.hasGamePlay)
{
player.gamePlay.UseEntityId = cmd.UseEntityId;
}
}
if (entity == null && (SharedConfig.IsServer || SharedConfig.IsOffline))
{
_listener.CreateMapObj(cmd.UseEntityId);
entity = _mapContext.GetEntityWithEntityKey(new EntityKey(cmd.UseEntityId, (int)EEntityType.MapObject));
if (entity == null)
{
_logger.ErrorFormat("Door Entity {0} does not exist!", cmd.UseEntityId);
return;
}
}
if (!SharedConfig.IsServer && !SharedConfig.IsOffline)
{
var player = (PlayerEntity)getter.OwnerEntity;
player.autoMoveInterface.PlayerAutoMove.StopAutoMove();
player.StateInteractController().InterruptCharactor();
player.stateInterface.State.OpenDoor();
return;
}
var door = entity as MapObjectEntity;
if (door == null)
{
_logger.ErrorFormat("entity {0} is not door", cmd.UseEntityId);
}
if (!door.hasDoorRotate && door.doorData.IsOpenable())
{
var player = (PlayerEntity)getter.OwnerEntity;
player.autoMoveInterface.PlayerAutoMove.StopAutoMove();
var go = door.rawGameObject.Value;
var playerPosition = player.RootGo().transform.position;
var doorPosition = go.transform.position;
var direction = (playerPosition - doorPosition);
var dot = Vector3.Dot(direction, go.transform.forward);
var rot = go.transform.localEulerAngles.y;
rot = YawPitchUtility.Normalize(rot);
float from = rot, to = 0;
var state = door.doorData.State;
var endState = state;
if (dot > 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMaxAngle;
endState = (int)DoorState.OpenMax;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
else if (dot < 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMinAngle;
endState = (int)DoorState.OpenMin;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
if (endState != state)
{
player.StateInteractController().InterruptCharactor();
player.stateInterface.State.OpenDoor();
var audioId = endState == (int)DoorState.Closed ? EAudioUniqueId.CloseDoor : EAudioUniqueId.OpenDoor;
SimpleProto sp = FreePool.Allocate();
sp.Key = FreeMessageConstant.PlaySound;
sp.Ks.Add(2);
sp.Ins.Add((int)audioId);
sp.Bs.Add(true);
FreeMessageSender.SendMessage(player, sp);
//player.AudioController().PlaySimpleAudio(audioId);
if (SharedConfig.IsServer || SharedConfig.IsOffline)
{
door.doorData.State = (int)DoorState.Rotating;
door.AddDoorRotate(from, from, to, endState);
_logger.DebugFormat("Trigger Door From {0} {1} To {2} {3}",
state, from, endState, to);
}
}
}
}
}
public virtual void Rotate(Quaternion target, float deltaTime)
{
_motor.CharacterController.SetDeltaRot(new Vector3(0, YawPitchUtility.CalcDeltaAngle(_motor.transform.rotation.eulerAngles.y, target.eulerAngles.y), 0));
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
if (cmd.IsUseAction && cmd.UseType == (int)EUseActionType.Door)
{
var entity = MapObjectUtility.GetMapObjByRawId(cmd.UseEntityId, (int)ETriggerObjectType.Door);
if (entity == null && (SharedConfig.IsServer || SharedConfig.IsOffline))
{
_listener.CreateMapObj(cmd.UseEntityId);
entity = MapObjectUtility.GetMapObjByRawId(cmd.UseEntityId, (int)ETriggerObjectType.Door);
if (entity == null)
{
_logger.ErrorFormat("Door Entity {0} does not exist!", cmd.UseEntityId);
return;
}
}
if (!SharedConfig.IsServer && !SharedConfig.IsOffline)
{
var player = (PlayerEntity)owner.OwnerEntity;
player.autoMoveInterface.PlayerAutoMove.StopAutoMove();
player.stateInterface.State.OpenDoor();
if (player.AudioController() != null)
{
player.AudioController().PlaySimpleAudio(EAudioUniqueId.OpenDoor);
}
return;
}
var door = entity as MapObjectEntity;
if (door == null)
{
_logger.ErrorFormat("entity {0} is not door", cmd.UseEntityId);
}
if (!door.hasDoorRotate && door.doorData.IsOpenable())
{
var player = (PlayerEntity)owner.OwnerEntity;
player.autoMoveInterface.PlayerAutoMove.StopAutoMove();
var go = door.rawGameObject.Value;
var playerPosition = player.RootGo().transform.position;
var doorPosition = go.transform.position;
var direction = (playerPosition - doorPosition);
var dot = Vector3.Dot(direction, go.transform.forward);
var rot = go.transform.localEulerAngles.y;
rot = YawPitchUtility.Normalize(rot);
float from = rot, to = 0;
var state = door.doorData.State;
var endState = state;
if (dot > 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMaxAngle;
endState = (int)DoorState.OpenMax;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
else if (dot < 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMinAngle;
endState = (int)DoorState.OpenMin;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
if (endState != state)
{
player.stateInterface.State.OpenDoor();
if (player.AudioController() != null)
{
player.AudioController().PlaySimpleAudio(EAudioUniqueId.OpenDoor);
}
if (SharedConfig.IsServer || SharedConfig.IsOffline)
{
door.doorData.State = (int)DoorState.Rotating;
door.AddDoorRotate(from, from, to, endState);
_logger.DebugFormat("Trigger Door From {0} {1} To {2} {3}",
state, from, endState, to);
}
}
}
}
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
if (cmd.IsUseAction && cmd.UseType == (int)EUseActionType.Door)
{
var door = _context.GetEntityWithEntityKey(new Core.EntityComponent.EntityKey(cmd.UseEntityId, (short)EEntityType.MapObject));
if (door == null)
{
_logger.ErrorFormat("Door Entity {0} does not exist!", cmd.UseEntityId);
return;
}
if (!door.hasDoorRotate && door.doorData.IsOpenable())
{
var player = (PlayerEntity)owner.OwnerEntity;
player.autoMoveInterface.PlayerAutoMove.StopAutoMove();
var go = door.rawGameObject.Value;
var playerPosition = player.RootGo().transform.position;
var doorPosition = go.transform.position;
var direction = (playerPosition - doorPosition);
var dot = Vector3.Dot(direction, go.transform.forward);
var rot = go.transform.localEulerAngles.y;
rot = YawPitchUtility.Normalize(rot);
float from = rot, to = 0;
var state = door.doorData.State;
var endState = state;
if (dot > 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMaxAngle;
endState = (int)DoorState.OpenMax;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
else if (dot < 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMinAngle;
endState = (int)DoorState.OpenMin;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
if (endState != state)
{
player.stateInterface.State.OpenDoor();
if (SharedConfig.IsServer || SharedConfig.IsOffline)
{
door.doorData.State = (int)DoorState.Rotating;
door.AddDoorRotate(from, from, to, endState);
_logger.DebugFormat("Trigger Door From {0} {1} To {2} {3}",
state, from, endState, to);
//switch((DoorState)endState)
//{
// case DoorState.Closed:
// player.soundManager.Value.PlayOnce(XmlConfig.EPlayerSoundType.CloseDoor);
// break;
// case DoorState.OpenMax:
// case DoorState.OpenMin:
// player.soundManager.Value.PlayOnce(XmlConfig.EPlayerSoundType.OpenDoor);
// break;
//}
}
}
}
}
}
public static void UpdateTransform(PlayerEntity player, float deltaTime)
{
var parent = player.RootGo().transform;
var child = player.thirdPersonModel.Value.transform;
var pos = child.localPosition - ModelInitPosition;
var rotation = child.localRotation;
parent.Translate(Vector3.right * pos.x);
parent.Translate(Vector3.up * pos.y);
parent.Translate(Vector3.forward * pos.z);
parent.rotation *= rotation;
child.localPosition = ModelInitPosition;
child.localRotation = Quaternion.identity;
player.playerMoveByAnimUpdate.NeedUpdate = true;
player.position.Value = parent.position;
player.playerMoveByAnimUpdate.Position = parent.position.ShiftedToFixedVector3();
player.playerMoveByAnimUpdate.ModelPitch = player.orientation.ModelPitch = YawPitchUtility.Normalize(parent.rotation.eulerAngles.x);
player.playerMoveByAnimUpdate.ModelYaw = player.orientation.ModelYaw = YawPitchUtility.Normalize(parent.rotation.eulerAngles.y);
if (player.hasPlayerMove)
{
player.playerMove.Velocity = Vector3.zero;
}
if (player.hasMoveUpdate)
{
player.moveUpdate.Velocity = Vector3.zero;
}
}
