private void UpdateNode(ref NpcFlyingNode npc)
{
if (npc.SensorTargets.WatchTargets.Count == 0)
{
npc.TryWander();
return;
}
var target = npc.SensorTargets.WatchTargets[0].Target;
if (!npc.Chasing)
{
npc.Chase(target);
}
if (npc.Projectile.ShootTimer.IsActive)
{
return;
}
if (Physics.Raycast(
npc.Projectile.ShootPivot.Tr.position, npc.Projectile.ShootPivot.Tr.forward, out var hit, 50,
LayerMasks.DefaultCollision))
{
if (UnityToEntityBridge.GetEntity(hit.collider) == target)
{
npc.Stop();
npc.Projectile.Fire();
}
}
}
public bool CanSeeOrHear(Entity source, Entity target, out bool canHear)
{
var sourcePos = source.GetPosition();
var dir = target.GetPosition() - sourcePos;
var ray = new Ray(sourcePos, dir.normalized);
var rayLimit = Physics.RaycastNonAlloc(ray, _rayHits, dir.magnitude, UnitCheckMask);
_rayHits.SortByDistanceAsc(rayLimit);
canHear = true;
for (int i = 0; i < rayLimit; i++)
{
if (_rayHits[i].transform.CompareTag(StringConst.TagEnvironment))
{
canHear = false;
continue;
}
var entity = UnityToEntityBridge.GetEntity(_rayHits[i].collider);
if (entity == null)
{
continue;
}
if (entity == source)
{
continue;
}
if (entity == target)
{
return(true);
}
}
return(true);
}
//private Entity FindArenaActorInRange(Entity source, float range, TargetType targeting) {
// List<Entity> actorList = new List<Entity>();
// switch (targeting) {
// case TargetType.Self:
// return source;
// case TargetType.Friendly:
// World.Get<FactionSystem>().FillFactionFriendsList(actorList, source.Get<FactionComponent>().Faction);
// break;
// default:
// World.Get<FactionSystem>().FillFactionEnemiesList(actorList, source.Get<FactionComponent>().Faction);
// break;
// }
// actorList.Shuffle();
// var ranksCanBust = (int) range;
// for (int i = 0; i < actorList.Count; i++) {
// if (actorList[i].PositionRank <= ranksCanBust) {
// return actorList[i];
// }
// }
// return null;
//}
private bool CanSeeTarget(int rayLimit, Entity source, Entity target)
{
_rayHits.SortByDistanceAsc(rayLimit);
for (int i = 0; i < rayLimit; i++)
{
if (_rayHits[i].transform.CompareTag(StringConst.TagEnvironment))
{
return(false);
}
var colliderEntity = UnityToEntityBridge.GetEntity(_rayHits[i].collider);
if (colliderEntity == null || colliderEntity == source)
{
continue;
}
if (colliderEntity == target)
{
return(true);
}
if (World.Get <FactionSystem>().AreEnemies(colliderEntity, source))
{
return(false);
}
}
return(true);
}
private void RunUpdate(ref UnitySensorNode node)
{
node.Sensor.Sensor.Pulse();
node.Targets.UpdateWatchTargets();
for (int i = 0; i < node.Sensor.Sensor.DetectedColliders.Count; i++)
{
var enemy = UnityToEntityBridge.GetEntity(node.Sensor.Sensor.DetectedColliders[i]);
if (enemy == null || enemy == node.Entity)
{
continue;
}
var faction = enemy.Get <FactionComponent>();
if (!World.Get <FactionSystem>().AreEnemies(faction, node.Faction))
{
continue;
}
node.Targets.AddWatch(enemy, true);
Console.Log(node.Entity.DebugId + " saw " + enemy.DebugId);
}
if (node.Targets.WatchTargets.Count != 0)
{
return;
}
_tempEnemyList.Clear();
World.Get <FactionSystem>().FillFactionEnemiesList(_tempEnemyList, node.Faction.Faction);
var nodePos = node.Tr.position.WorldToGenericGrid(HearingSectorSize);
for (int f = 0; f < _tempEnemyList.Count; f++)
{
var enemy = _tempEnemyList[f];
var tr = enemy.Get <TransformComponent>();
if (tr == null)
{
Debug.Log("Enemy has no TR " + enemy.DebugId);
continue;
}
if (tr.position.WorldToGenericGrid(HearingSectorSize) != nodePos)
{
continue;
}
var hearingChance = HearingChance;
if (enemy.Tags.Contain(EntityTags.PerformingCommand))
{
hearingChance *= 4;
}
else if (enemy.Tags.Contain(EntityTags.Moving))
{
hearingChance *= 2;
}
if (Game.Random.DiceRollSucess(hearingChance))
{
if (!Physics.Linecast(tr.position, node.Tr.position, LayerMasks.Walls))
{
node.Targets.AddWatch(enemy, false);
Console.Log(node.Entity.DebugId + " heard " + enemy.DebugId);
}
}
}
}
void OnCollisionEnter(Collision collision)
{
if (collision.transform.CompareTag(StringConst.TagPlayer))
{
var entity = UnityToEntityBridge.GetEntity(collision.collider).GetTemplate <CharacterTemplate>();
if (entity != null)
{
World.Get <RulesSystem>().Post(new HealingEvent(null, _amount, entity, entity, _vital));
ItemPool.Despawn(gameObject);
}
}
}
void OnCollisionEnter(Collision collision)
{
if (collision.transform.CompareTag(StringConst.TagPlayer))
{
var entity = UnityToEntityBridge.GetEntity(collision.collider);
if (entity != null)
{
entity.Post(new HealingEvent(_amount, entity, entity, _vital));
ItemPool.Despawn(gameObject);
}
}
}
public void Handle(ReceivedDamageEvent arg)
{
var sensorTargets = arg.Target.Entity.Find <SensorTargetsComponent>();
//#if DEBUG
// DebugLog.Add(
// sensorTargets.GetEntity().DebugId + " was attacked by " + arg.Origin?.Entity.DebugId + " parent " +
// arg.Origin?.Entity.ParentId + " is pooled " + arg.Origin?.Entity.Pooled);
//#endif
sensorTargets.AddWatch(arg.Origin, true);
if (sensorTargets.Shouted)
{
return;
}
var sourceFaction = arg.Target.Faction.Value;
var factionSystem = World.Get <FactionSystem>();
sensorTargets.Shouted = true;
var sourcePos = arg.Target.Tr.position;
var limit = Physics.OverlapSphereNonAlloc(sourcePos, ShoutRadius, _shoutColliders, LayerMasks.DefaultCollision);
for (int i = 0; i < limit; i++)
{
var sensorTemplate = UnityToEntityBridge.GetEntity(_shoutColliders[i]).GetTemplate <UnitySensorTemplate>();
if (sensorTemplate == null)
{
continue;
}
if (!factionSystem.AreFriends(sourceFaction, sensorTemplate.Faction.Value))
{
continue;
}
if (Physics.Linecast(sourcePos, sensorTemplate.Tr.position, LayerMasks.Walls))
{
continue;
}
sensorTemplate.Targets.AddWatch(arg.Origin, false);
}
}
public Entity GetTarget(Entity source, Vector3 dir, float range, TargetType targeting)
{
//if (GameOptions.ArenaCombat) {
// return FindArenaActorInRange(source, range, targeting);
//}
var sourcePos = source.GetPosition();
var ray = new Ray(sourcePos, dir);
var rayLimit = Physics.RaycastNonAlloc(ray, _rayHits, range, UnitCheckMask);
_rayHits.SortByDistanceAsc(rayLimit);
for (int i = 0; i < rayLimit; i++)
{
if (_rayHits[i].transform.CompareTag(StringConst.TagEnvironment))
{
return(null);
}
var entity = UnityToEntityBridge.GetEntity(_rayHits[i].collider);
if (entity == null)
{
continue;
}
if (entity == source)
{
continue;
}
var target = EntityController.GetEntity(entity);
if (targeting == TargetType.Enemy && !World.Get <FactionSystem>().AreEnemies(source, target))
{
continue;
}
if (targeting == TargetType.Friendly && !World.Get <FactionSystem>().AreFriends(source, target))
{
continue;
}
return(target);
}
return(null);
}
void Update()
{
if (!Game.GameActive)
{
return;
}
//if (_debug) {
// DebugText.UpdatePermText("World Control", "Game Not Active");
//}
//if (GenericDraggableController.Dragging) {
// if (_debug) {
// DebugText.UpdatePermText("World Control", "Dragging");
// }
// return;
//}
_foundControl = false;
//_eventData.position = Input.mousePosition;
//EventSystem.current.RaycastAll(_eventData, _result);
if (PlayerInputSystem.IsCursorOverUI)
{
SetCurrentNull();
//if (_debug) {
// var go = PlayerInput.CurrentInput != null ? PlayerInput.CurrentInput.GameObjectUnderPointer() : null;
// DebugText.UpdatePermText("World Control", string.Format("Over UI: {0}", go != null ? go.name :
// EventSystem.current.currentSelectedGameObject != null ? EventSystem.current.currentSelectedGameObject.name : " null ?"));
//}
return;
}
_mouseRay = Cam.ScreenPointToRay(Input.mousePosition);
Entity currentActor = null;
var cnt = Physics.RaycastNonAlloc(_mouseRay, _hits, _currentEnemyRayDistance, _worldControlsMask);
_hits.SortByDistanceAsc(cnt);
for (int i = 0; i < cnt; i++)
{
var hit = _hits[i];
if (!_foundControl)
{
if (hit.transform.gameObject == _currentGameObject)
{
_foundControl = true;
continue;
}
if (hit.distance <= _currentRayDistance)
{
hit.transform.GetComponentsInChildren(_tempControls);
for (int j = 0; j < _tempControls.Count; j++)
{
if (_tempControls[j] == null)
{
continue;
}
if (_tempControls[j].WorldControlActive)
{
SetNewCurrent(_tempControls[j], hit.transform.gameObject);
_foundControl = true;
break;
}
}
}
}
if (currentActor == null)
{
currentActor = UnityToEntityBridge.GetEntity(hit.collider);
}
if (LayerMasks.Environment.ContainsLayer(hit.transform.gameObject.layer))
{
if (_debug)
{
DebugText.UpdatePermText("World Control", "Environment " + cnt);
}
break;
}
}
if (currentActor != null)
{
if (_debug)
{
DebugText.UpdatePermText("World Control", currentActor.Id.ToString());
}
}
//RaycastHit hit;
//if (Physics.Raycast(_mouseRay, out hit, _enemyDistance, _worldControlsMask)) {
// if (hit.transform.gameObject == _currentGameObject) {
// _foundControl = true;
// }
// else {
// if (hit.distance <= _rayDistance) {
// var newCurrent = hit.transform.GetComponent<IWorldControl>();
// if (newCurrent != null) {
// SetNewCurrent(newCurrent, hit.transform.gameObject);
// _foundControl = true;
// }
// }
// else {
// if (currentActor == null) {
// Actor.Actors.TryGetValue(hit.collider, out currentActor);
// }
// }
// }
//}
UICenterTarget.SetTargetActor(currentActor.GetTemplate <CharacterTemplate>());
if (!_foundControl || currentActor != null)
{
SetCurrentNull();
}
if (_debug)
{
DebugText.UpdatePermText("World Control", string.Format("Current: {0}", _currentGameObject != null ? _currentGameObject.name : "None"));
}
//if (_current == null && AlternativeUse == null) {
// var wasActive = GenericDraggableController.HasTarget;
// if (GenericDraggableController.main.CanDrag()) {
// UICenterTarget.SetText("Drag");
// }
// else if (wasActive){
// UICenterTarget.Clear();
// }
//}
//else {
// GenericDraggableController.ClearTarget();
//}
}
public void OnSystemUpdate(float dt)
{
switch (_state)
{
case State.FinishingFall:
if (!FoundFloor())
{
_state = State.Falling;
}
else
{
transform.position = _floorLerp.Get();
if (!_floorLerp.Active)
{
_state = State.Disabled;
}
}
break;
case State.Pulling:
if (_pullTarget == null)
{
CheckState();
break;
}
var dir = (_pullTarget.position - transform.position);
var distance = dir.magnitude;
if (distance > _pullRange.Max * 1.5f)
{
CheckState();
}
else
{
transform.position = Vector3.MoveTowards(transform.position, _pullTarget.position, Mathf.Lerp(_pullSpeed * 0.25f, _pullSpeed, Mathf.InverseLerp(_pullRange.Max, _pullRange.Min, distance)) * dt);
}
break;
case State.Falling:
transform.Translate(-transform.up * _gravitySpeed * dt);
CheckState();
break;
case State.Throwing:
if (!_arcMover.Active)
{
CheckState();
break;
}
_arcMover.Get(transform);
break;
}
if (_collisionRadius > 0 && _collisions.Length > 0)
{
var cnt = Physics.OverlapSphereNonAlloc(transform.position, _collisionRadius, _tempColliders, _collisionMask);
for (int c = 0; c < cnt; c++)
{
var collEntity = UnityToEntityBridge.GetEntity(_tempColliders[c]);
if (collEntity == null)
{
continue;
}
for (int i = 0; i < _collisions.Length; i++)
{
_collisions[i].Collision(collEntity);
}
}
}
if (_pullRange.Max <= 0)
{
return;
}
switch (_state)
{
case State.Pulling:
case State.Throwing:
return;
}
var pullCnt = Physics.OverlapSphereNonAlloc(transform.position, _pullRange.Max, _tempColliders, _pullMask);
for (int c = 0; c < pullCnt; c++)
{
var coll = _tempColliders[c];
if (_playerOnly && !coll.transform.CompareTag(StringConst.TagPlayer))
{
continue;
}
_pullTarget = _tempColliders[0].transform;
_state = State.Pulling;
break;
}
}
