public static void Move(VehicleEntity vehicle, IVehicleCmd cmd)
{
var target = vehicle.GetController <MotorcycleController>();
var steerInput = Mathf.Clamp(cmd.MoveHorizontal, -1f, 1f);
var forwardInput = Mathf.Clamp(cmd.MoveVertical, -1f, 1f);
var horizontalShift = 0.0f;
if (cmd.IsLeftShift)
{
horizontalShift = target.horizontalMassShift - 0.1f;
}
else if (cmd.IsRightShift)
{
horizontalShift = target.horizontalMassShift + 0.1f;
}
horizontalShift = Mathf.Clamp(horizontalShift, -1f, 1f);
var stuntInput = 0.0f;
if (cmd.IsHandbrake)
{
stuntInput = target.HasAnyWheelOnGround() ? 0.0f : -1.0f;
}
else if (cmd.IsStunt)
{
stuntInput = target.HasAnyWheelOnGround() ? 0.0f : 1.0f;
}
target.SetInput(forwardInput, steerInput, cmd.IsSpeedup, cmd.IsHandbrake, cmd.IsHornOn, horizontalShift, stuntInput);
}
private void DirectSetStateFromCmd(VehicleEntity vehicle, IVehicleCmd cmd)
{
var vehicleCmd = (VehicleCmd)cmd;
var body = vehicleCmd.Body;
var controller = GetController(vehicle);
SetRudderAnglesFromCmd(controller, vehicleCmd);
VehicleDynamicPredictionUtility.SetControllerState(controller,
body.Position, body.Rotation,
body.LinearVelocity, body.AngularVelocity,
controller.IsSleeping, 0);
// var state = controller.GetShipState();
//
// state.IsFlagSync = true;
//
// state.Position = vehicleCmd.Body.Position;
// state.Rotation = vehicleCmd.Body.Rotation;
// state.BodyState.Body2WorldPosition = vehicleCmd.Body.Body2WorldPosition;
// state.BodyState.Body2WorldRotation = vehicleCmd.Body.Body2WorldRotation;
// state.BodyState.LinearVelocity = vehicleCmd.Body.LinearVelocity;
// state.BodyState.AngularVelocity = vehicleCmd.Body.AngularVelocity;
//
// var rudders = state.RudderStates;
// for (int i = 0; i < vehicleCmd.SteerableCount; ++i)
// {
// var rudder = rudders[i];
// var shipSteerable = vehicleCmd.Steerables[i].Ship;
// rudder.Angle = shipSteerable.Angle;
// rudder.Rpm = shipSteerable.Rpm;
// rudder.SpinVelocity = shipSteerable.SpinVelocity;
// rudder.Submerged = shipSteerable.Submerged;
// }
//
// controller.ApplyShipState();
}
public static void Move(VehicleEntity vehicle, IVehicleCmd cmd)
{
var target = vehicle.GetController <AdvancedShipController>();
var steerInput = Mathf.Clamp(cmd.MoveHorizontal, -1f, 1f);
var forwardInput = Mathf.Clamp(cmd.MoveVertical, -1f, 1f);
target.SetInput(forwardInput, steerInput, cmd.IsSpeedup);
}
public void Move(VehicleEntity vehicle, IVehicleCmd cmd)
{
if (!vehicle.hasGameObject)
{
return;
}
CarMoveInternal.Move(vehicle, cmd);
}
public static void MoveByCmd(VehicleEntity vehicle, IVehicleCmd cmd)
{
if (!vehicle.hasGameObject)
{
return;
}
var controllerType = vehicle.GetController <VehicleAbstractController>().ControllerType;
EntityAPI[(int)controllerType].Move(vehicle, cmd);
}
// private void MoveToCmdState(VehicleEntity vehicle, IVehicleCmd cmd)
// {
// //check state change
// var currentState = vehicle.GetCurrentVehicleState();
//
// // Find out how much of a correction we are making
// var deltaPos = newState.Position - currentState.Position;
// var deltaMagSq = deltaPos.sqrMagnitude;
// var bodyLinearSpeedSq = currentState.LinearVelocity.sqrMagnitude;
//
// // Snap position by default (big correction, or we are moving too slowly)
// var updatePos = newState.Position;
// var fixLinVel = Vector3.zero;
//
// // If its a small correction and velocity is above threshold, only make a partial correction,
// // and calculate a velocity that would fix it over 'fixTime'.
// if (deltaMagSq < PhysicErrorCorrection.Singleton.LinearDeltaThresholdSq &&
// bodyLinearSpeedSq > PhysicErrorCorrection.Singleton.BodySpeedThresholdSq)
// {
// updatePos = Vector3.Lerp(currentState.Position, newState.Position, PhysicErrorCorrection.Singleton.LinearInterpAlpha);
// fixLinVel = (newState.Position - updatePos) * PhysicErrorCorrection.Singleton.LinearRecipFixTime;
// }
//
//
// /////// ORIENTATION CORRECTION ///////
// // Get quaternion that takes us from old to new
// var currentQuat = Quaternion.Euler(currentState.Rotation);
// var newQuat = Quaternion.Euler(newState.Rotation);
//
// var invCurrentQuat = Quaternion.Inverse(currentQuat);
// var deltaQuat = newQuat * invCurrentQuat;
//
// var deltaAxis = new Vector3();
// var deltaAng = .0f;
// deltaQuat.ToAngleAxis(out deltaAng, out deltaAxis);
// //clamp to [-90, 90]
// if (deltaAng >= 180)
// {
// deltaAng = 360 - deltaAng;
// deltaAxis = -deltaAxis;
// }
//
// if (deltaAng >= 90)
// {
// deltaAng -= 180;
// }
//
// deltaAng *= Mathf.Deg2Rad;
//
// var updateRot = newState.Rotation;
// var fixAngVel = Vector3.zero;
// var absDeltaAng = Math.Abs(deltaAng);
// const float epsilon = 0.0001f;
// if (absDeltaAng < PhysicErrorCorrection.Singleton.AngularDeltaThreshold)
// {
// var updateQuat = Quaternion.Lerp(currentQuat, newQuat, PhysicErrorCorrection.Singleton.AngularInterpAlpha);
// updateRot = updateQuat.eulerAngles;
//
// if (absDeltaAng > epsilon)
// {
// fixAngVel = deltaAxis.normalized * deltaAng * (1.0f - PhysicErrorCorrection.Singleton.AngularInterpAlpha) * PhysicErrorCorrection.Singleton.AngularRecipFixTime;
// }
// }
// else
// {
// _logger.DebugFormat("Delta Angle is too large {0}", deltaAng);
// }
//
// if (deltaMagSq <= epsilon &&
// fixLinVel.sqrMagnitude <= epsilon &&
// deltaAng <= epsilon &&
// fixAngVel.sqrMagnitude <= epsilon)
// {
// return;
// }
//
// /////// STATE UPDATE ///////
// currentState.IsRemoteSync = true;
// currentState.IsSyncInput = isClientSide;
// currentState.SteerInput = newState.SteerInput;
// currentState.ThrottleInput = newState.ThrottleInput;
// currentState.BrakeInput = newState.BrakeInput;
// currentState.HandbrakeInput = newState.HandbrakeInput;
//
// currentState.Position = updatePos;
// currentState.Rotation = updateRot;
// currentState.LinearVelocity += fixLinVel;
// currentState.AngularVelocity += fixAngVel;
//
// //Update Wheels
//
// var wheelStates = currentState.WheelStates;
// Debug.Assert(wheelStates.Length == 4);
//
// wheelStates[0].SteerAngle = newState.SteerAngle0;
// wheelStates[1].SteerAngle = newState.SteerAngle1;
// wheelStates[2].SteerAngle = newState.SteerAngle2;
// wheelStates[3].SteerAngle = newState.SteerAngle3;
// }
private void SetStateFromCmd(VehicleEntity vehicle, IVehicleCmd cmd)
{
if (SharedConfig.DynamicPrediction)
{
DynamicPredictState(vehicle, cmd);
}
else
{
DirectSetStateFromCmd(vehicle, cmd);
}
}
public override void ExecuteVehicleCmd(Entity entity, IVehicleCmd cmd)
{
if (SharedConfig.ServerAuthorative)
{
base.ExecuteVehicleCmd(entity, cmd);
}
else
{
var vehicle = (VehicleEntity)entity;
VehicleStateUtility.ApplyVehicleCmdAndState(vehicle, cmd);
}
}
private void DynamicPredictState(VehicleEntity vehicle, IVehicleCmd cmd)
{
var vehicleCmd = (VehicleCmd)cmd;
var controller = GetController(vehicle);
var state = VehicleDynamicPredictionUtility.MoveToState(controller, vehicleCmd);
SetRudderAnglesFromCmd(controller, vehicleCmd);
VehicleDynamicPredictionUtility.SetControllerState(controller,
state.Position, state.Rotation,
state.LinearVelocity, state.AngularVelocity,
state.IsSleeping, state.SleepingOutSync);
}
#pragma warning restore RefCounter001
private void ExecuteCmdsInSubSystemsBetween(int startTime, int endTime)
{
foreach (IVehicleCmdOwner owner in _handler.VehicleCmdOwnerList)
{
_currentEntity = owner.Entity;
foreach (var userCmd in owner.GetCmdList(startTime, endTime))
{
_currentCmd = userCmd;
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("execute vehicle simulation {0}, at time {1} on vehicle {2}", startTime, userCmd.ExecuteTime, userCmd.VehicleId);
}
_logger.DebugFormat("Simulation Cmd is {0} seq {1} move {2} {3}", userCmd.ExecuteTime, userCmd.CmdSeq, userCmd.MoveHorizontal, userCmd.MoveVertical);
ExecuteVehicleSystems();
}
}
}
public void SetVehicleStateToCmd(VehicleEntity vehicle, IVehicleCmd cmd)
{
var vehicleCmd = (VehicleCmd)cmd;
var controller = GetController(vehicle);
vehicleCmd.VehicleType = (int)EVehicleType.Ship;
vehicleCmd.Body.Position = controller.cachedRigidbody.position.ShiftedToFixedVector3();
vehicleCmd.Body.Rotation = controller.cachedRigidbody.rotation;
vehicleCmd.Body.LinearVelocity = controller.Velocity;
vehicleCmd.Body.AngularVelocity = controller.AngularVelocity;
vehicleCmd.Body.IsSleeping = controller.IsSleeping;
var rudders = controller.rudders;
vehicleCmd.SteerableCount = rudders.Count;
for (int i = 0; i < rudders.Count; ++i)
{
vehicleCmd.Steerables[i].Ship.Angle = rudders[i].Angle;
}
// var state = controller.GetShipState();
// vehicleCmd.Body.Position = state.Position;
// vehicleCmd.Body.Rotation = state.Rotation;
// vehicleCmd.Body.Body2WorldPosition = state.BodyState.Body2WorldPosition;
// vehicleCmd.Body.Body2WorldRotation = state.BodyState.Body2WorldRotation;
// vehicleCmd.Body.LinearVelocity = state.BodyState.LinearVelocity;
// vehicleCmd.Body.AngularVelocity = state.BodyState.AngularVelocity;
//
// var rudders = state.RudderStates;
// vehicleCmd.SteerableCount = rudders.Length;
// for (int i = 0; i < rudders.Length; ++i)
// {
// var rudder = rudders[i];
// var shipSteerable = vehicleCmd.Steerables[i].Ship;
// shipSteerable.Angle = rudder.Angle;
// shipSteerable.Rpm = rudder.Rpm;
// shipSteerable.SpinVelocity = rudder.SpinVelocity;
// shipSteerable.Submerged = rudder.Submerged;
//
// vehicleCmd.Steerables[i].Ship = shipSteerable;
// }
}
public static void Move(VehicleEntity vehicle, IVehicleCmd cmd)
{
var target = vehicle.GetController <VehicleController>();
var steerInput = Mathf.Clamp(cmd.MoveHorizontal, -1f, 1f);
var forwardInput = Mathf.Clamp(cmd.MoveVertical, -1f, 1f);
var reverseInput = -forwardInput;
float throttleInput = 0.0f;
float brakeInput = 0.0f;
float minSpeed = 0.1f;
float minInput = 0.1f;
if (target.speed > minSpeed)
{
throttleInput = forwardInput;
brakeInput = reverseInput;
}
else
{
if (reverseInput > minInput)
{
throttleInput = -reverseInput;
brakeInput = 0.0f;
}
else if (forwardInput > minInput)
{
if (target.speed < -minSpeed)
{
throttleInput = 0.0f;
brakeInput = forwardInput;
}
else
{
throttleInput = forwardInput;
brakeInput = 0;
}
}
}
target.SetInput(steerInput, throttleInput, brakeInput, cmd.IsSpeedup, cmd.IsHandbrake, cmd.IsHornOn);
}
#pragma warning disable RefCounter001
private void ExecuteLatestCmdsInSubSystems()
{
foreach (IVehicleCmdOwner owner in _handler.VehicleCmdOwnerList)
{
_currentEntity = owner.Entity;
var userCmd = owner.LatestCmd;
if (userCmd == null)
{
continue;
}
_logger.DebugFormat("execute vehicle latest cmd at time {0} on vehicle {1}", userCmd.ExecuteTime, userCmd.VehicleId);
_currentCmd = userCmd;
ExecuteVehicleSystems();
owner.ClearCmdList();
}
}
public void ApplyVehicleCmdAndState(VehicleEntity vehicle, IVehicleCmd cmd)
{
SetStateFromCmd(vehicle, cmd);
WheelEntityMoveUtility.MoveByCmd(vehicle, cmd);
}
public void ApplyVehicleCmdAndState(VehicleEntity vehicle, IVehicleCmd cmd)
{
SetStateFromCmd(vehicle, cmd);
ShipMoveInternal.Move(vehicle, cmd);
}
public static void Move(this VehicleEntity vehicle, IVehicleCmd cmd)
{
EntityAPI[vehicle.GetTypeValue()].Move(vehicle, cmd);
}
public static void ApplyVehicleCmdAndState(VehicleEntity vehicle, IVehicleCmd cmd)
{
EntityAPI[vehicle.GetTypeValue()].ApplyVehicleCmdAndState(vehicle, cmd);
}
public static void SetVehicleStateToCmd(this VehicleEntity vehicle, IVehicleCmd cmd)
{
EntityAPI[vehicle.GetTypeValue()].SetVehicleStateToCmd(vehicle, cmd);
}
public void Move(VehicleEntity vehicle, IVehicleCmd cmd)
{
MoveByCmd(vehicle, cmd);
}
private void DirectSetStateFromCmd(VehicleEntity vehicle, IVehicleCmd cmd)
{
var vehicleCmd = (VehicleCmd)cmd;
var controller = GetController(vehicle);
SetControllerState(controller, vehicleCmd.Body.Position.ShiftedVector3(), vehicleCmd.Body.Rotation,
vehicleCmd.Body.LinearVelocity, vehicleCmd.Body.AngularVelocity,
vehicleCmd.Body.Crashed);
SetWheelPosesFromCmd(controller, vehicleCmd);
// var state = controller.GetCurrentState();
//
// state.IsSyncFlagSet = true;
//
// state.BodyState.Position = vehicleCmd.Body.Position;
// state.BodyState.Rotation = vehicleCmd.Body.Rotation;
// state.BodyState.Body2WorldPosition = vehicleCmd.Body.Body2WorldPosition;
// state.BodyState.Body2WorldRotation = vehicleCmd.Body.Body2WorldRotation;
// state.BodyState.WakeCounter = vehicleCmd.Body.WakeCounter;
//
// var wheels = state.WheelStates;
// for (int i = 0; i < vehicleCmd.SteerableCount; ++i)
// {
// var wheel = wheels[i];
// var carSteerable = vehicleCmd.Steerables[i].Car;
//
// wheel.ColliderSteerAngle = carSteerable.ColliderSteerAngle;
// wheel.SteerAngle = carSteerable.SteerAngle;
// wheel.MotorTorque = carSteerable.MotorTorque;
//
// wheel.SuspensionDistance = carSteerable.SuspensionDistance;
// wheel.SuspensionSpring = carSteerable.SuspensionSpring;
// wheel.SuspensionTargetPosition = carSteerable.SuspensionTargetPosition;
//
// wheel.SprungMass = carSteerable.SprungMass;
// wheel.ForceDistance = carSteerable.ForceDistance;
//
// wheel.AngularVelocity = carSteerable.AngularVelocity;
// wheel.AngularPosition = carSteerable.AngularPosition;
// wheel.RotationAngle = carSteerable.RotationAngle;
//
// wheel.RotationSpeed = carSteerable.RotationSpeed;
//
// wheel.CorrectedRotationSpeed = carSteerable.CorrectedRotationSpeed;
// wheel.Jounce = carSteerable.Jounce;
//
// wheel.TireLowSideSpeedTimers = carSteerable.TireLowSideSpeedTimers;
// wheel.TireLowforwardSpeedTimers = carSteerable.TireLowforwardSpeedTimers;
// wheel.HitInfo.Grounded = carSteerable.Grounded;
//
// wheel.HitInfo.Point = carSteerable.Point;
//
// wheel.HitInfo.Normal = carSteerable.Normal;
// wheel.HitInfo.ForwardDir = carSteerable.ForwardDir;
//
// wheel.HitInfo.SidewaysDir = carSteerable.SidewaysDir;
// wheel.HitInfo.Force = carSteerable.Force;
//
// wheel.HitInfo.ForwardSlip = carSteerable.ForwardSlip;
// wheel.HitInfo.SidewaysSlip = carSteerable.SidewaysSlip;
// }
//
// ApplyState(vehicle);
}
public void SetVehicleStateToCmd(VehicleEntity vehicle, IVehicleCmd cmd)
{
var vehicleCmd = (VehicleCmd)cmd;
var controller = GetController(vehicle);
vehicleCmd.VehicleType = (int)EVehicleType.Car;
vehicleCmd.Body.Position = controller.cachedRigidbody.position.ShiftedToFixedVector3();
vehicleCmd.Body.Rotation = controller.cachedRigidbody.rotation;
vehicleCmd.Body.LinearVelocity = controller.Velocity;
vehicleCmd.Body.AngularVelocity = controller.AngularVelocity;
// vehicleCmd.Body.ContactCount = controller.ContactCount;
vehicleCmd.Body.Crashed = controller.IsCrashed;
vehicleCmd.Body.IsSleeping = controller.IsSleeping;
var wheelCount = controller.WheelCount;
vehicleCmd.SteerableCount = wheelCount;
for (int i = 0; i < wheelCount; ++i)
{
var wheel = controller.GetWheel(i);
// var wd = controller.GetWheelData(i);
vehicleCmd.Steerables[i].Car.Position = wheel.wheelTransform.localPosition;
vehicleCmd.Steerables[i].Car.Rotation = wheel.wheelTransform.localRotation;
vehicleCmd.Steerables[i].Car.Angle = wheel.wheelCollider.steerAngle;
// vehicleCmd.Steerables[i].Car.Grounded = wd.Grounded;
// vehicleCmd.Steerables[i].Car.GroundedOnTerrain = wd.GroundedOnTerrain;
}
// var state = controller.GetCurrentState();
// vehicleCmd.Body.Position = state.BodyState.Position;
// vehicleCmd.Body.Rotation = state.BodyState.Rotation;
// vehicleCmd.Body.Body2WorldPosition = state.BodyState.Body2WorldPosition;
// vehicleCmd.Body.Body2WorldRotation = state.BodyState.Body2WorldRotation;
// vehicleCmd.Body.LinearVelocity = state.BodyState.LinearVelocity;
// vehicleCmd.Body.AngularVelocity = state.BodyState.AngularVelocity;
//
// var wheels = state.WheelStates;
// vehicleCmd.SteerableCount = wheels.Length;
// for (int i = 0; i < wheels.Length; ++i)
// {
// var wheel = wheels[i];
// var carSteerable = vehicleCmd.Steerables[i].Car;
//
// carSteerable.ColliderSteerAngle = wheel.ColliderSteerAngle;
// carSteerable.SteerAngle = wheel.SteerAngle;
// carSteerable.MotorTorque = wheel.MotorTorque;
//
// carSteerable.SuspensionDistance = wheel.SuspensionDistance;
// carSteerable.SuspensionSpring = wheel.SuspensionSpring;
// carSteerable.SuspensionTargetPosition = wheel.SuspensionTargetPosition;
//
// carSteerable.SprungMass = wheel.SprungMass;
// carSteerable.ForceDistance = wheel.ForceDistance;
//
// carSteerable.AngularVelocity = wheel.AngularVelocity;
// carSteerable.AngularPosition = wheel.AngularPosition;
// carSteerable.RotationAngle = wheel.RotationAngle;
//
// carSteerable.RotationSpeed = wheel.RotationSpeed;
//
// carSteerable.CorrectedRotationSpeed = wheel.CorrectedRotationSpeed;
// carSteerable.Jounce = wheel.Jounce;
//
// carSteerable.TireLowSideSpeedTimers = wheel.TireLowSideSpeedTimers;
// carSteerable.TireLowforwardSpeedTimers = wheel.TireLowforwardSpeedTimers;
// carSteerable.Grounded = wheel.HitInfo.Grounded;
//
// carSteerable.Point = wheel.HitInfo.Point;
//
// carSteerable.Normal = wheel.HitInfo.Normal;
// carSteerable.ForwardDir = wheel.HitInfo.ForwardDir;
//
// carSteerable.SidewaysDir = wheel.HitInfo.SidewaysDir;
// carSteerable.Force = wheel.HitInfo.Force;
//
// carSteerable.ForwardSlip = wheel.HitInfo.ForwardSlip;
// carSteerable.SidewaysSlip = wheel.HitInfo.SidewaysSlip;
//
// vehicleCmd.Steerables[i].Car = carSteerable;
// }
}
public virtual void ExecuteVehicleCmd(Entity entity, IVehicleCmd cmd)
{
var vehicle = (VehicleEntity)entity;
vehicle.Move(cmd);
}
