private void OnHealthChanged(HealthChangedEventArgs eventArgs)
{
if (eventArgs.GameObject.name == "Player" && eventArgs.NewValue == 0)
{
Time.timeScale = 0.0f;
Explode();
AudioManager.Play(PlayerDeath, AudioCategory.Effect, 1.0f);
Collider2D[] colliders = GetComponentsInChildren <Collider2D>();
foreach (Collider2D collider in colliders)
{
collider.enabled = false;
}
SpriteRenderer[] spriteRenderers = GetComponentsInChildren <SpriteRenderer>();
foreach (SpriteRenderer spriteRenderer in spriteRenderers)
{
spriteRenderer.enabled = false;
}
GameObject.Find("Player").GetComponent <PlayerInput>().actions.Disable();
MenuManager.GoInto("MenuDeath");
}
else if (eventArgs.GameObject.name == "Player" && eventArgs.NewValue <= eventArgs.OldValue)
{
_cameraShakeBehaviour.Shake(CameraShakeStrength, CameraShakeDuration);
}
else if (eventArgs.GameObject.name == "Player" && eventArgs.NewValue > eventArgs.OldValue)
{
HealthParticleSystem.Play();
}
}
public void LoseHealth(Player source, int magnitude)
{
if (source.IsDead)
{
return;
}
var args = new HealthChangedEventArgs()
{
Source = null, Delta = -magnitude
};
args.Targets.Add(source);
Emit(GameEvent.BeforeHealthChanged, args);
Trace.Assert(args.Targets.Count == 1);
args.Targets[0].Health += args.Delta;
Trace.TraceInformation("Player {0} lose {1} hp, @ {2} hp", args.Targets[0].Id, -args.Delta, args.Targets[0].Health);
NotificationProxy.NotifyLoseHealth(args.Targets[0], -args.Delta);
GameDelays.Delay(GameDelays.Damage);
try
{
Emit(GameEvent.AfterHealthChanged, args);
}
catch (TriggerResultException)
{
}
}
// private void SpawnGoldNumber()
// {
// GoldNumber gold = Instantiate(GoldNumber, Camera.main.WorldToScreenPoint(transform.position), Quaternion.identity, GameController.GUICanvas.transform).GetComponent<GoldNumber>();
// gold.Number = GoldValue;
// GameController.Instance.AddGold(GoldValue);
// }
public virtual void TookDamage(object sender, HealthChangedEventArgs e)
{
if (e.CausedDeath)
{
// GameController.AddDeath();
// SpawnGoldNumber();
Destroy(healthBarReference.gameObject);
Destroy(gameObject);
}
}
void LoseBuQu(Player player)
{
Game.CurrentGame.HandleCardDiscard(player, Game.CurrentGame.Decks[player, bq]);
var nArgs = new HealthChangedEventArgs()
{
Source = null, Delta = 0
};
nArgs.Targets.Add(player);
Game.CurrentGame.Emit(GameEvent.AfterHealthChanged, nArgs);
}
private void OnDamage(HealthChangedEventArgs eventArgs)
{
int current = eventArgs.Damageable.TotalDamage;
int max = eventArgs.Damageable.Thresholds[DamageState.Dead];
if (eventArgs.Damageable.CurrentState == DamageState.Dead)
{
return;
}
UpdateVisuals(current, max);
}
protected override void ChangeFillAmount(object sender, HealthChangedEventArgs e)
{
float total = e.NewHealth;
for (int i = 0; i < GameController.GUICanvas.GetComponent <GUICanvasLogic>().heartContainer.Hearts.Length; i++)
{
var heart = GameController.GUICanvas.GetComponent <GUICanvasLogic>().heartContainer.Hearts[i];
heart.GetComponent <Image>().fillAmount = total / 2;
total -= 2;
}
hpMngr.SpawnHitNumber();
}
public override void TookDamage(object sender, HealthChangedEventArgs e)
{
if (e.CausedDeath)
{
var dead = Instantiate(deadObject);
dead.transform.position = transform.position;
dead.GetComponent <Rigidbody2D>().velocity = new Vector2(0, 8);
Destroy(dead, 5f);
GameController.AliveEnemies -= 1;
Destroy(healthBarReference.gameObject);
Destroy(gameObject);
}
}
private void OnHealthChanged(HealthChangedEventArgs eventArgs)
{
if (eventArgs.GameObject.name == "Player" && eventArgs.NewValue < eventArgs.OldValue)
{
DamageTaken += eventArgs.OldValue - eventArgs.NewValue;
}
TagBehaviour tagBehaviour = eventArgs.GameObject.GetComponent <TagBehaviour>();
if (tagBehaviour != null && tagBehaviour.HasTag("Enemy") && eventArgs.NewValue < eventArgs.OldValue)
{
DamageDealt += eventArgs.OldValue - eventArgs.NewValue;
if (eventArgs.NewValue <= 0)
{
EnemiesDefeated++;
}
}
}
private void OnHealthChanged(HealthChangedEventArgs eventArgs)
{
TagBehaviour tagBehaviour = eventArgs.GameObject.GetComponent <TagBehaviour>();
bool isEnemy = tagBehaviour != null && tagBehaviour.HasTag("Enemy");
bool isDead = eventArgs.NewValue == 0;
bool isWithinRoom = eventArgs.GameObject.transform.parent == transform;
if (isEnemy && isDead && isWithinRoom)
{
_enemyCount -= 1;
if (_enemyCount <= 0)
{
OnRoomCleared();
EventManager.Unregister(_healthChangedEventId);
}
}
}
private void OnHealthChanged(HealthChangedEventArgs eventArgs)
{
if (eventArgs.GameObject != Target)
{
return;
}
for (int i = 0; i < _targetHealthBehaviour.MaxHealth; i++)
{
if (i < eventArgs.NewValue)
{
_cellAnimators[i].SetBool("Full", true);
}
else
{
_cellAnimators[i].SetBool("Full", false);
}
}
}
public BuQu()
{
_useBuQu = false;
var trigger = new AutoNotifyPassiveSkillTrigger(
this,
(p, e, a) =>
{
HealthChangedEventArgs arg = a as HealthChangedEventArgs;
return(p.Health <= 0 || arg.Delta > 0 && Game.CurrentGame.Decks[p, bq].Count > 0);
},
Run,
TriggerCondition.OwnerIsTarget
)
{
AskForConfirmation = false, IsAutoNotify = false, Type = TriggerType.Skill
};
Triggers.Add(GameEvent.AfterHealthChanged, trigger);
IsAutoInvoked = true;
}
public void RecoverHealth(Player source, Player target, int magnitude)
{
if (target.IsDead)
{
return;
}
if (target.Health >= target.MaxHealth)
{
return;
}
var args = new HealthChangedEventArgs()
{
Source = source, Delta = magnitude
};
args.Targets.Add(target);
Emit(GameEvent.BeforeHealthChanged, args);
Trace.Assert(args.Targets.Count == 1);
if (args.Targets[0].Health + args.Delta > args.Targets[0].MaxHealth)
{
args.Targets[0].Health = args.Targets[0].MaxHealth;
}
else
{
args.Targets[0].Health += args.Delta;
}
Trace.TraceInformation("Player {0} gain {1} hp, @ {2} hp", args.Targets[0].Id, args.Delta, args.Targets[0].Health);
NotificationProxy.NotifyRecoverHealth(args.Targets[0], args.Delta);
try
{
Emit(GameEvent.AfterHealthChanged, args);
}
catch (TriggerResultException)
{
}
}
protected void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
HealthChangedEventArgs arg = eventArgs as HealthChangedEventArgs;
if (arg.Delta > 0)
{
if (Game.CurrentGame.Decks[Owner, bq].Count <= arg.Delta)
{
Game.CurrentGame.HandleCardDiscard(Owner, Game.CurrentGame.Decks[Owner, bq]);
return;
}
else
{
List <List <Card> > answer;
List <DeckPlace> sourceDecks = new List <DeckPlace>()
{
new DeckPlace(Owner, bq)
};
if (!Owner.AskForCardChoice(new CardChoicePrompt("BuQu", Owner),
sourceDecks,
new List <string>()
{
"QiPaiDui"
},
new List <int>()
{
1
},
new RequireCardsChoiceVerifier(arg.Delta),
out answer,
null,
CardChoiceCallback.GenericCardChoiceCallback))
{
answer = new List <List <Card> >();
answer.Add(Game.CurrentGame.PickDefaultCardsFrom(sourceDecks, arg.Delta));
}
Game.CurrentGame.HandleCardDiscard(Owner, answer[0]);
}
if (!_useBuQu)
{
return;
}
List <int> check = new List <int>();
foreach (var c in Game.CurrentGame.Decks[Owner, bq])
{
if (!check.Contains(c.Rank))
{
check.Add(c.Rank);
}
}
if (check.Count == Game.CurrentGame.Decks[Owner, bq].Count && Game.CurrentGame.DyingPlayers.Contains(Owner))
{
Owner[Player.SkipDeathComputation] = 1;
}
return;
}
if (!AskForSkillUse())
{
Owner[Player.SkipDeathComputation] = 0; _useBuQu = false; return;
}
_useBuQu = true;
if (1 - Owner.Health > Game.CurrentGame.Decks[Owner, bq].Count)
{
int toDraw = 1 - Owner.Health - Game.CurrentGame.Decks[Owner, bq].Count;
CardsMovement move = new CardsMovement();
move.To = new DeckPlace(Owner, bq);
move.Helper.PrivateDeckHeroTag = HeroTag;
while (toDraw-- > 0)
{
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
Card c1 = Game.CurrentGame.DrawCard();
move.Cards.Add(c1);
}
Game.CurrentGame.MoveCards(move);
}
if (Owner.Health <= 0)
{
Dictionary <int, bool> death = new Dictionary <int, bool>();
foreach (Card c in Game.CurrentGame.Decks[Owner, bq])
{
if (death.ContainsKey(c.Rank))
{
return;
}
death.Add(c.Rank, true);
}
Owner[Player.SkipDeathComputation] = 1;
NotifySkillUse();
}
}
/// <summary>
/// 造成伤害
/// </summary>
/// <param name="source">伤害来源</param>
/// <param name="dest">伤害目标</param>
/// <param name="originalTarget">最初的伤害目标</param>
/// <param name="magnitude">伤害点数</param>
/// <param name="elemental">伤害属性</param>
/// <param name="cards">造成伤害的牌</param>
public void DoDamage(Player source, Player dest, Player originalTarget, int magnitude, DamageElement elemental, ICard card, ReadOnlyCard readonlyCard)
{
if (dest.IsDead)
{
return;
}
var damageArgs = new DamageEventArgs()
{
Source = source, OriginalTarget = originalTarget, Targets = new List <Player>(), Magnitude = magnitude, Element = elemental
};
HealthChangedEventArgs healthChangedArgs;
int ironShackledDamage = 0;
DamageElement ironShackledDamageElement = DamageElement.None;
if (readonlyCard == null)
{
readonlyCard = new ReadOnlyCard(new Card()
{
Place = new DeckPlace(null, null)
});
}
damageArgs.ReadonlyCard = readonlyCard;
if (card is CompositeCard)
{
if ((card as CompositeCard).Subcards != null)
{
damageArgs.Cards = new List <Card>((card as CompositeCard).Subcards);
}
}
else if (card is Card)
{
damageArgs.Cards = new List <Card>()
{
card as Card
};
}
else
{
damageArgs.Cards = new List <Card>();
}
damageArgs.Targets.Add(dest);
damageArgs.Card = card;
try
{
//伤害来源与基数、属性的确定发生在伤害结算前，连环，以及转移的伤害不会重新确定来源与基数，所以不会多次触发【裸衣】，以及【酒】
while (damageArgs.ReadonlyCard[SourceAndElementIsConfirmed] == 0)
{
Emit(GameEvent.DamageSourceConfirmed, damageArgs);
Emit(GameEvent.DamageElementConfirmed, damageArgs);
damageArgs.ReadonlyCard[SourceAndElementIsConfirmed] = 1;
break;
}
Emit(GameEvent.BeforeDamageComputing, damageArgs);
Emit(GameEvent.DamageComputingStarted, damageArgs);
Emit(GameEvent.DamageCaused, damageArgs);
Emit(GameEvent.DamageInflicted, damageArgs);
if (damageArgs.Magnitude == 0)
{
Trace.TraceInformation("Damage is 0, aborting");
return;
}
if (damageArgs.Targets[0].IsIronShackled && damageArgs.Element != DamageElement.None)
{
ironShackledDamage = damageArgs.Magnitude;
Trace.TraceInformation("IronShackled damage {0}", ironShackledDamage);
ironShackledDamageElement = damageArgs.Element;
damageArgs.Targets[0].IsIronShackled = false;
// if this is TieSuo damage already, prevent itself from spreading...
if (readonlyCard[IsIronShackleDamage] == 1)
{
ironShackledDamage = 0;
}
}
healthChangedArgs = new HealthChangedEventArgs(damageArgs);
Emit(GameEvent.BeforeHealthChanged, healthChangedArgs);
damageArgs.Magnitude = -healthChangedArgs.Delta;
}
catch (TriggerResultException e)
{
if (e.Status == TriggerResult.End)
{
//伤害结算完毕事件应该总是被触发
//受到伤害的角色如果存活能发动的技能/会执行的技能效果：【酒诗②】、执行【天香】摸牌的效果。
Emit(GameEvent.DamageComputingFinished, damageArgs);
Trace.TraceInformation("Damage Aborted");
return;
}
Trace.Assert(false);
return;
}
Trace.Assert(damageArgs.Targets.Count == 1);
damageArgs.Targets[0].Health -= damageArgs.Magnitude;
Trace.TraceInformation("Player {0} Lose {1} hp, @ {2} hp", damageArgs.Targets[0].Id, damageArgs.Magnitude, damageArgs.Targets[0].Health);
NotificationProxy.NotifyDamage(damageArgs.Source, damageArgs.Targets[0], damageArgs.Magnitude, damageArgs.Element);
GameDelays.Delay(GameDelays.Damage);
try
{
Emit(GameEvent.AfterHealthChanged, healthChangedArgs);
}
catch (TriggerResultException)
{
}
Emit(GameEvent.AfterDamageCaused, damageArgs);
Emit(GameEvent.AfterDamageInflicted, damageArgs);
Emit(GameEvent.DamageComputingFinished, damageArgs);
if (ironShackledDamage != 0)
{
List <Player> toProcess = new List <Player>(AlivePlayers);
SortByOrderOfComputation(CurrentPlayer, toProcess);
foreach (Player p in toProcess)
{
if (p.IsIronShackled)
{
readonlyCard[IsIronShackleDamage] = 1;
DoDamage(damageArgs.Source, p, originalTarget, ironShackledDamage, ironShackledDamageElement, card, readonlyCard);
}
}
}
}
private void view_HealthUpdated(object sender, HealthChangedEventArgs e)
{
playerModel.Health += e.difference;
}
