/// <summary>
/// 殺す
/// </summary>
/// <param name="attacker"></param>
public virtual void Kill(IAttacker attacker)
{
var message = "";
switch (attacker)
{
case CharacterAttacker cAttacker:
//debug
if (!cAttacker.Attacker)
{
message = "Unknown";
break;
}
message = cAttacker.Attacker.name;
break;
case StatusAttacker sAttacker:
message = sAttacker.StatusOwner.name + "の" + sAttacker.Attacker.GetStatusName();
break;
default:
message = "Unknown";
break;
}
// Debug.Log($"{name}は{message}に倒された!");
Death();
}
/// <summary>
/// 技能是否放到的检测
/// </summary>
protected bool SkillDistanceJudge(IAttacker attackObject, Transform beAttacker, string disType, float x, float y)
{
bool res = false;
switch (disType)
{
case "Forward":
if (!LookAtJudge(attackObject, beAttacker))
{
return(false); //朝向不满足
}
if (!IsInSkillDistance(attackObject, beAttacker, x, y))
{
return(false); //不在技能范围内
}
res = true;
break;
case "Range":
if (!IsInSkillDistance(attackObject, beAttacker, x, y))
{
return(false); //不在技能范围内
}
res = true;
break;
default:
break;
}
return(res);
}
public bool ExecuteAttackOrder(IAttacker attacker, IAttacker target)
{
var args = new AttackOrderEventArgs(this, attacker, target);
AttackOrderEvent.Call(args);
return(args.succesful);
}
public void SyncKill(IAttacker attacker)
{
Assert.IsTrue(attacker is IPhotonBehaviour);
int attackerViewID = ((IPhotonBehaviour)attacker).PhotonView.viewID;
photonView.RPC("SyncKillRPC", PhotonTargets.All, attackerViewID);
}
public DamageEventArgs(IAttacker dealer, IAttacker target, int value, DamageType type)
{
this.dealer = dealer;
this.target = target;
this.value = value;
this.type = type;
}
public DeathEventArgs(IAttacker target, IAttacker killer, int value, DamageType type)
{
this.target = target;
this.killer = killer;
this.value = value;
this.type = type;
}
public static RollResult GetResultFromRoll(IAttacker attacker, IDefender defender, List <int> rolledFaceIndexAttack, List <int> rolledFaceIndexDefense)
{
var result = new RollResult();
if (attacker != null)
{
var attackerDice = attacker.AttackDice;
for (int i = 0; i < attackerDice.Count; ++i)
{
var face = attackerDice[i].GetFace(rolledFaceIndexAttack[i]);
result.heart += face.heart;
result.surge += face.surge;
result.range += face.range;
result.pierce = attacker.Pierce;
result.bonusRange = attacker.RangeModifier;
if (face.IsMiss)
{
result.miss = true;
}
}
}
if (defender != null)
{
var defenderDice = defender.DefenseDice;
for (int i = 0; i < defenderDice.Count; ++i)
{
result.defense += defenderDice[i].GetDefensePerFace(rolledFaceIndexDefense[i]);
}
}
result.defense = Mathf.Max(0, result.defense);
return(result);
}
public override void Attack(IAttacker attacker, Vector3 direction)
{
if (!IsAvailableToShoot)
{
return;
}
IEnumerable <RaycastHit> allhits = GetAllHits(transform.position, direction);
allhits = allhits.Except(allhits.Where(hit => attacker.Equals(hit.transform.GetComponent <IAttacker>())));
foreach (RaycastHit hit in allhits)
{
IHitable target = hit.collider.gameObject.GetComponent <IHitable>();
if (target != null)
{
HitArgs hitInfo = HitArgs.CreateBuilder().SetDirection(direction).SetAttacker(attacker).SetDamage(this);
target.GetStrike(hitInfo);
}
else
{
HitAnimation(hit.point);
}
}
ShotAnimation();
ShotSound();
lastShot = Time.time;
}
void UpdatePierce(IAttacker attacker)
{
int pierce = attacker != null ? attacker.Pierce : 0;
_textPierce.transform.parent.gameObject.SetActive(pierce > 0);
_textPierce.text = pierce.ToString();
}
void UpdateRangeModifier(IAttacker attacker)
{
int rangeModifier = attacker != null ? attacker.RangeModifier : 0;
_textRangeModifier.transform.parent.gameObject.SetActive(attacker != null && attacker.AttackType == AttackType.Ranged && rangeModifier > 0);
_textRangeModifier.text = "+" + rangeModifier;
}
/// <summary>
/// Eat intersection pixels.
/// </summary>
/// <param name="i_Attacker">The IAttacker.</param>
private void eatPixels(IAttacker i_Attacker)
{
int direction;
Vector2 minVector, maxVector;
getEatMinMaxVectors(i_Attacker.ShapeRectangle, out minVector, out maxVector, out direction);
for (int i = 0; i < maxVector.Y; i++)
{
bool transparentLine = true;
for (int x = (int)minVector.X; x < maxVector.X; x++)
{
int y = (int)minVector.Y + (i * direction);
if ((y < 0) || (y >= m_SelfTexture.Height))
{
i = (int)maxVector.Y + 1;
break;
}
if (!m_transparentMap[x, y])
{
int index = x + (y * m_SelfTexture.Width);
transparentLine = false;
m_transparentMap[x, y] = true;
m_textureColors[index] = sr_transparent;
m_transparentPixels++;
}
}
if (transparentLine)
{
maxVector.Y++;
}
}
}
/// <summary>
/// When the Barrier got attacked, clear the eaten pixels.
/// </summary>
/// <param name="i_Attacker">The IAttacker</param>
protected override void attacked(IAttacker i_Attacker)
{
eatPixels(i_Attacker);
m_SelfTexture.SetData((Color[])m_textureColors.Clone());
updateSoulsForDeath();
base.attacked(i_Attacker);
}
public override void Kill(IAttacker attacker)
{
base.Kill(attacker);
//死亡音
Audio.AudioManager.PlaySE("damage7");
}
private IEnumerator pushback(IAttacker attacker, Controllable victim) {
var vicPos = victim.gameObject.transform.position;
for (var i = 0; i < frames; i++) {
victim.gameObject.transform.position += ((vicPos - attacker.entity ().transform.position).normalized * power/frames);
yield return new WaitForEndOfFrame ();
}
}
/// <summary>
/// ダメージを与える
/// </summary>
/// <param name="attacker"></param>
/// <param name="damage"></param>
public virtual void ApplyDamage(IAttacker attacker, int damage)
{
switch (attacker)
{
case CharacterAttacker cAttacker:
var message = "Unknown";
if (cAttacker.Attacker)
{
message = cAttacker.Attacker.name;
}
Debug.Log($"{message}は{name}に{damage}ダメージ与えた");
break;
default:
Debug.Log($"Unknownは{name}に{damage}ダメージ与えた");
break;
}
TakeDamage(attacker, damage);
}
/// <summary>
/// Apply damage from the attacker to the target
/// </summary>
/// <param name="attacker">The card doing the attacking</param>
/// <param name="target">The object receiving the attack</param>
/// <param name="isRetaliation">Whether or not the attack is a retaliation</param>
public static void ApplyAttackDamage(IAttacker attacker, IDamageableEntity target, bool isRetaliation = false)
{
// If the attacker is a spell card or hero power, you can't retaliate
// If the target is a hero, he can't retaliate
if (target is BaseMinion)
{
var targetMinion = (BaseMinion)target;
targetMinion.TakeDamage(attacker.GetCurrentAttackPower());
if (!isRetaliation && (attacker is BaseMinion || attacker is BaseWeapon))
{
if (attacker is BaseWeapon)
{
var weapon = (BaseWeapon)attacker;
ApplyAttackDamage(targetMinion, weapon.WeaponOwner, isRetaliation: true);
}
else
{
// Then we must be attacking a minion
ApplyAttackDamage(targetMinion, (IDamageableEntity)attacker, isRetaliation: true);
}
}
}
else if (target is BasePlayer)
{
var targetPlayer = (BasePlayer)target;
targetPlayer.TakeDamage(attacker.GetCurrentAttackPower());
}
}
/// <summary>
/// Act for being attacked.
/// </summary>
/// <param name="i_Attacker">Attacker.</param>
protected virtual void attacked(IAttacker i_Attacker)
{
if (i_Attacker.SelfTeam != SelfTeam)
{
SoundManager soundManager = Game.Services.GetService(typeof(SoundManager)) as SoundManager;
soundManager.PlaySoundEffect(m_attackedSound);
ApplyAnimation();
i_Attacker.Destroy(m_score);
Souls--;
if (IsDead)
{
if (!m_AnimationsLibrary.IsOnRun)
{
Visible = false;
}
if (BeenKilled != null)
{
BeenKilled.Invoke();
}
if (m_isFiniteSprite && m_AnimationsLibrary == null)
{
Game.Components.Remove(this);
}
}
}
}
private static float GetHitChanceTo(this IAttacker attacker, IAttackable defender)
{
float defenseRate;
float attackRate;
if (defender is Player && attacker is Player)
{
defenseRate = defender.Attributes[Stats.DefenseRatePvp];
attackRate = attacker.Attributes[Stats.AttackRatePvp];
}
else
{
defenseRate = defender.Attributes[Stats.DefenseRatePvm];
attackRate = attacker.Attributes[Stats.AttackRatePvm];
}
float hitChance = 0.03f;
if (defenseRate < attackRate)
{
hitChance = 1.0f - (defenseRate / attackRate);
}
return(hitChance);
}
public bool IsAttacked(IAttacker attacker)
{
var hasAttacked = false;
if (type == TerrainType.breakableWall)
{
type = TerrainType.land;
hasAttacked = true;
foreach (var cell in Around)
{
if (cell.type != TerrainType.breakableWall)
{
continue;
}
cell.IsAttacked(attacker);
}
}
if (hasAttacked)
{
return(true);
}
if (attacker.ID == 'つ')
{
if (type == TerrainType.wall)
{
type = TerrainType.land;
hasAttacked = true;
}
}
return(hasAttacked);
}
public static void OnAttacking(IAttacker attacker, IDamageableEntity target, bool isRetaliation, out bool shouldAbort)
{
shouldAbort = false;
if (_minionAttackingListeners.Any())
{
// Triggered Effects get called first, then Secrets, then the game engine
var sortedListeners = _minionAttackingListeners.Where(kvp => kvp.Item1.Type != CardType.ACTIVE_SECRET).OrderBy(kvp => kvp.Item1.TimePlayed).ToList();
var secrets = _minionAttackingListeners.Where(kvp => kvp.Item1.Type == CardType.ACTIVE_SECRET).OrderBy(kvp => kvp.Item1.TimePlayed).ToList();
sortedListeners.AddRange(secrets);
foreach (var handler in sortedListeners.Select(kvp => kvp.Item2))
{
handler(attacker, target, isRetaliation, out shouldAbort);
}
}
if (!shouldAbort)
{
GameEngine.ApplyAttackDamage(attacker, target, isRetaliation);
// Time to trigger deathrattles
// If it was a weapon attacking, wait until after the weapon has taken durability hit
if (!(attacker is BaseWeapon))
{
GameEngine.TriggerDeathrattles();
}
}
}
/// <inheritdoc />
public void AfterTargetGotAttacked(IAttacker attacker, IAttackable target, SkillEntry skillEntry, Point targetAreaCenter)
{
if (!target.Alive || !(target is IMovable movableTarget))
{
return;
}
var startingPoint = attacker.Position;
var currentTarget = target.Position;
var direction = startingPoint.GetDirectionTo(currentTarget);
if (direction == Direction.Undefined)
{
direction = (Direction)Rand.NextInt(1, 9);
}
var currentDistance = startingPoint.EuclideanDistanceTo(currentTarget);
while (currentDistance < skillEntry.Skill.Range)
{
var nextTarget = currentTarget.CalculateTargetPoint(direction);
if (!target.CurrentMap.Terrain.WalkMap[nextTarget.X, nextTarget.Y] ||
(target is NonPlayerCharacter && target.CurrentMap.Terrain.SafezoneMap[nextTarget.X, nextTarget.Y]))
{
// we don't want to push the target into a non-reachable area, through walls or monsters into the safe zone.
break;
}
currentTarget = nextTarget;
currentDistance = startingPoint.EuclideanDistanceTo(currentTarget);
}
movableTarget.Move(currentTarget);
}
private void Start()
{
var kuribo = GetComponent <Kuribo>();
var rb = GetComponent <Rigidbody>();
myAttacker = GetComponent <IAttacker>();
kuribo.OnAttackObservable
.Subscribe(t =>
{
Observable.EveryFixedUpdate()
.TakeUntil(Observable.Amb(
Observable.Timer(TimeSpan.FromSeconds(4)).AsUnitObservable(),
OnSuccessfulAttackObservable))
.Subscribe(_ =>
{
moveVector3 = (t.position - transform.position).SetY(0f).normalized *attackMoveSpeed;
rb.velocity = moveVector3.SetY(rb.velocity.y);
}, () =>
{
kuribo.SetEnemyMoveable(false);
Observable.Timer(TimeSpan.FromSeconds(attackInteraval))
.Subscribe(_ => kuribo.SetEnemyMoveable(true));
});
});
this.OnCollisionEnterAsObservable()
.Subscribe(hit => Hit(hit.gameObject));
}
/// <summary>
/// Is called when an <see cref="IAttackable" /> object got killed by another.
/// </summary>
/// <param name="killed">The killed <see cref="IAttackable" />.</param>
/// <param name="killer">The killer.</param>
public void AttackableGotKilled(IAttackable killed, IAttacker killer)
{
if (!(killer is Player player && killed is Monster monster) ||
player.SelectedCharacter?.QuestStates is null)
{
return;
}
foreach (var questState in player.SelectedCharacter.QuestStates)
{
if (questState.ActiveQuest is null)
{
continue;
}
foreach (var killRequirement in questState.ActiveQuest.RequiredMonsterKills.Where(r => r.Monster == monster.Definition))
{
if (questState.RequirementStates.FirstOrDefault(s => s.Requirement == killRequirement)
is not {
} requirementState)
{
requirementState = player.PersistenceContext.CreateNew <QuestMonsterKillRequirementState>();
requirementState.Requirement = killRequirement;
questState.RequirementStates.Add(requirementState);
}
requirementState !.KillCount++;
}
}
}
public virtual bool ReceiveAttack(AttackManager atkMngr)
{
if (atkMngr == null)
{
return(false);
}
OwnerComponent ownerComponent = atkMngr.GetAttackComponent <OwnerComponent>();
List <IAttacker> owners = ownerComponent.owners;
IAttacker thisAttacker = (this as IAttacker);
Entity destroyer = null;
foreach (IAttacker owner in owners)
{
if (owner is Entity e)
{
destroyer = e;
break;
}
}
if (thisAttacker != null && owners.Contains(thisAttacker))
{
return(false);
}
DamageComponent damageComponent = atkMngr.GetAttackComponent <DamageComponent>();
if (damageComponent != null)
{
float damage = damageComponent.DamageIncludingBonuses;
TakeDamage(damage, atkMngr.Position, destroyer, 1f, true);
}
return(true);
}
public BoardController(
IAttacker attacker,
IBoardCreator boardCreator)
{
_attacker = attacker;
_boardCreator = boardCreator;
}
public void Shoot(IAttacker attacker, Vector3 direction)
{
_attacker = attacker;
_direction = direction;
transform.forward = direction;
Destroy(this.gameObject, _lifeTime);
}
public override void attackedBy(IAttacker attacker, dir dir = dir.Still)
{
if (!attacker.Equals(lastAttcker) || lastAttcker == null)
{
base.attackedBy(attacker, dir.left);
lastAttcker = attacker;
}
}
public Player(ICountryClaimer countryClaimer, ITroopReenforcer troopReenforcer, IAttacker attacker, Logger logger, Ledger ledger)
{
_countryClaimer = countryClaimer;
_troopReenforcer = troopReenforcer;
_attacker = attacker;
_logger = logger;
Ledger = ledger;
}
private bool CalculateHit(IAttacker attacker, IDefender target)
{
int armorClass = target.GetArmorClass();
int hitBonus = attacker.GetHitBonus();
int roll = rng.RandiRange(1, 20);
return (roll + hitBonus) >= armorClass;
}
/// <inheritdoc />
public override void RegisterHit(IAttacker attacker)
{
if (this.CurrentTarget is null ||
attacker.IsInRange(this.Npc.Position, this.Npc.Definition.AttackRange))
{
base.RegisterHit(attacker);
}
}
public AttackFlow(IAttacker attacker, IOnAttacked target, int damage, bool isCritical, HitEffectType hitEffectType)
{
Attacker = attacker;
Target = target;
Damage = damage;
IsCritical = isCritical;
HitEffectType = hitEffectType;
}
void Start()
{
swordAttacker = GetComponent<SwordAttacker>(); // Получаем компаненты аттакеров
rangeAttacker = GetComponent<RangeAttacker>();
magicAttacker = GetComponent<MagicAttacker>();
swordAttacker.setActions(actions); // Передаём им контроллер над анимацией
rangeAttacker.setActions(actions);
magicAttacker.setActions(actions);
currentAttacker = swordAttacker; // выбираем атакер по умолчанию
}
protected AttackBehaviour(IAttacker owner)
{
mOwner = owner;
mAttackRange = owner.AttackRange;
mAttackSpeed = owner.AttackSpeed;
mTarget = null;
mIsIMovable = false;
if (owner is IMovable)
{
mMovement = new FreeMovement((IMovable) owner);
mIsIMovable = true;
}
SetLaserType(owner);
}
/// <summary>
/// Устанавливает текущий атакер по типу оружия
/// </summary>
/// <param name="attackerType"></param>
public void setAttacker(WeaponTypes attackerType)
{
// Меняем атакер по умолчанию
currentAttackerType=attackerType;
switch(attackerType){
case WeaponTypes.Sword:
currentAttacker=swordAttacker;
break;
case WeaponTypes.Range:
currentAttacker=rangeAttacker;
break;
case WeaponTypes.Magic:
currentAttacker=magicAttacker;
break;
}
}
private bool InRange(IAttacker attacker, IGameObject target)
{
return (attacker.Position - target.Position).Length() <= attacker.AttackRange;
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
myR = animator.gameObject.GetComponent<Rigidbody2D>();
attacker = Interface.Find<IAttacker>(FindObjectOfType<Player>().gameObject);
}
public override void ApplyEffect (IAttacker attacker, Controllable victim) {
var text = GameObject.Instantiate(Resources.Load<CombatText> ("CombatText"));
text.Text = damage.ToString();
text.transform.position = victim.transform.position + Vector3.up * 1;
victim.AddHealth (-damage);
}
public void OnAttack(IAttacker attacker, float dmg)
{
hp.CurrValue -= dmg;
if (hp.CurrValue <= 0)
{
Destroy();
}
}
public abstract void ApplyEffect (IAttacker attacker, Controllable victim);
public override void ApplyEffect (IAttacker attacker, Controllable victim) {
var text = GameObject.Instantiate(Resources.Load<CombatText> ("CombatText"));
text.Text = "Faster?";
text.transform.position = victim.transform.position + Vector3.up * 1;
victim.ChangeMoveSpeed(1f + pctSpeedChange);
}
protected AttackBehaviour(IAttacker owner, float customAttackSpeed)
: this(owner)
{
mAttackSpeed = customAttackSpeed;
}
public void Initializer(IAttacker attacker, IObservable<bool> attackObservable)
{
this.attacker = attacker;
this.OnShootAsObservable = attackObservable.TakeUntil(this.OnDestroyAsObservable());
}
public AggressiveAi(Character host, float range) : base(host)
{
this.range = range;
attacker = (IAttacker)host;
}
private void AutoAttack(IAttacker attacker)
{
// If the possible auto attacker is idle (not InAction) or in AggressiveMovementMode
if (!(attacker.InAction) || attacker.AggressiveMovementMode)
{
if (attacker is IMinionAttacker)
{
AttackNearbyMinions((IMinionAttacker)attacker);
}
if (attacker is ISpaceshipAttacker)
{
AttackNearbySpaceships((ISpaceshipAttacker)attacker);
}
}
}
public override void ApplyEffect (IAttacker attacker, Controllable victim) {
var text = GameObject.Instantiate(Resources.Load<CombatText> ("CombatText"));
text.Text = "Spin To Win";
text.transform.position = victim.transform.position + Vector3.up * 1;
victim.UpsideDown (-damage);
}
public void RegisterAttacker(IAttacker attacker)
{
this.attacker = attacker;
}
public static void OnAttacking(IAttacker attacker, IDamageableEntity target, bool isRetaliation, out bool shouldAbort)
{
shouldAbort = false;
if (_minionAttackingListeners.Any())
{
// Triggered Effects get called first, then Secrets, then the game engine
var sortedListeners = _minionAttackingListeners.Where(kvp => kvp.Item1.Type != CardType.ACTIVE_SECRET).OrderBy(kvp => kvp.Item1.TimePlayed).ToList();
var secrets = _minionAttackingListeners.Where(kvp => kvp.Item1.Type == CardType.ACTIVE_SECRET).OrderBy(kvp => kvp.Item1.TimePlayed).ToList();
sortedListeners.AddRange(secrets);
foreach (var handler in sortedListeners.Select(kvp => kvp.Item2))
{
handler(attacker, target, isRetaliation, out shouldAbort);
}
}
if (!shouldAbort)
{
GameEngine.ApplyAttackDamage(attacker, target, isRetaliation);
// Time to trigger deathrattles
// If it was a weapon attacking, wait until after the weapon has taken durability hit
if (!(attacker is BaseWeapon))
{
GameEngine.TriggerDeathrattles();
}
}
}
/// <summary>
/// Apply damage from the attacker to the target
/// </summary>
/// <param name="attacker">The card doing the attacking</param>
/// <param name="target">The object receiving the attack</param>
/// <param name="isRetaliation">Whether or not the attack is a retaliation</param>
public static void ApplyAttackDamage(IAttacker attacker, IDamageableEntity target, bool isRetaliation = false)
{
// If the attacker is a spell card or hero power, you can't retaliate
// If the target is a hero, he can't retaliate
if (target is BaseMinion)
{
var targetMinion = (BaseMinion) target;
targetMinion.TakeDamage(attacker.GetCurrentAttackPower());
if (!isRetaliation && (attacker is BaseMinion || attacker is BaseWeapon))
{
if (attacker is BaseWeapon)
{
var weapon = (BaseWeapon) attacker;
ApplyAttackDamage(targetMinion, weapon.WeaponOwner, isRetaliation: true);
}
else
{
// Then we must be attacking a minion
ApplyAttackDamage(targetMinion, (IDamageableEntity)attacker, isRetaliation: true);
}
}
}
else if (target is BasePlayer)
{
var targetPlayer = (BasePlayer) target;
targetPlayer.TakeDamage(attacker.GetCurrentAttackPower());
}
}
public override void ApplyEffect (IAttacker attacker, Controllable victim) {
victim.StartCoroutine(pushback(attacker, victim));
}
private void SetLaserType(IAttacker owner)
{
if (owner is Interceptor) mLaserType = LaserType.Interceptor;
else if (owner is Predator) mLaserType = LaserType.Predator;
else if (owner is Defender) mLaserType = LaserType.Defender;
else if (owner is DeathStar) mLaserType = LaserType.DeathStarLaser;
else mLaserType = LaserType.Interceptor;
}
/// <summary>
/// Damageオブジェクト
/// </summary>
/// <param name="direction">吹っ飛ぶ方向</param>
/// <param name="value">ダメージ値</param>
public Damage(Vector3 direction, float value, IAttacker attacker)
{
HitDirection = direction;
DamageValue = value;
Attacker = attacker;
}
