private void _onFighterKilled(object sender, KilledEventArgs e)
{
if (IsTeamDefeated())
{
OnTeamDefeated(new TeamDefeatedEventArgs(this));
}
}
void PlayerEntity_Killed(object sender, KilledEventArgs e)
{
var dieMenu = new DieMenu((Player)sender);
AddChild(dieMenu);
dieMenu.Centre();
}
public void OnKilledMethod_AppropriatelyFiresKilledEvent()
{
_fighter.OnKilled(new KilledEventArgs());
var logs = _logger.Logs;
Assert.AreEqual(1, logs.Count);
Assert.AreEqual(EventType.Killed, logs[0].Type);
Assert.AreEqual(_fighter, logs[0].Sender);
KilledEventArgs e = logs[0].E as KilledEventArgs;
Assert.That(e, Is.Not.Null);
}
protected void PrintKilledMessage(object sender, KilledEventArgs e)
{
if (Config.ShowDeathMessages)
{
IFighter senderAsFighter = sender as IFighter;
if (senderAsFighter == null)
{
throw new InvalidOperationException("PrintKilledMessage subscribed to something that wasn't an IFighter");
}
_output.WriteLine($"{senderAsFighter.DisplayName} has been defeated!");
}
}
internal void HandleKilled(ServerPlayer player, MsgKilled msgKilled)
{
if (msgKilled == null || player == null)
{
return;
}
KilledEventArgs args = new KilledEventArgs();
msgKilled.VictimID = player.PlayerID;
args.Victim = player;
args.Killer = GetPlayerByID(msgKilled.KillerID);
args.Shot = Shots.FindKillableShot(msgKilled.KillerID, msgKilled.ShotID);
args.KillInfo = msgKilled;
KillPlayer(player, args);
}
private void OnShadeDeath(object sender, KilledEventArgs e)
{
Shade senderAsShade = sender as Shade;
if (senderAsShade == null)
{
throw new InvalidOperationException("ShadeFighterGrouping.OnShadeDeath should only subscribe to a Shade fighters' Killed event!");
}
List <Shade> stillAliveShades = _shades.FindAll(s => s.IsAlive());
int numberOfShadesStillAlive = stillAliveShades.Count;
if (numberOfShadesStillAlive > 0)
{
int chosenShadeIndex = _chanceService.WhichEventOccurs(numberOfShadesStillAlive);
stillAliveShades[chosenShadeIndex].AbsorbShade(senderAsShade);
}
}
public void AttackMethod_AppropriatelyRaisesEvents_WhenEnemyDies()
{
_fighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "Ted");
_logger.SubscribeAll(_fighter);
_fighter.SetStrength(_enemy.MaxHealth + 1);
_fighter.Attack(_enemy);
var logs = _logger.Logs;
Assert.AreEqual(4, logs.Count);
//first event, damage taken
Assert.AreEqual(EventType.DamageTaken, logs[0].Type);
Assert.AreEqual(_enemy, logs[0].Sender);
PhysicalDamageTakenEventArgs e1 = logs[0].E as PhysicalDamageTakenEventArgs;
Assert.NotNull(e1);
Assert.AreEqual(_fighter.Strength, e1.Damage);
//second event, killed - fired by enemy
Assert.AreEqual(EventType.Killed, logs[1].Type);
Assert.AreEqual(_enemy, logs[1].Sender);
KilledEventArgs e2 = logs[1].E as KilledEventArgs;
Assert.That(e2, Is.Not.Null);
//third event, damageDealt to enemy
Assert.AreEqual(EventType.AttackSuccessful, logs[2].Type);
Assert.AreEqual(_fighter, logs[2].Sender);
AttackSuccessfulEventArgs e3 = logs[2].E as AttackSuccessfulEventArgs;
Assert.NotNull(e3);
Assert.AreEqual(_enemy.MaxHealth, e3.DamageDealt);
//fourth event, killed enemy
Assert.AreEqual(EventType.EnemyKilled, logs[3].Type);
Assert.AreEqual(_fighter, logs[3].Sender);
EnemyKilledEventArgs e4 = logs[3].E as EnemyKilledEventArgs;
Assert.NotNull(e4);
Assert.AreEqual(_enemy, e4.Enemy);
}
public void HandleKilled(NetworkMessage msg)
{
MsgKilled killed = msg as MsgKilled;
KilledEventArgs args = new KilledEventArgs();
args.Victim = GetPlayerByID(killed.VictimID);
args.Killer = GetPlayerByID(killed.KillerID);
args.Reason = killed.Reason;
args.KilledByFlag = FlagTypeList.GetFromAbriv(killed.FlagAbreviation);
if (killed.Reason == BlowedUpReasons.DeathTouch)
{
args.InstrumentID = killed.PhysicsDriverID;
}
else
{
args.InstrumentID = killed.ShotID;
if (killed.ShotID > 0)
{
// kill shot
int bzfsShotID = (killed.KillerID * byte.MaxValue) + killed.ShotID;
// tell the shot manager to kill that thar shot
}
}
if (args.Victim != null)
{
args.Victim.SetTeleport(-1, null, null);
args.Victim.Active = false;
args.Victim.IsRabbit = false;
}
if (PlayerKilled != null)
{
PlayerKilled.Invoke(this, args);
}
}
private void _logKilled(object sender, KilledEventArgs e)
{
Logs.Add(new EventLog(EventType.Killed, sender, e));
}
private void OnEggKilled(object sender, KilledEventArgs e)
{
var egg = sender as Egg;
_eggs.Remove(egg);
}
private void _setReviveCounter(object sender, KilledEventArgs e)
{
ReviveCounter = ChanceService.WhichEventOccurs(3) + 2;
}
public void CastMethod_AppropriatelyRaisesEvents([Values(false, true)] bool enemyDies)
{
var spellDamage = _fireballSpell.Power + _human.MagicStrength;
int enemyHealth = spellDamage + (enemyDies ? 0 : 1);
_enemy.SetHealth(enemyHealth);
_human.SetDeathOnTurnEndEvent();
_human.AddSpell(_fireballSpell);
_human.SetMana(_fireballSpell.Cost);
_human.SetMove(_fireballSpell);
_human.SetMoveTarget(_enemy);
_logger.Subscribe(EventType.ManaLost, _human);
_logger.Subscribe(EventType.SpellSuccessful, _human);
_logger.Subscribe(EventType.EnemyKilled, _human);
_logger.Subscribe(EventType.MagicalDamageTaken, _enemy);
_logger.Subscribe(EventType.Killed, _enemy);
_battleManager.Battle(_humanTeam, _enemyTeam);
var logs = _logger.Logs;
int expectedLogCount = enemyDies ? 5 : 3;
Assert.AreEqual(expectedLogCount, logs.Count);
int i = 0;
//first event, mana spent
EventLog log = logs[i++];
Assert.AreEqual(EventType.ManaLost, log.Type);
Assert.AreEqual(_human, log.Sender);
ManaLostEventArgs e1 = log.E as ManaLostEventArgs;
Assert.That(e1, Is.Not.Null);
if (e1 != null)
{
Assert.AreEqual(_fireballSpell.Cost, e1.ManaSpent);
}
//second event, magical damage taken
log = logs[i++];
Assert.AreEqual(EventType.MagicalDamageTaken, log.Type);
Assert.AreEqual(_enemy, log.Sender);
MagicalDamageTakenEventArgs e2 = log.E as MagicalDamageTakenEventArgs;
Assert.That(e2, Is.Not.Null);
if (e2 != null)
{
Assert.AreEqual(spellDamage, e2.Damage);
Assert.AreEqual(_fireballSpell.ElementalType, e2.MagicType);
}
//killed event sent by enemy, potentially
if (enemyDies)
{
log = logs[i++];
Assert.AreEqual(EventType.Killed, log.Type);
Assert.AreEqual(_enemy, log.Sender);
KilledEventArgs e3 = log.E as KilledEventArgs;
Assert.That(e3, Is.Not.Null);
}
//Spell successful
log = logs[i++];
Assert.AreEqual(EventType.SpellSuccessful, log.Type);
Assert.AreEqual(_human, log.Sender);
SpellSuccessfulEventArgs e4 = log.E as SpellSuccessfulEventArgs;
Assert.That(e4, Is.Not.Null);
if (e4 != null)
{
Assert.AreEqual(_fireballSpell, e4.Spell);
Assert.AreEqual(spellDamage, e4.DamageDealt);
Assert.AreEqual(_enemy, e4.TargettedFoe);
}
//enemy killed, potentially
if (enemyDies)
{
log = logs[i];
Assert.AreEqual(EventType.EnemyKilled, log.Type);
Assert.AreEqual(_human, log.Sender);
EnemyKilledEventArgs e5 = log.E as EnemyKilledEventArgs;
Assert.That(e5, Is.Not.Null);
if (e5 != null)
{
Assert.AreEqual(_enemy, e5.Enemy);
}
}
}
public void KillPlayer(ServerPlayer player, KilledEventArgs args)
{
if (args == null || player == null)
{
return;
}
if (!player.Info.Alive)
{
Logger.Log0("Player " + player.Callsign + " killed while dead");
}
player.Info.Alive = false;
PlayerKilled?.Invoke(this, args);
Logger.Log4("Player " + player.Callsign + " killed by " + args.KillInfo.Reason.ToString());
bool wasFromAFlag = false;
switch (args.KillInfo.Reason)
{
case BlowedUpReasons.GotKilledMsg:
break;
case BlowedUpReasons.GotShot:
wasFromAFlag = true;
Shots.RemoveShotForDeath(player, args.KillInfo.KillerID, args.KillInfo.ShotID);
if (args.Shot != null) // tell the flag it took a hit
{
Flags.HandlePlayerTakeHit(player, args.Killer, args.Shot);
}
break;
case BlowedUpReasons.GotRunOver:
wasFromAFlag = true;
break;
case BlowedUpReasons.GotCaptured:
break;
case BlowedUpReasons.GenocideEffect:
break;
case BlowedUpReasons.SelfDestruct:
break;
case BlowedUpReasons.WaterDeath:
break;
case BlowedUpReasons.DeathTouch:
break;
case BlowedUpReasons.LastReason:
case BlowedUpReasons.Unknown:
Logger.Log0("Player " + player.Callsign + " killed by a method that should not happen");
break;
}
if (wasFromAFlag) // tell the flag it killed
{
Flags.HandlePlayerDoDamage(player, args.Killer, FlagTypeList.GetFromAbriv(args.KillInfo.FlagAbreviation));
}
// process any scores
PlayerInfo.ScoreInfo vicScores = new PlayerInfo.ScoreInfo();
PlayerInfo.ScoreInfo killerScores = new PlayerInfo.ScoreInfo();
if (ComputeScores(args.Victim, ref vicScores, args.Killer, ref killerScores, args.KillInfo.Reason))
{
args.Victim.Info.Score.ApplyScore(vicScores);
if (args.Killer != null)
{
args.Killer.Info.Score.ApplyScore(killerScores);
}
MsgScore scoreMessage = new MsgScore();
if (!vicScores.Empty)
{
Logger.Log3("Player " + player.Callsign + " score updated by " + vicScores.ToString());
ScoreUpdated?.Invoke(this, args.Victim);
args.Victim.Info.Score.Pack(args.Victim.PlayerID, scoreMessage);
}
if (args.Killer != null && !killerScores.Empty)
{
Logger.Log3("Player " + player.Callsign + " score updated by " + killerScores.ToString());
ScoreUpdated?.Invoke(this, args.Killer);
args.Killer.Info.Score.Pack(args.Killer.PlayerID, scoreMessage);
}
if (scoreMessage.Scores.Count > 0)
{
SendToAll(scoreMessage, false);
}
}
MsgKilled killedMessage = new MsgKilled();
killedMessage.VictimID = args.Victim.PlayerID;
killedMessage.KillerID = args.Killer != null ? args.Killer.PlayerID : PlayerConstants.ServerPlayerID;
killedMessage.ShotID = args.Shot != null ? args.Shot.PlayerShotID : -1;
killedMessage.Reason = args.KillInfo.Reason;
killedMessage.FlagAbreviation = (args.Shot != null && args.Shot.SourceFlag != null) ? args.Shot.SourceFlag.FlagAbbv : string.Empty;
killedMessage.PhysicsDriverID = args.KillInfo.PhysicsDriverID;
SendToAll(killedMessage, false);
}
public void TestPrintKilledMessage(object sender, KilledEventArgs e)
{
PrintKilledMessage(sender, e);
}
private void RemoveFromTeamOnDeath(object sender, KilledEventArgs e)
{
Team.Remove(this);
}
public void OnKilled(KilledEventArgs e)
{
Killed?.Invoke(this, e);
}
