public virtual IEnumerator DisplayPreEffect()
{
if (castEffect != null)
{
EffectTarget effectTarget = (EffectTarget)castEffect.target;
if (effectTarget == EffectTarget.Enemy)
{
castEffectTrans = targetUnit.GetEffectPoint((EffectPoint)castEffect.bone);
}
else if (effectTarget == EffectTarget.Self)
{
castEffectTrans = mineUnit.GetEffectPoint((EffectPoint)castEffect.bone);
}
else if (effectTarget == EffectTarget.Screen)
{
castEffectTrans = FightEffectManager.instance.transform;
}
if (!string.IsNullOrEmpty(castEffectName))
{
yield return(StartCoroutine(AssetManager.LoadAsset(castEffectName, AssetManager.AssetType.Effect, false)));
GameObject obj = AssetManager.GetGameObject(castEffectName, castEffectTrans);
yield return(StartCoroutine(AssetManager.LoadAsset(castEffectAudioName, AssetManager.AssetType.Audio, false)));
AudioClip audio = AssetManager.GetAudio(castEffectAudioName);
obj.AddComponent <AudioSource> ().clip = audio;
StartCoroutine(WaitAudioDelay(castEffectAudioDelay));
obj.GetComponent <AudioSource> ().Play();
}
}
}
/// <summary>
/// 展现魔法特效
/// </summary>
public virtual IEnumerator DisplaydmgEffect(FightUnit dmgEffectTarget)
{
if (dmgEffect != null && !string.IsNullOrEmpty(dmgEffectName))
{
EffectTarget effectTarget = (EffectTarget)dmgEffect.target;
Transform dmgEffectTrans = null;
Vector3 effectLocalPos = Vector3.zero;
if (effectTarget == EffectTarget.Screen)
{
dmgEffectTrans = FightEffectManager.instance.transform;
}
else if (effectTarget == EffectTarget.MineCenter)
{
dmgEffectTrans = mineUnit.mTrans.parent;
effectLocalPos = mineUnit.parentGroup.Center;
}
else if (effectTarget == EffectTarget.EnemyCenter)
{
dmgEffectTrans = mineUnit.mTrans.parent;
effectLocalPos = targetUnit.parentGroup.Center;
}
else if (dmgEffectTarget != null)
{
dmgEffectTrans = dmgEffectTarget.GetEffectPoint((EffectPoint)dmgEffect.bone);
}
yield return(StartCoroutine(AssetManager.LoadAsset(dmgEffectName, AssetManager.AssetType.Effect, false)));
GameObject obj = AssetManager.GetGameObject(dmgEffectName, dmgEffectTrans);
obj.transform.localPosition = effectLocalPos;
}
}
/// <summary>
/// 展现施法特效
/// </summary>
public override IEnumerator DisplayPreEffect()
{
if (curCastEffect != null)
{
EffectTarget effectTarget = (EffectTarget)curCastEffect.target;
if (effectTarget == EffectTarget.Enemy)
{
castEffectTrans = targetUnit.GetEffectPoint((EffectPoint)curCastEffect.bone);
}
else if (effectTarget == EffectTarget.Self)
{
castEffectTrans = mineUnit.GetEffectPoint((EffectPoint)curCastEffect.bone);
}
else if (effectTarget == EffectTarget.Screen)
{
castEffectTrans = FightEffectManager.instance.transform;
}
castEffectName = Util.GetConfigString(curCastEffect.name);
if (!string.IsNullOrEmpty(castEffectName))
{
yield return(StartCoroutine(AssetManager.LoadAsset(castEffectName, AssetManager.AssetType.Effect, false)));
GameObject obj = AssetManager.GetGameObject(castEffectName, castEffectTrans);
}
}
}
public Potion(string id, string name, EffectType effectType, EffectTarget effectTarget, int amount)
: base(id, name, SubType.Potion)
{
EffectType = effectType;
EffectTarget = effectTarget;
Amount = amount;
}
public void ActivateAllEffect(EffectTarget target)
{
foreach (Effect effect in Effects)
{
target.AddEffect(effect.CloneEffect());
}
}
public TimeEffect(EffectTarget _target, StatType _targetStat, float _value, int stack, int step = 1)
{
this.target = _target;
this.targetStat = _targetStat;
this.value = _value;
this.Stack = stack;
this.initStack = stack;
this.Step = step;
}
private IEnumerable <ActorBase> GetTarget(EffectTarget target, ActorBase source)
{
switch (target)
{
case EffectTarget.Self:
yield return(source);
break;
case EffectTarget.EnemyActive:
yield return(enemy.GetCurrentEnemy().Instance);
break;
case EffectTarget.CaravanActive:
yield return(caravan.activeCaravanActor);
break;
case EffectTarget.Caravan:
foreach (var item in caravan.caravan)
{
yield return(item);
}
break;
case EffectTarget.CaravanActiveOrCaravan:
yield return(caravan.GetFirstAvailablePlayerTarget());
break;
case EffectTarget.CaravanHighestHealth:
yield return(caravan.GetHighestHealthCaravanMember());
break;
case EffectTarget.CaravanLowestHealth:
yield return(caravan.GetLowestHealthCaravanMember());
break;
case EffectTarget.CaravanAndActive:
foreach (var item in caravan.caravan)
{
yield return(item);
}
yield return(caravan.activeCaravanActor);
break;
default:
Debug.LogError($"Target not implemented: {target.ToString()}");
yield break;
}
}
public EffectTemplate(string line)
{
string[] parts = line.Split('/');
this.Target = parts[0] == "target" ? EffectTarget.Target : EffectTarget.User;
this.Probability = Int32.Parse(parts[1].Split(',')[0]);
this.ProbabilityGrowth = Int32.Parse(parts[1].Split(',')[1]);
this.Type = parts[2];
this.Animation = parts[3];
this.Colour = Utility.GetColor(parts[4]);
}
public SkillStatus()
{
this._prefabId = string.Empty;
this._seId = string.Empty;
this._skillType = SkillType.Attack;
this._name = string.Empty;
this._description = string.Empty;
this._target = EffectTarget.Enemy;
this._numbers = EffectNumbers.Simple;
this._needAp = 0;
this._affectEffect = new List <AffectEffectProperty>();
this._affectEffect.Add(new AffectEffectProperty());
this._returnAffectEffect.AddRange(this._affectEffect);
}
public ModEffectOnAttacking(AttackOrAttacked onAttackOrAttacked, AbilityEffect[] effects, float chance, EffectTarget effectTarget, bool mustBeAttack, bool attackMustHit,
AttackType attackType, DamageType damageType, bool attackMustBeDefended, bool attackMustCrit)
{
this.onAttackOrAttacked = onAttackOrAttacked;
this.effects = effects;
this.chance = chance;
this.effectTarget = effectTarget;
this.mustBeAttack = mustBeAttack;
this.attackMustHit = attackMustHit;
this.attackMustBeDefended = attackMustBeDefended;
this.attackMustCrit = attackMustCrit;
this.attackType = attackType;
this.damageType = damageType;
}
private void CheckEffectActivation(bool isHit)
{
if (isEffectOnHit == isHit)
{
FollowerAttackStats attackStats = attackManager.GetAttackStats(currentAttack);
EffectTarget atkFXTarget = attackStats.EffectTarget;
if (atkFXTarget == EffectTarget.None)
{
if (attackStats.movePool == FollowerAttackPool.Cleanse)
{
fighter.ClearEffect(debuffCleanseQueue.Dequeue());
}
else
{
foreach (var resource in resourceTypes)
{
float recoveryAmount = attackStats.Power / 100 * resource.GetMaxAttributeValue();
// healAmount *= baseStats.GetStat(Stat.Spirit) / 100;
resource.GainAttribute(recoveryAmount);
}
}
return;
}
string atkFXid = attackStats.EffectID.ToString();
switch (atkFXTarget)
{
case EffectTarget.Enemy:
fighter.PassEffectEnemy(atkFXid);
break;
case EffectTarget.Self:
fighter.PassEffectSelf(atkFXid);
break;
case EffectTarget.Player:
fighter.PassEffectPlayer(atkFXid);
break;
case EffectTarget.Party:
fighter.PassEffectParty(atkFXid);
break;
default:
Debug.Log("Effect has no target!");
break;
}
}
}
public ConstantEffect(EffectTarget effecttarget, bool decrement, int effectamount, Action effectaction = null)
{
if (effectaction == null)
{
_action = () => { };
}
else
{
_action = effectaction;
}
_target = effecttarget;
_decrement = decrement;
_amount = effectamount;
}
public static ItfElement PtGetCursor(EffectTarget target, Player player, int mx, int my)
{
ItfElement result = ItfElement.id_Cursor;
if (target == EffectTarget.et_Direction || target == EffectTarget.et_Creature)
{
int px = player.PosX;
int py = player.PosY;
int dist = MathHelper.Distance(px, py, mx, my);
if (dist > 0)
{
switch (Directions.GetDirByCoords(px, py, mx, my))
{
case Directions.DtNorth:
result = ItfElement.id_Cursor_N;
break;
case Directions.DtSouth:
result = ItfElement.id_Cursor_S;
break;
case Directions.DtWest:
result = ItfElement.id_Cursor_W;
break;
case Directions.DtEast:
result = ItfElement.id_Cursor_E;
break;
case Directions.DtNorthWest:
result = ItfElement.id_Cursor_NW;
break;
case Directions.DtNorthEast:
result = ItfElement.id_Cursor_NE;
break;
case Directions.DtSouthWest:
result = ItfElement.id_Cursor_SW;
break;
case Directions.DtSouthEast:
result = ItfElement.id_Cursor_SE;
break;
}
}
}
return(result);
}
private void SetCurrentTargettingCharacter(EffectTarget target, int num)
{
switch (target)
{
case EffectTarget.Enemy:
case EffectTarget.EnemyWithoutAttacker:
this._currentTargettingCharacter_Enemy = num;
break;
case EffectTarget.Ally:
case EffectTarget.AllyWithoutAttacker:
this._currentTargettingCharacter_Ally = num;
break;
}
}
static Targets()
{
Individual = new EffectTarget(WizardMonks.Targets.Individual, 0);
Taste = new EffectTarget(WizardMonks.Targets.Taste, 0);
Circle = new EffectTarget(WizardMonks.Targets.Circle, 0);
Part = new EffectTarget(WizardMonks.Targets.Part, 1);
Touch = new EffectTarget(WizardMonks.Targets.Touch, 1);
Group = new EffectTarget(WizardMonks.Targets.Group, 2);
Smell = new EffectTarget(WizardMonks.Targets.Smell, 2);
Room = new EffectTarget(WizardMonks.Targets.Room, 2);
Structure = new EffectTarget(WizardMonks.Targets.Structure, 3);
Hearing = new EffectTarget(WizardMonks.Targets.Hearing, 3);
Boundary = new EffectTarget(WizardMonks.Targets.Boundary, 4, true);
Sight = new EffectTarget(WizardMonks.Targets.Sight, 4);
}
public SkillStatus(string skillId, string prefabId, string seId, SkillType skillType, string name, string description, EffectTarget target, EffectNumbers numbers, int needAp, string useCountType, int useCountValue, params AffectEffectProperty[] affectEffect)
{
this.skillId = skillId;
this._prefabId = prefabId;
this._seId = seId;
this._skillType = skillType;
this._name = name;
this._description = description;
this._target = target;
this._numbers = numbers;
this._needAp = needAp;
this._useCountType = useCountType;
this._useCountValue = useCountValue;
this._affectEffect = new List <AffectEffectProperty>(affectEffect);
this._returnAffectEffect.AddRange(this._affectEffect);
}
public void Use(Actor by, Coord target)
{
Direction fireDirection = Direction.GetDirection(by.Parent.Position, target);
Coord spawnPos = by.Parent.Position + fireDirection;
GameObject projectile = new UpdatingGameObject(spawnPos, Layers.Main, null, by.GameObject.Timeline);
Characters[] alignChars = new[] {Characters.VERTICAL_LINE, Characters.SLASH, Characters.HYPHEN, Characters.BACK_SLASH, Characters.VERTICAL_LINE, Characters.SLASH, Characters.HYPHEN, Characters.BACK_SLASH};
int dX = target.X - spawnPos.X;
int dY = target.Y - spawnPos.Y;
int dist = (int) Distance.MANHATTAN.Calculate(dX, dY);
int speed = 30;
int xVel = dX == 0 ? 0 : speed * dist / dX;
int yVel = dY == 0 ? 0 : speed * dist / dY;
Damagable damagable = new Damagable(1);
projectile.AddComponent(damagable);
projectile.AddComponent(new GlyphComponent(new Glyph(alignChars[(int) fireDirection.Type], Color.SaddleBrown)));
projectile.AddComponent(new NameComponent(new Title("an", "arrow")));
ProjectileComponent projectileComponent = new ProjectileComponent(xVel, yVel, damagable);
projectileComponent.OnCollide += (gameObject) =>
{
EffectTarget effectTarget = gameObject?.GetComponent<EffectTargetComponent>()?.EffectTarget;
effectTarget?.ApplyEffect(new DamageEffect(_damage));
by.MainBus.Send(new ParticleEvent(new GlyphFlash(new Glyph(Characters.ASTERISK, Color.Red), 200,
gameObject.Position)));
if(gameObject.GetComponent<NameComponent>() is NameComponent nameComponent)
by.MainBus.Send(new LogMessage($"{{0}} was hit by {{1}}'s arrow", new LogLink(nameComponent.Title.ToString(), Color.Aquamarine, by), new LogLink(by.Being.Name, Color.Aquamarine, by)));
};
projectile.AddComponent(projectileComponent);
by.MainBus.Send(new SpawnEvent(projectile));
}
private int GetCurrentTargettingCharacter(EffectTarget target)
{
switch (target)
{
case EffectTarget.Enemy:
case EffectTarget.EnemyWithoutAttacker:
return(this._currentTargettingCharacter_Enemy);
case EffectTarget.Ally:
case EffectTarget.AllyWithoutAttacker:
return(this._currentTargettingCharacter_Ally);
case EffectTarget.Attacker:
return(base.battleStateData.currentSelectCharacterIndex);
default:
return(base.battleStateData.currentSelectCharacterIndex);
}
}
public IList <BattleCharacter> GetPossibleTargets(BattleCharacter src, EffectTarget target)
{
if (target == EffectTarget.Self)
{
return(src.AsList());
}
if (target == EffectTarget.AllEnemies)
{
return(_characters.Where(x => x.Loyalty != src.Loyalty).ToList());
}
if (target == EffectTarget.AllAllies)
{
return(_characters.Where(x => x.Loyalty == src.Loyalty).ToList());
}
if (target == EffectTarget.One)
{
return(_characters.ToList());
}
return(new List <BattleCharacter>());
}
private static string TargetToFriendlyString(EffectTarget target)
{
switch (target)
{
case EffectTarget.EnemyActive:
return("enemy");
case EffectTarget.EnemyPack:
return("enemy pack");
case EffectTarget.EnemyActiveAndPack:
return("all enemies");
case EffectTarget.Self:
return("self");
case EffectTarget.CaravanActive:
return("active member");
case EffectTarget.CaravanActiveOrCaravan:
return("active or caravan member");
case EffectTarget.Caravan:
return("caravan");
case EffectTarget.CaravanAndActive:
return("all caravan members");
case EffectTarget.CaravanLowestHealth:
return("lowest health caravan member");
case EffectTarget.CaravanHighestHealth:
return("highest health caravan member");
default:
throw new Exception($"No valid value: {target}");
}
}
public void Use(Actor by, Coord target)
{
IGameObject gameObject = by.Parent.CurrentMap.GetObject(target);
EffectTarget effectTarget = gameObject?.GetComponent <EffectTargetComponent>()?.EffectTarget;
effectTarget?.ApplyEffect(new DamageEffect(_damage));
by.Parent.GetComponent <EffectTargetComponent>()?.EffectTarget.ApplyEffect(new StaminaEffect(-_stamina));
if (effectTarget != null)
{
by.MainBus.Send(new ParticleEvent(new GlyphFlash(new Glyph(Characters.SLASH, Color.Red), 200,
target)));
by.MainBus.Send(new LogMessage($"{{0}} attacked with their {Title.Name}", new LogLink(by.Being.Name, Color.Aquamarine, by)));
}
else
{
by.MainBus.Send(new ParticleEvent(new GlyphFlash(new Glyph(Characters.FULL_BLOCK, Color.FromArgb(100, Color.Gray)), 200,
target)));
by.MainBus.Send(new LogMessage($"{{0}} missed with their {Title.Name}", new LogLink(by.Being.Name, Color.Aquamarine, by)));
}
}
private bool checkUseSkill(SkillStatus status, CharacterStateControl currentCharacter, CharacterStateControl tg)
{
bool isProtectEnableSkill = false;
foreach (AffectEffectProperty affectEffectProperty in status.affectEffect)
{
if (AffectEffectProperty.IsDamage(affectEffectProperty.type))
{
isProtectEnableSkill = true;
break;
}
}
List <SubStateSkillDetailsFunction.TargetData> list = new List <SubStateSkillDetailsFunction.TargetData>();
int num = 0;
for (int i = 0; i < status.affectEffect.Count; i++)
{
AffectEffectProperty affectEffectProperty2 = status.affectEffect[i];
if (AffectEffectProperty.IsDamage(affectEffectProperty2.type))
{
num += affectEffectProperty2.hitNumber;
}
}
bool flag = true;
AffectEffectProperty affectEffectProperty3 = null;
bool flag2 = false;
bool result = false;
bool flag3 = false;
EffectTarget effectTarget = EffectTarget.Enemy;
for (int j = 0; j < status.affectEffect.Count; j++)
{
DkLog.W("↓↓↓↓↓↓", false);
AffectEffectProperty affectEffectProperty4 = status.affectEffect[j];
if (j == 0)
{
effectTarget = affectEffectProperty4.target;
}
if (affectEffectProperty3 != null && affectEffectProperty3.target != affectEffectProperty4.target)
{
CharacterStateControl[] skillTargetList = base.stateManager.targetSelect.GetSkillTargetList(currentCharacter, affectEffectProperty4.target);
if (skillTargetList != null && skillTargetList.Length > 0)
{
currentCharacter.targetCharacter = skillTargetList[0];
}
if (effectTarget == affectEffectProperty4.target)
{
currentCharacter.targetCharacter = tg;
}
}
list = this.CreateTargetData(list, currentCharacter, affectEffectProperty4, isProtectEnableSkill, ref flag);
affectEffectProperty3 = affectEffectProperty4;
if (this.SwitchAffectEffect(affectEffectProperty4, currentCharacter, tg, list, ref flag3, ref flag2))
{
DkLog.W(string.Format("targetDataList {0} : currentSuffer.type {1} : tg {2} : skip {3}", new object[]
{
list.Count,
affectEffectProperty4.type,
string.Empty,
flag2
}), false);
if (!flag2)
{
result = true;
DkLog.W(string.Format("targetDataList.Count {0}", list.Count), false);
}
}
}
return(result);
}
public void Exec(NWCreature creature, EffectID effectID, InvokeMode invokeMode, EffectExt ext, string rayMsg)
{
GlobalVars.nwrWin.ShowText(creature, rayMsg);
int i = Effect.GetMagnitude(effectID);
EffectTarget target = EffectTarget.et_None;
if ((ext.ReqParams.Contains(EffectParams.ep_Direction)))
{
target = EffectTarget.et_Direction;
}
else
{
if ((ext.ReqParams.Contains(EffectParams.ep_Creature)))
{
target = EffectTarget.et_Creature;
}
}
int x;
int y;
int x2;
int y2;
if (target != EffectTarget.et_Direction)
{
if (target != EffectTarget.et_Creature)
{
return;
}
x = creature.PosX;
y = creature.PosY;
NWCreature extCr = (NWCreature)ext.GetParam(EffectParams.ep_Creature);
x2 = extCr.PosX;
y2 = extCr.PosY;
int dir = Directions.GetDirByCoords(x, y, x2, y2);
x += Directions.Data[dir].DX;
y += Directions.Data[dir].DY;
}
else
{
int dir = (int)ext.GetParam(EffectParams.ep_Direction);
x = creature.PosX + Directions.Data[dir].DX;
y = creature.PosY + Directions.Data[dir].DY;
x2 = x + Directions.Data[dir].DX * i;
y2 = y + Directions.Data[dir].DY * i;
}
Creature = creature;
Dir = Directions.GetDirByCoords(x, y, x2, y2);
EffID = effectID;
Field = Creature.CurrentField;
int eid = (int)effectID;
EffectRec effRec = EffectsData.dbEffects[eid];
if (effRec.FrameCount > 0)
{
MapObject = new MapObject(creature.Space, Field);
MapObject.InitByEffect(effectID);
Field.Features.Add(MapObject);
}
else
{
MapObject = null;
}
TargetMeeted = AuxUtils.DoLine(x, y, x2, y2, LineProc, true);
if (MapObject != null)
{
Field.Features.Remove(MapObject);
}
}
public void ResolveEffect(EffectTarget effectTarget)
{
effectTarget.ResolveEffect();
}
private AddTagEffectViewModel(TagViewModelBase tag, KeyConflictResolutionKind conflictResolution, ConditionViewModelBase condition, EffectTarget target)
: base(condition, target)
{
m_tag = tag;
m_conflictResolution = conflictResolution;
}
private RemoveTagsEffectViewModel(string tagKey, MatchKind tagKeyMatchKind, ConditionViewModelBase condition, EffectTarget target)
: base(condition, target)
{
m_tagKey = tagKey;
m_tagKeyMatchKind = tagKeyMatchKind;
}
static Targets()
{
Individual = new EffectTarget(WizardMonks.Targets.Individual, 0);
Taste = new EffectTarget(WizardMonks.Targets.Taste, 0);
Circle = new EffectTarget(WizardMonks.Targets.Circle, 0);
Part = new EffectTarget(WizardMonks.Targets.Part, 1);
Touch = new EffectTarget(WizardMonks.Targets.Touch, 1);
Group = new EffectTarget(WizardMonks.Targets.Group, 2);
Smell = new EffectTarget(WizardMonks.Targets.Smell, 2);
Room = new EffectTarget(WizardMonks.Targets.Room, 2);
Structure = new EffectTarget(WizardMonks.Targets.Structure, 3);
Hearing = new EffectTarget(WizardMonks.Targets.Hearing, 3);
Boundary = new EffectTarget(WizardMonks.Targets.Boundary, 4, true);
Sight = new EffectTarget(WizardMonks.Targets.Sight, 4);
}
protected EffectBase(IDeserializer deserializer)
{
Condition = deserializer.GetValue <ConditionBase>(nameof(Condition));
Target = deserializer.GetValue <EffectTarget>(nameof(Target));
}
protected EffectBase(ConditionBase condition, EffectTarget target)
{
Condition = condition;
Target = target;
}
public CopyTagsEffect(string tagKey, MatchKind tagKeyMatchKind, TagScope tagScope, ConditionBase condition, string newTagKey, KeyConflictResolutionKind conflictResolution, EffectTarget target)
: base(condition, target)
{
TagKey = tagKey;
TagKeyMatchKind = tagKeyMatchKind;
TagScope = tagScope;
NewTagKey = newTagKey;
ConflictResolution = conflictResolution;
}
private CopyTagsEffectViewModel(string tagKey, MatchKind tagKeyMatchKind, TagScope tagScope, string newTagKey, KeyConflictResolutionKind conflictResolution, ConditionViewModelBase condition, EffectTarget target)
: base(condition, target)
{
m_tagKey = tagKey;
m_tagKeyMatchKind = tagKeyMatchKind;
m_tagScope = tagScope;
m_newTagKey = newTagKey;
m_conflictResolution = conflictResolution;
}
