private NativeList <ButtonTypes> GetButtonPressesFromTouches(ref PhysicsWorld physicsWorld, NativeArray <float2> touches)
{
var buttonIdentifiers = GetComponentDataFromEntity <ButtonIdentifier>();
var buttonPresses = new NativeList <ButtonTypes>(Allocator.TempJob);
for (var i = 0; i < touches.Length; i++)
{
var pointInput = new OverlapPointInput()
{
Position = touches[i],
Filter = CollisionFilter.Default
};
if (physicsWorld.OverlapPoint(pointInput, out var overlapPointHit))
{
var body = physicsWorld.AllBodies[overlapPointHit.PhysicsBodyIndex];
if (buttonIdentifiers.HasComponent(body.Entity))
{
buttonPresses.Add(buttonIdentifiers[body.Entity].Value);
}
}
}
return(buttonPresses);
}
public unsafe void PhysicsBodyOverlapPointTest()
{
var geometry = new BoxGeometry
{
Size = new float2(2f),
};
using (var collider = PhysicsBoxCollider.Create(geometry))
{
var physicsBody = new PhysicsBody(collider);
var queryInput = new OverlapPointInput()
{
Filter = CollisionFilter.Default
};
var closestHit = new OverlapPointHit();
var allHits = new NativeList <OverlapPointHit>(Allocator.Temp);
// OK case.
var positionOK = new float2(1f);
queryInput.Position = positionOK;
Assert.IsTrue(physicsBody.OverlapPoint(queryInput));
Assert.IsTrue(physicsBody.OverlapPoint(queryInput, out closestHit));
Assert.IsTrue(physicsBody.OverlapPoint(queryInput, ref allHits));
// Fail Case.
var positionFail = new float2(-10f);
queryInput.Position = positionFail;
Assert.IsFalse(physicsBody.OverlapPoint(queryInput));
Assert.IsFalse(physicsBody.OverlapPoint(queryInput, out closestHit));
Assert.IsFalse(physicsBody.OverlapPoint(queryInput, ref allHits));
allHits.Dispose();
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var input = World.GetExistingSystem <Tiny.Input.InputSystem>();
var physicsWorld = World.GetExistingSystem <PhysicsWorldSystem>().PhysicsWorld;
if (InputUtil.GetInputUp(input))
{
var inputPos = CameraUtil.ScreenPointToViewportPoint(EntityManager, InputUtil.GetInputPosition(input));
Debug.Log("inputPos" + inputPos);
var cameraMatrices = m_CameraQuery.ToComponentDataArray <CameraMatrices>(Allocator.TempJob);
var resultPos = CameraUtil.ViewPortPointToNearClipPoint(cameraMatrices[0], inputPos);
var pointInput = new OverlapPointInput()
{
Position = resultPos,
Filter = CollisionFilter.Default
};
if (physicsWorld.OverlapPoint(pointInput, out var overlapPointHit))
{
var body = physicsWorld.AllBodies[overlapPointHit.PhysicsBodyIndex];
Debug.Log("input hit physicsbody " + body.Entity.Index);
var colorComponent = m_entityManager.GetComponentData <ColorComponent>(body.Entity);
colorComponent.Flag = !colorComponent.Flag;
m_entityManager.SetComponentData <ColorComponent>(body.Entity, colorComponent);
}
cameraMatrices.Dispose();
}
return(inputDeps);
}
public static bool OverlapPoint(ISimGameWorldReadWriteAccessor accessor, fix2 position, NativeList <OverlapPointHit> outHits, Entity ignoreEntity = default)
{
var physicsSystem = accessor.GetExistingSystem <PhysicsWorldSystem>();
OverlapPointInput pointDistanceInput = OverlapPointInput.Default;
pointDistanceInput.Position = (float2)position;
if (ignoreEntity != Entity.Null)
{
pointDistanceInput.Ignore = new IgnoreHit(physicsSystem.GetPhysicsBodyIndex(ignoreEntity));
}
return(physicsSystem.PhysicsWorld.OverlapPoint(pointDistanceInput, ref outHits));
}
public static Entity GetInputEntity(PhysicsWorld physicsWorld, float2 worldPos)
{
var pointInput = new OverlapPointInput()
{
Position = worldPos,
Filter = CollisionFilter.Default
};
if (physicsWorld.OverlapPoint(pointInput, out var overlapPointHit))
{
var body = physicsWorld.AllBodies[overlapPointHit.PhysicsBodyIndex];
return(body.Entity);
}
return(Entity.Null);
}
private static SwapInput GetSwapInputFromWorldPos(ref PhysicsWorld physicsWorld, float2 worldPos, float2 deltaInput)
{
var pointInput = new OverlapPointInput()
{
Position = worldPos,
Filter = CollisionFilter.Default
};
var swapInput = new SwapInput()
{
DeltaInput = deltaInput
};
if (physicsWorld.OverlapPoint(pointInput, out var overlapPointHit))
{
var body = physicsWorld.AllBodies[overlapPointHit.PhysicsBodyIndex];
swapInput.Cell = body.Entity;
}
return(swapInput);
}
protected override void OnUpdate()
{
////////////////////////////////////////////////////////////////////////////////////////
// Camera
////////////////////////////////////////////////////////////////////////////////////////
if (CameraController.Instance != null)
{
Cache.CameraPosition = CameraController.Instance.CamPosition;
Cache.CameraSize = CameraController.Instance.CamSize;
}
////////////////////////////////////////////////////////////////////////////////////////
// Player & Pawn
////////////////////////////////////////////////////////////////////////////////////////
Cache.LocalPawn = PlayerHelpers.GetLocalSimPawnEntity(Cache.SimWorld);
if (Cache.LocalPawn != Entity.Null)
{
Cache.LocalController = CommonReads.TryGetPawnController(Cache.SimWorld, Cache.LocalPawn);
Cache.LocalPawnPosition = Cache.SimWorld.GetComponent <FixTranslation>(Cache.LocalPawn).Value;
Cache.LocalPawnPositionFloat = Cache.LocalPawnPosition.ToUnityVec();
Cache.PlayerAP = Cache.SimWorld.GetComponent <ActionPoints>(Cache.LocalPawn).Value;
Cache.PlayerMaxAP = Cache.SimWorld.GetComponent <MaximumFix <ActionPoints> >(Cache.LocalPawn).Value;
}
else
{
Cache.LocalController = Entity.Null;
}
////////////////////////////////////////////////////////////////////////////////////////
// Player Group
////////////////////////////////////////////////////////////////////////////////////////
if (Cache.SimWorld.HasSingleton <PlayerGroupDataTag>())
{
Cache.PlayerGroupEntity = Cache.SimWorld.GetSingletonEntity <PlayerGroupDataTag>();
Cache.GroupLifePoints = Cache.SimWorld.GetComponent <LifePoints>(Cache.PlayerGroupEntity);
Cache.GroupHealth = Cache.SimWorld.GetComponent <Health>(Cache.PlayerGroupEntity);
Cache.GroupMaxHealth = Cache.SimWorld.GetComponent <MaximumFix <Health> >(Cache.PlayerGroupEntity).Value;
Cache.GroupShield = Cache.SimWorld.GetComponent <Shield>(Cache.PlayerGroupEntity);
Cache.GroupMaxShield = Cache.SimWorld.GetComponent <MaximumFix <Shield> >(Cache.PlayerGroupEntity).Value;
Cache.GroupPosition = Cache.SimWorld.GetComponent <FixTranslation>(Cache.PlayerGroupEntity).Value;
}
////////////////////////////////////////////////////////////////////////////////////////
// Pointer
////////////////////////////////////////////////////////////////////////////////////////
{
Cache.PointerWorldPosition = CameraService.Instance.ActiveCamera.ScreenToWorldPoint(Input.mousePosition);
if (WorldUIEventSystem.Instance != null)
{
Cache.PointerInWorld = WorldUIEventSystem.Instance.MouseInWorld;
}
Cache.PointedTile = Helpers.GetTile(Cache.PointerWorldPosition);
int hitCount = Physics2D.OverlapPointNonAlloc(Cache.PointerWorldPosition, _overlapResults, layerMask: ~0);
Cache.PointedViewEntities.Clear();
Cache.PointedColliders.Clear();
Cache.PointedGameObjects.Clear();
for (int i = 0; i < hitCount; i++)
{
Cache.PointedColliders.Add(_overlapResults[i]);
Cache.PointedGameObjects.AddUnique(_overlapResults[i].gameObject);
if (_overlapResults[i].gameObject.TryGetComponent(out BindedSimEntityManaged bindedSimEntity))
{
Cache.PointedViewEntities.Add(bindedSimEntity);
}
}
Cache.PointedBodies.Clear();
var physicsWorldSys = Cache.SimWorld.GetExistingSystem <PhysicsWorldSystem>();
if (physicsWorldSys.PhysicsWorldFullyUpdated)
{
NativeList <OverlapPointHit> hits = new NativeList <OverlapPointHit>(Allocator.Temp);
OverlapPointInput input = OverlapPointInput.Default;
input.Position = Cache.PointerWorldPosition;
physicsWorldSys.PhysicsWorld.OverlapPoint(input, ref hits);
foreach (var hit in hits)
{
Cache.PointedBodies.Add(hit.Entity);
}
}
}
}
protected override void OnUpdate()
{
TileWorld tileWorld = CommonReads.GetTileWorld(Accessor);
PhysicsWorld physicsWorld = _physicsWorldSystem.PhysicsWorld;
Entities
.WithReadOnly(tileWorld)
.WithReadOnly(physicsWorld)
.ForEach((Entity entity, ref NavAgentFootingState footing, in FixTranslation fixTranslation, in PhysicsColliderBlob colliderRef, in PhysicsVelocity velocity) =>
{
if (!colliderRef.Collider.IsCreated)
{
return;
}
ref Collider collider = ref colliderRef.Collider.Value;
fix pawnRadius = (fix)collider.Radius;
fix pawnFeetXOffset = pawnRadius * (fix)0.8f;
fix2 belowLeftFoot = new fix2(fixTranslation.Value.x - pawnFeetXOffset, fixTranslation.Value.y - pawnRadius - (fix)0.05);
fix2 belowRightFoot = new fix2(fixTranslation.Value.x + pawnFeetXOffset, fixTranslation.Value.y - pawnRadius - (fix)0.05);
fix2 belowLongDick = new fix2(fixTranslation.Value.x, fixTranslation.Value.y - pawnRadius - (fix)0.05);
// GOTO Ladder IF on ladder && (already has footing on ladder || already has footing on ground)
if (tileWorld.GetFlags(Helpers.GetTile(fixTranslation)).IsLadder &&
(footing.Value == NavAgentFooting.Ladder || footing.Value == NavAgentFooting.Ground))
{
footing.Value = NavAgentFooting.Ladder;
}
else
{
OverlapPointInput detectTerrain = new OverlapPointInput()
{
Filter = SimulationGameConstants.Physics.CharacterFilter.Data,
};
OverlapPointInput detectTerrainLeftFoot = detectTerrain;
detectTerrainLeftFoot.Position = (float2)belowLeftFoot;
OverlapPointInput detectTerrainLongDick = detectTerrain;
detectTerrainLongDick.Position = (float2)belowLongDick;
OverlapPointInput detectTerrainRightFoot = detectTerrain;
detectTerrainRightFoot.Position = (float2)belowRightFoot;
// GOTO Ground IF above terrain && (previously grounded || previously ladder || previously airControl and not jumping || velocity is low)
if ((physicsWorld.OverlapPoint(detectTerrainLeftFoot) || physicsWorld.OverlapPoint(detectTerrainLongDick) || physicsWorld.OverlapPoint(detectTerrainRightFoot)) &&
(footing.Value == NavAgentFooting.Ground ||
footing.Value == NavAgentFooting.Ladder ||
(footing.Value == NavAgentFooting.AirControl && velocity.Linear.y <= (fix)0.5) ||
velocity.Linear.lengthSquared < 4))
{
footing.Value = NavAgentFooting.Ground;
}
else
{
// GOTO air control IF in mid-air && was not in None
if (footing.Value != NavAgentFooting.None)
{
footing.Value = NavAgentFooting.AirControl;
}
}
}
}).Run();
