public void ClickDel(UISimpleGameDataButton button, PointerEventData.InputButton buttonEvent)
{
var item = button.Data as Entity;
if (item != null)
{
World.Get <ContainerSystem>().TryAdd(Player.MainInventory, item);
}
}
public static void PostImpactEvent(CharacterTemplate origin, CharacterTemplate target, BaseActionTemplate action, Vector3 hitPoint,
Vector3 hitNormal)
{
var hitRotation = hitNormal == Vector3.zero ? Quaternion.identity : Quaternion.LookRotation(hitNormal);
var ae = new ActionEvent(action, origin, target, hitPoint, hitRotation, ActionState.Impact);
World.Get <RulesSystem>().Post(new ImpactEvent(action, origin, target, hitPoint, hitNormal));
origin.Post(ae);
}
private void RunUpdate(ref SensorDetectingNode node)
{
var sensor = node.Sensor;
sensor.DetectedCells.Clear();
var start = node.Position.Position;
sensor.LastDetectedCenter = start;
var fwd = node.Tr.ForwardDirection2D();
var ls = World.Get <LineOfSightSystem>();
for (int i = 0; i < DirectionsExtensions.Length2D; i++)
{
var dir = (Directions)i;
var maxRowDistance = dir == fwd ? sensor.MaxVisionDistance : sensor.MaxHearDistance;
var adjacent = dir.Adjacent();
ShadowFloodFill.CheckRow(
ref sensor.DetectedCells, start, start,
maxRowDistance, new[] { adjacent[0].ToPoint3(), adjacent[1].ToPoint3() }, dir.ToPoint3());
}
for (int i = 0; i < _occupyNodes.Max; i++)
{
if (_occupyNodes.IsInvalid(i))
{
continue;
}
var visible = _occupyNodes[i];
if (visible.Entity == node.Entity)
{
continue;
}
if (!sensor.DetectedCells.Contains(visible.Position))
{
continue;
}
var isVision = true;
if (CheckVision)
{
ls.CanSeeOrHear(node.Entity, visible.Entity, out isVision);
}
sensor.AddWatch(visible.Entity, isVision);
}
for (int w = sensor.WatchTargets.Count - 1; w >= 0; w--)
{
if (sensor.WatchTargets[w].Target == null)
{
sensor.RemoveWatch(sensor.WatchTargets[w]);
continue;
}
sensor.WatchTargets[w].LastSensedTurnCount++;
if (sensor.WatchTargets[w].LastSensedTurnCount > MaxTurnsNpcVisible)
{
sensor.RemoveWatch(sensor.WatchTargets[w]);
}
}
}
private void Update(ref Command node)
{
if (node.TryComplete())
{
node.Complete();
World.Get <TurnBasedSystem>().CommandComplete(node.Owner);
_commands.Remove(node);
Store(node);
}
}
public void Collision(Entity hitEntity)
{
var template = hitEntity.GetTemplate <CharacterTemplate>();
if (template != null && template.Tags.Contain(EntityTags.Player))
{
World.Get <RulesSystem>().Post(new HealingEvent(null, _amount, template, template, _vital));
ItemPool.Despawn(gameObject);
}
}
public static ParticlePlayer PlayParticle(SpriteParticle particle, Vector3 pos, Quaternion rot)
{
var ps = World.Get <SpriteParticleSystem>();
var player = ps.GetPlayer();
player.Tr.position = pos;
player.Tr.rotation = rot;
player.PlayAnimation(particle);
ps._current.Add(player);
return(player);
}
public static void GetVisiblePoints(Point3 start, int maxRowDistance, Action <LevelCell> del, Func <LevelCell, bool> ignoreCheck)
{
if (World.Get <MapSystem>().GetCell(start) == null)
{
return;
}
CheckRow(start, start, maxRowDistance, del, ignoreCheck, new[] { new Point3(0, 0, 1), new Point3(0, 0, -1) }, new Point3(-1, 0, 0));
CheckRow(start, start, maxRowDistance, del, ignoreCheck, new[] { new Point3(0, 0, 1), new Point3(0, 0, -1) }, new Point3(1, 0, 0));
CheckRow(start, start, maxRowDistance, del, ignoreCheck, new[] { new Point3(1, 0, 0), new Point3(-1, 0, 0) }, new Point3(0, 0, 1));
CheckRow(start, start, maxRowDistance, del, ignoreCheck, new[] { new Point3(1, 0, 0), new Point3(-1, 0, 0) }, new Point3(0, 0, -1));
}
private void RunTurn()
{
if (_current.IsPlayer())
{
World.Get <PlayerTurnBasedSystem>().TurnContinue(_current);
}
else
{
World.Get <NpcTurnBasedSystem>().TurnContinue(_current);
}
}
public bool EquipToEmpty(Entity actionEntity)
{
for (int i = 0; i < _list.Count; i++)
{
if (_list[i].Item == null && World.Get <EquipmentSystem>().TryEquip(_list[i], actionEntity))
{
return(true);
}
}
return(false);
}
public static void AddItemToPlayer()
{
if (World.Get <ContainerSystem>().TryAdd(Player.MainInventory, CurrentData))
{
Take();
}
else
{
ClearData();
}
}
public static void HealEntity(int entityId, int amount)
{
var entity = EntityController.GetEntity(entityId);
if (entity == null)
{
Console.Log("No Entity " + entityId);
return;
}
World.Get <RulesSystem>().Post(new HealingEvent(amount, null, null, "Vitals.Health"));
Console.Log(entity.Get <StatsContainer>().GetVital("Vitals.Health").ToLabelString());
}
public void Handle(ActionStateEvent arg)
{
if (arg.State == ActionStateEvents.Start)
{
Triggered = false;
}
else if (arg.State == ActionStateEvents.Impact && !Triggered)
{
Triggered = true;
World.Get <RadiusSystem>().HandleRadius(EntityController.GetEntity(arg.Origin), EntityController.GetEntity(arg.Focus), Radius);
}
}
private void StartTurn()
{
_current.Entity.Post(new StartTurnEvent(_current.Entity));
if (_current.IsPlayer())
{
World.Get <PlayerTurnBasedSystem>().TurnStart(_current);
}
else
{
World.Get <NpcTurnBasedSystem>().TurnStart(_current);
}
}
public bool Remove(Entity entity)
{
for (int i = 0; i < Count; i++)
{
if (this[i] == entity)
{
World.Get <EquipmentSystem>().ClearEquippedItem(_list[i], false);
return(true);
}
}
return(false);
}
public static void PrintLog()
{
var log = World.Get <CollisionEventSystem>()._eventLog;
foreach (var msg in log.InOrder())
{
Console.Log(string.Format("{5}: {0} hit {1} at {2} {3} source {4}",
msg.Origin?.Entity.DebugId ?? "null",
msg.Target?.Entity.DebugId ?? "null",
msg.HitPoint, msg.HitNormal, msg.Source.DebugId, log.GetTime(msg)));
}
}
public static bool SatisfiesCondition(this CommandTargeting targeting, Entity target)
{
if (targeting.Criteria == TargetType.Any && targeting.Range <= 0)
{
return(true);
}
var owner = targeting.GetEntity();
if (owner == null)
{
return(true);
}
switch (targeting.Criteria)
{
case TargetType.Enemy:
if (!World.Get <FactionSystem>().AreEnemies(owner, target))
{
return(false);
}
break;
case TargetType.Friendly:
if (!World.Get <FactionSystem>().AreFriends(owner, target))
{
return(false);
}
break;
case TargetType.Self:
if (target != null && target.Id != targeting.Owner)
{
return(false);
}
break;
}
if (targeting.RequireLoS)
{
if (target != null && !World.Get <LineOfSightSystem>().CanSee(owner, target))
{
return(false);
}
if (target == null)
{
return(false);
}
}
if (targeting.Range > 0.25f)
{
var dist = DistanceSystem.GetDistance(owner, target);
return(dist <= targeting.Range);
}
return(true);
}
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);
}
}
}
public void HandleGlobal(DeathEvent arg)
{
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Clear();
logMsg.Append(arg.Caused.GetName());
logMsg.Append(" killed ");
logMsg.Append(arg.Target.GetName());
logSystem.PostCurrentStrings(GameLogSystem.DeathColor);
arg.Target.Tags.Add(EntityTags.IsDead);
arg.Target.Tags.Add(EntityTags.CantMove);
}
protected override void TryDrop() {
var newItem = UIDragDropHandler.CurrentData;
if (World.Get<EquipmentSystem>().TryEquip(_slot, newItem)) {
UIDragDropHandler.Take();
}
else {
if (PlayAudio) {
AudioPool.PlayClip(StringConst.AudioDefaultItemReturn, transform.position, 0, AudioVolume);
}
UIFloatingText.InventoryMessage(_slot.LastEquipStatus, RectTransform);
UIDragDropHandler.Return();
}
}
public void HandleGlobal(CollisionEvent msg)
{
_eventLog.Add(msg);
if (msg.Hit < 0)
{
msg.Hit = CollisionResult.Hit;
for (int h = 0; h < _globalHandlers.Count; h++)
{
msg.Hit = MathEx.Min(_globalHandlers[h].CheckHit(msg), msg.Hit);
}
}
if (msg.Hit <= 0)
{
return;
}
var criticalHit = msg.Target.Entity.Get <CriticalHitCollider>();
if (criticalHit != null && criticalHit.IsCritical(msg.Target.Tr, msg.HitPoint))
{
msg.Hit = CollisionResult.CriticalHit;
}
var ae = new ActionEvent(msg.Origin.Entity, msg.Target.Entity, msg.HitPoint,
msg.HitNormal == Vector3.zero ? Quaternion.identity :Quaternion.LookRotation(msg.HitNormal),
ActionState.Impact);
var origin = msg.Origin.Entity.FindTemplate <CharacterTemplate>();
World.Get <RulesSystem>().Post(new ImpactEvent(msg, ae.Action, origin, msg.Target.Entity.FindTemplate <CharacterTemplate>()));
msg.Origin.Post(ae);
if (!_collisionMessage)
{
return;
}
_collisionString.Clear();
_collisionString.Append(msg.Origin.GetName());
if (msg.Hit == CollisionResult.CriticalHit)
{
_collisionString.Append(" critically hit ");
}
else
{
_collisionString.Append(" struck ");
}
_collisionString.Append(msg.Target.GetName());
MessageKit <UINotificationWindow.Msg> .post(Messages.MessageLog, new UINotificationWindow.Msg(
_collisionString.ToString(), "", Color.blue));
if (msg.Target.Entity.HasComponent <DespawnOnCollision>())
{
msg.Target.Entity.Destroy();
}
}
public static bool IsValidCollision(Entity entity, bool limitEnemy, Entity hitEntity, Collider collider, out CollidableTemplate
sourceTemplate, out CollidableTemplate targetTemplate)
{
sourceTemplate = targetTemplate = null;
if (hitEntity == entity)
{
return(false);
}
var tr = collider.transform;
if (tr.CompareTag(StringConst.TagInvalidCollider) ||
tr.CompareTag(StringConst.TagSensor))
{
return(false);
}
if (!hitEntity.Tags.Contain(EntityTags.CanUnityCollide))
{
return(false);
}
if (AreEntitiesConnected(hitEntity, entity))
{
return(false);
}
#if DEBUG
DebugLog.Add(entity.DebugId + " hit actor " + tr.name);
#endif
sourceTemplate = entity.FindTemplate <CollidableTemplate>();
targetTemplate = hitEntity.FindTemplate <CollidableTemplate>();
if (sourceTemplate == null || targetTemplate == null || sourceTemplate == targetTemplate)
{
return(false);
}
if (limitEnemy)
{
if (World.Get <FactionSystem>().AreEnemies(sourceTemplate.Entity, targetTemplate.Entity))
{
if (entity.Tags.IsConfused)
{
return(false);
}
}
else
{
if (!entity.Tags.IsConfused)
{
return(false);
}
}
}
return(true);
}
private void CheckBuy(int index)
{
if (index > 0 || Data == null)
{
return;
}
var sellPrice = RulesSystem.TotalPrice(InventoryItem);
if (World.Get <ContainerSystem>().TryAdd(Player.MainInventory, Data))
{
StatusMessages(string.Format("Bought for {0} {1}", sellPrice, GameText.DefaultCurrencyLabel));
Clear();
}
}
public bool CanRuleEventStart(ref InstantKillEvent context)
{
var success = RulesSystem.DiceRollSuccess(context.InstantKill.Chance);
var logSystem = World.Get <GameLogSystem>();
logSystem.StartNewMessage(out var logMsg, out var hoverMsg);
logMsg.Append(context.Origin.GetName());
logMsg.Append(" used instant kill on ");
logMsg.Append(context.Target.GetName());
logMsg.Append(success ? " and succeeded" : " and failed");
hoverMsg.AppendNewLine(RulesSystem.LastQueryString.ToString());
logSystem.PostCurrentStrings(!success ? GameLogSystem.NormalColor : GameLogSystem.DeathColor);
return(success);
}
public static void PrintLog()
{
var log = World.Get <DamageSystem>()._eventLog;
foreach (var msg in log.InOrder())
{
Console.Log(
string.Format(
"{5}: Damage {0} hit {1} Amount {2} Type {3} Vital {4}",
msg.Origin?.Entity.DebugId ?? "null",
msg.Target?.Entity.DebugId ?? "null",
msg.Amount, msg.DamageType, msg.TargetVital, log.GetTime(msg)));
}
}
public static void PrintLog()
{
var log = World.Get <ActionSystem>()._eventLog;
foreach (var msg in log.InOrder())
{
Console.Log(
string.Format(
"{5}: Action source {0} target {1} at {2} {3} State {4}",
msg.Origin?.Entity.DebugId ?? "null",
msg.Target?.Entity.DebugId ?? "null",
msg.Position, msg.Rotation, msg.State, log.GetTime(msg)));
}
}
public virtual void OnPointerClick(PointerEventData eventData)
{
if (_watchedMod == null)
{
return;
}
if (eventData.button == PointerEventData.InputButton.Right)
{
if (_watchedMod.Value.Target.HasComponent <PlayerComponent>())
{
World.Get <ModifierSystem>().RemoveStatMod(_watchedMod.Value.Id);
}
}
}
public static void OnUsage(ActionEvent ae, ActionCommand cmd, string stat)
{
var prepareDamage = new PrepareDamageEvent(ae.Origin, ae.Target, cmd.Action, cmd.HitResult);
var damageStat = cmd.Owner.Stats.Get <DiceStat>(stat);
if (damageStat == null)
{
return;
}
var total = cmd.HitResult.Result == CollisionResult.CriticalHit ? damageStat.GetMax() : damageStat.Value;
prepareDamage.Entries.Add(new DamageEntry(total, cmd.Action.Data.GetString(AbilityDataEntries.DamageType), Stats.Health, "Weapon Attack"));
World.Get <RulesSystem>().Post(prepareDamage);
}
public bool EquipToHidden(Entity actionEntity)
{
for (int i = 0; i < _list.Count; i++)
{
if (_list[i].Type != PivotTypes.Hidden)
{
continue;
}
if (_list[i].Item == null && World.Get <EquipmentSystem>().TryEquip(_list[i], actionEntity))
{
return(true);
}
}
return(false);
}
public void Trigger(ActionEvent stateEvent, string eventName)
{
if (!stateEvent.Origin.IsPlayer())
{
return;
}
if (IsRotation)
{
World.Get <EntityEventSystem>().Post(new CameraRotationForceEvent(stateEvent.Rotation.eulerAngles, Frames));
}
else
{
World.Get <EntityEventSystem>().Post(new CameraPositionForceEvent(stateEvent.Rotation.eulerAngles, Frames));
}
}
private bool TryEquip(Equipment equip, Entity entity, bool overrideCurrent)
{
for (int i = 0; i < _list.Count; i++)
{
if (_list[i].Item != null && !overrideCurrent)
{
continue;
}
if (_list[i].CompatibleSlots.Contains(equip.EquipmentSlotType) && World.Get <EquipmentSystem>().TryEquip(_list[i], entity))
{
return(true);
}
}
return(false);
}
