private Vector3 GetGravity(Entity entity, DefStJumpSettings setting)
{
if (setting.GravityGravityType == GravityType.Custom)
{
return(setting.Gravity);
}
if (setting.GravityGravityType == GravityType.Default)
{
return(m_CachedDefaultGravity);
}
if (EntityManager.HasComponent <StGravitySettings>(entity))
{
var data = EntityManager.GetComponentData <StGravitySettings>(entity);
return(data.FlagIsDefault == 1 ? m_CachedDefaultGravity : data.Value);
}
return(m_CachedDefaultGravity);
}
private bool ProcessItem
(
ref Entity entity,
ref StVelocity velocity,
ref DefStJumpSettings setting,
ref DefStRunInput runInput,
ref DefStJumpInput input,
ref DefStWallJumpProcessData process,
ref CharacterControllerState state,
Transform transform
)
{
var action = input.State == InputState.Down && !MvUtils.OnGround(state, velocity) && Time.time > process.TimeBeforeNextWJ;
if (!action)
{
return(false);
}
var originalVelocity = velocity.Value;
var fwd = transform.forward;
var pos = transform.position + new Vector3(0, 0.4f + 0.1f); // hardcoded value (stepoffset)
var rot = transform.rotation;
var rd = 0.3f + 0.075f; // (radius)
var sw = 0.07f + 0.025f; // hardcoded value (skinwidth)
var height = 2f - 0.4f; // harcoded value (height and stepOffset)
var subheight = (height * 0.75f) - 0.005f;
CPhysicSettings.Active.SetGlobalCollision(transform.gameObject, false);
var direction = (Vector3)SrtComputeDirection(fwd, rot, runInput.Direction);
var rayTrace = UtilityWallRayTrace.RayTrace(ref direction, ref pos, ref rd, ref sw, ref height, ref subheight, transform.GetComponent <Collider>());
Debug.DrawRay(rayTrace.point, rayTrace.normal, Color.red, 10);
CPhysicSettings.Active.SetGlobalCollision(transform.gameObject, true);
var success = rayTrace.normal != Vector3.zero && Mathf.Abs(rayTrace.normal.y) < 0.2f;
if (success)
{
rayTrace.normal = rayTrace.normal.ToGrid(1).normalized;
velocity.Value = RaycastUtilities.SlideVelocityNoYChange(velocity.Value, rayTrace.normal);
velocity.Value.y = math.max(math.min(velocity.Value.y + 6.5f, 12f), 0);
var previousVelocity = velocity.Value;
var bounceDir = rayTrace.normal * 6f;
var minSpeed = bounceDir.magnitude;
velocity.Value += bounceDir;
var flatVelocity = velocity.Value.ToGrid(1);
var oldY = velocity.Value.y;
velocity.Value = Vector3.ClampMagnitude(flatVelocity, Mathf.Max(previousVelocity.magnitude, minSpeed));
velocity.Value.y = oldY;
process.TimeBeforeNextWJ = Time.time + DefaultCooldown;
input.TimeBeforeResetState = -1f;
input.State = InputState.None;
BroadcastNewEntity(PostUpdateCommands, true);
PostUpdateCommands.AddComponent(new DefStWallJumpEvent(Time.time, Time.frameCount, entity, originalVelocity, rayTrace.normal));
MvDelegateEvents.InvokeCharacterWalljump(entity);
}
return(success);
}
public override void Create(Entity entity)
{
Debug.Assert(GameObject != null, "GameObject != null");
Debug.Assert(GameObjectEntity.Entity == entity, "GameObjectEntity.Entity == entity");
var characterController = GameObject.GetComponent <CharacterController>();
characterController.center = Vector3.up * 0.9f;
characterController.radius = 0.4f;
characterController.stepOffset = 0.4f;
characterController.height = 2f * 0.9f;
characterController.slopeLimit = 75;
characterController.detectCollisions = false;
AddDefaultComponents(entity);
if (Player.IsCreated)
{
EntityManager.AddComponentData(entity, new CharacterPlayerOwner
{
Target = Player.WorldPointer
});
}
EntityManager.AddComponentData(entity, new CharacterControllerState(false, false, false, Vector3.up));
EntityManager.AddComponentData(entity, StormiumCharacterMvData.NewBase());
EntityManager.AddComponentData(entity, new StormiumCharacterMvProcessData());
ShareManager.SetShareOption(entity, typeof(CharacterPlayerOwner), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(CharacterControllerState), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(StormiumCharacterMvData), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(StormiumCharacterMvProcessData), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
/*// Add switcher
* {
* var actionEntity = EntityManager.CreateEntity
* (
* typeof(StActionTag),
* typeof(StActionOwner),
* typeof(StActionSlot),
* typeof(StActionDualSwitch)
* );
*
* var actionType = typeof(StActionDualSwitch);
*
* EntityManager.SetComponentData(actionEntity, new StActionTag(TypeManager.GetTypeIndex(actionType)));
* EntityManager.SetComponentData(actionEntity, new StActionOwner(entity));
* EntityManager.SetComponentData(actionEntity, new StActionSlot(0));
* EntityManager.SetComponentData(actionEntity, new StActionDualSwitch(rocketEntity, rocketEntity));
*
* EntityManager.GetBuffer<StActionContainer>(entity).Add(new StActionContainer(actionEntity));
* }
* // Add grenade
* {
* var actionEntity = EntityManager.CreateEntity
* (
* typeof(StActionTag),
* typeof(StActionOwner),
* typeof(StActionSlot),
* typeof(StActionAmmo),
* typeof(StActionAmmoCooldown),
* typeof(StDefActionThrowGrenade)
* );
*
* var actionType = typeof(StDefActionThrowGrenade);
*
* EntityManager.SetComponentData(actionEntity, new StActionTag(TypeManager.GetTypeIndex(actionType)));
* EntityManager.SetComponentData(actionEntity, new StActionOwner(entity));
* EntityManager.SetComponentData(actionEntity, new StActionSlot(1));
* EntityManager.SetComponentData(actionEntity, new StActionAmmo(0, 1, 0));
* EntityManager.SetComponentData(actionEntity, new StActionAmmoCooldown(-1, 8));
* EntityManager.SetComponentData(actionEntity, new StDefActionThrowGrenade(28f, 25, 2));
*
* EntityManager.GetBuffer<StActionContainer>(entity).Add(new StActionContainer(actionEntity));
* }*/
// Add transforms component
EntityManager.AddComponentData(entity, new Position());
EntityManager.AddComponentData(entity, new Rotation());
EntityManager.AddComponentData(entity, new StVelocity());
ShareManager.SetShareOption(entity, typeof(Position), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(Rotation), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(StVelocity), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
// Add settings
EntityManager.AddComponentData(entity, new EntityPhysicLayer(30));
EntityManager.AddComponentData(entity, new StStamina(4, 0.75f, 0));
EntityManager.AddComponentData(entity, DefStGroundRunSettings.NewBase());
EntityManager.AddComponentData(entity, DefStAerialRunSettings.NewBase());
EntityManager.AddComponentData(entity, DefStJumpSettings.NewBase());
EntityManager.AddComponentData(entity, DefStDodgeOnGroundSettings.NewBase());
EntityManager.AddComponentData(entity, new DefStJumpStaminaUsageData()
{
Usage = EStaminaUsage.RemoveStamina,
RemoveBySpeedFactor01 = 0.01f,
BaseRemove = 0.1f
});
EntityManager.AddComponentData(entity, new DefStDodgeStaminaUsageData()
{
Usage = EStaminaUsage.BlockAction,
Needed = 1f,
BaseRemove = 1f
});
ShareManager.SetShareOption(entity, typeof(EntityPhysicLayer), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(StStamina), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStGroundRunSettings), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStAerialRunSettings), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStJumpSettings), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStDodgeOnGroundSettings), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStJumpStaminaUsageData), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStDodgeStaminaUsageData), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
// Add simple client inputs
EntityManager.AddComponentData(entity, new DefStRunClientInput());
EntityManager.AddComponentData(entity, new DefStJumpClientInput());
EntityManager.AddComponentData(entity, new DefStDodgeClientInput());
EntityManager.AddComponentData(entity, new DefStEntityAimClientInput());
ShareManager.SetShareOption(entity, typeof(DefStRunClientInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStJumpClientInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStDodgeClientInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStEntityAimClientInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
// Add global inputs
EntityManager.AddComponentData(entity, new DefStRunInput());
EntityManager.AddComponentData(entity, new DefStJumpInput());
EntityManager.AddComponentData(entity, new DefStDodgeInput());
EntityManager.AddComponentData(entity, new DefStEntityAimInput());
ShareManager.SetShareOption(entity, typeof(DefStRunInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStJumpInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStDodgeInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStEntityAimInput), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
// Add processable data
EntityManager.AddComponentData(entity, new DefStJumpProcessData());
EntityManager.AddComponentData(entity, new DefStDodgeOnGroundProcessData());
EntityManager.AddComponentData(entity, new DefStWallJumpProcessData());
EntityManager.AddComponentData(entity, new DefStWallDodgeProcessData());
ShareManager.SetShareOption(entity, typeof(DefStJumpProcessData), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStDodgeOnGroundProcessData), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(DefStWallDodgeProcessData), ComponentShareOption.Manual, DeliveryMethod.ReliableOrdered);
// Make the clients able to change the input data
EntityManager.AddComponentData(entity, new ClientDriveData <DefStRunInput>(Player));
EntityManager.AddComponentData(entity, new ClientDriveData <DefStJumpInput>(Player));
EntityManager.AddComponentData(entity, new ClientDriveData <DefStDodgeInput>(Player));
EntityManager.AddComponentData(entity, new ClientDriveData <DefStEntityAimInput>(Player));
ShareManager.SetShareOption(entity, typeof(ClientDriveData <DefStRunInput>), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(ClientDriveData <DefStJumpInput>), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(ClientDriveData <DefStDodgeInput>), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
ShareManager.SetShareOption(entity, typeof(ClientDriveData <DefStEntityAimInput>), ComponentShareOption.Automatic, DeliveryMethod.ReliableOrdered);
}
private bool ProcessItem
(
ref Entity entity,
ref StVelocity velocity,
ref DefStJumpSettings setting,
ref DefStRunInput runInput,
ref DefStJumpInput input,
ref DefStJumpProcessData process,
ref CharacterControllerState state,
Transform transform
)
{
if (MvUtils.OnGround(state, velocity))
{
process.ComboCtx = 0;
}
if (input.ContinueJump == 0)
{
process.NeedToChain = 0;
}
var inputCanJump = input.State == InputState.Down || (input.ContinueJump == 1 && process.NeedToChain == 1);
var doJump = inputCanJump && (process.ComboCtx < setting.MaxCombo && process.CooldownBeforeNextJump <= 0f) &&
(MvUtils.OnGround(state, velocity) || process.ComboCtx > 0);
var airJump = doJump && !state.IsGrounded() && !state.IsSliding();
if (input.TimeBeforeResetState <= 0f)
{
input.State = InputState.None;
}
process.CooldownBeforeNextJump -= Time.deltaTime;
input.TimeBeforeResetState -= Time.deltaTime;
// We expect the developpers to check for staminas or things like that for this command.
DiffuseCommand(m_CmdDoJump, m_CmdDoJumpResult, doJump, CmdState.Begin);
doJump = GetCmdResult(m_CmdDoJumpResult);
if (!doJump)
{
return(false);
}
var direction = SrtComputeDirection(transform.forward, transform.rotation, runInput.Direction);
var strafeAngle = SrtGetStrafeAngleNormalized(direction, velocity.Value);
if (math.all(runInput.Direction == float2.zero))
{
strafeAngle *= 0.5f;
}
if (input.State == InputState.Down)
{
process.NeedToChain = 1;
}
velocity.Value.y = math.max(velocity.Value.y, 0);
if (!airJump)
{
var motor = transform.GetComponent <CharacterControllerMotor>();
velocity.Value += Vector3.up * (setting.JumpPower * (input.State != InputState.Down ? 0.75f : 1f));
//if (motor.Momentum.y > 0) velocity.Value += Vector3.up * (motor.Momentum.normalized.y * 6f);
}
else
{
velocity.Value = Vector3.up * setting.JumpPower;
}
if (airJump)
{
velocity.Value = math.lerp(velocity.Value, SrtAirDash(velocity.Value, direction), 1f);
}
else if (input.State != InputState.Down)
{
velocity.Value += (Vector3)(direction * (strafeAngle * 5f));
var oldY = velocity.Value.y;
var currSpeed = velocity.Value.ToGrid(1).magnitude;
var newSpeed = math.min(currSpeed + strafeAngle * 2f, math.max(currSpeed, 18f));
velocity.Value = velocity.Value.ToGrid(1).normalized *newSpeed;
velocity.Value.y = oldY;
}
else
{
var oldY = velocity.Value.y;
//velocity.Value = velocity.Value.ToGrid(1).normalized * (velocity.Value.ToGrid(1).magnitude - 2.5f);
velocity.Value.y = oldY;
}
input.TimeBeforeResetState = -1f;
input.State = InputState.Pressed;
process.ComboCtx++;
process.CooldownBeforeNextJump = 0.1f;
// We except developpers to just clean the pre-command phase, and not applying things like reducing stamina...
DiffuseCommand(m_CmdDoJump, m_CmdDoJumpResult, true, CmdState.End);
// Send event to clients
BroadcastNewEntity(PostUpdateCommands, true);
PostUpdateCommands.AddComponent(new DefStJumpEvent(Time.time, Time.frameCount, entity));
MvDelegateEvents.InvokeCharacterJump(entity);
return(true);
}
