public void TestPushback()
{
Setup.EnsureMinimalSetup();
SpellHandler.LoadSpells();
var npc = Setup.NPCPool.CreateDummy();
npc.EnsureInWorldAndLiving();
var spell = SpellHandler.Get(SpellId.ClassSkillPrayerOfHealingRank1);
Assert.IsNotNull(spell);
Asser.GreaterThan(spell.CastDelay, 0u);
npc.Map.AddMessageAndWait(new Message(() => {
var cast = npc.SpellCast;
var err = cast.Start(spell, false, npc);
Assert.AreEqual(err, SpellFailedReason.Ok);
Assert.IsTrue(npc.IsUsingSpell);
var timeleft = cast.RemainingCastTime;
cast.RemainingCastTime -= 2000;
Asser.Approx(timeleft - 2000, 40, cast.RemainingCastTime);
timeleft = cast.RemainingCastTime;
cast.Pushback();
Asser.Approx(timeleft + 1000, 40, cast.RemainingCastTime);
timeleft = cast.RemainingCastTime;
cast.Pushback();
Asser.Approx(timeleft + 800, 40, cast.RemainingCastTime);
}));
}
public void TestInstantDamageSpell()
{
var spell = SpellHandler.Get(SpellId.ClassSkillFireBlastRank1);
Assert.AreEqual(0, spell.ProjectileSpeed); // not delayed
chr.EnsureInWorld();
var enemy = chr.Enemies.Create();
enemy.Regenerates = false;
var oldHealth = enemy.Health;
Asser.GreaterThan(enemy.Health, 0);
// make sure we are in range and facing the enemy
enemy.EnsureXDistance(chr, spell.Range.MinDist + 0.5f, true);
chr.EnsureFacing(enemy);
// triggered spells are instant and cannot miss
chr.Map.AddMessageAndWait(() => {
var failReason = chr.SpellCast.Start(spell, true, enemy);
Assert.AreEqual(SpellFailedReason.Ok, failReason);
Assert.IsFalse(chr.SpellCast.IsCasting);
Asser.GreaterThan(oldHealth, enemy.Health);
});
}
public static Group CreateGroup(int count)
{
var pool = Setup.AllianceCharacterPool;
pool.EnsureLiving = true;
var members = new TestCharacter[count];
var leader = members[0] = pool.Create();
Asser.GreaterThan(count, 1);
// invite
leader.EnsureInWorldAndLiving();
for (uint i = 1; i < count; i++)
{
members[i] = pool.Create();
members[i].EnsureInWorldAndLiving();
Invite(leader, members[i]);
}
// accept
for (uint i = 1; i < count; i++)
{
Accept(leader, members[i]);
Assert.AreEqual(members[i].GroupMember, members[i - 1].GroupMember.Next);
}
var group = leader.Group;
Assert.AreEqual(count, group.CharacterCount);
return(group);
}
public void TestPetLearnTalent()
{
TestPetResetTalents();
var points = Cat.FreeTalentPoints;
SendLearnTalentPacket(TalentId.PetTalentsFerocityCobraReflexes, 1);
Assert.IsTrue(Cat.Talents.HasTalent(TalentId.PetTalentsFerocityCobraReflexes));
Asser.GreaterThan(points, Cat.FreeTalentPoints);
}
public void TestBeastMasteryEffects()
{
Master.Level = 50;
Cat.Level = 50;
Master.Talents.LearnAll();
TestMakePet();
var basePoints = PetMgr.GetPetTalentPointsByLevel(Cat.Level);
Cat.FreeTalentPoints = basePoints;
Asser.GreaterThan(Cat.FreeTalentPoints, basePoints);
}
public void TestInitialReputations()
{
Setup.EnsureDBSetup();
FactionMgr.Initialize();
var stormWind = FactionMgr.Get(FactionId.Stormwind);
var bootyBay = FactionMgr.Get(FactionId.BootyBay);
Assert.IsNotNull(bootyBay);
var reputation = new Reputation(new ReputationRecord(), bootyBay, 1000, ReputationFlags.None);
Asser.FlatNotSet(reputation.Flags, ReputationFlags.AtWar);
}
public TestCharacter(TestAccount acc, CharacterRecord record, Archetype archetype, bool isNew)
{
Create(acc, PrepareRecord(acc, record, archetype, isNew), CreateClient(acc));
record.ExploredZones = new byte[UpdateFieldMgr.ExplorationZoneFieldSize * 4];
acc.Characters.Add(record);
acc.Character = this;
BaseHealth = 1000;
Health = 1000;
Assert.AreEqual(1000, BaseHealth);
Asser.GreaterOrEqual(MaxHealth, BaseHealth);
Assert.AreEqual(1000, Health);
Assert.IsFalse(string.IsNullOrEmpty(Name));
SpecProfiles = new[] { WCell.RealmServer.Talents.SpecProfile.NewSpecProfile(this, 0) };
}
public static Guild CreateGuild(int count)
{
var pool = Setup.AllianceCharacterPool;
pool.EnsureLiving = true;
Asser.GreaterThan(count, 1);
// create
leader.EnsureInWorldAndLiving();
leader.EnsureNoGuild();
new Guild(leader.Record, "TestGuild " + Utility.Random(1, 1000));
var guild = leader.Guild;
Assert.IsNotNull(guild);
// invite
var members = new TestCharacter[count - 1];
for (uint i = 1; i < count; i++)
{
var member = members[i - 1] = pool.Create();
member.EnsureInWorldAndLiving();
member.EnsureNoGuild();
Invite(leader, member);
}
// accept
for (uint i = 1; i < count; i++)
{
var member = members[i - 1];
Accept(leader, member);
var character = member;
var guildMember = guild[character.Name];
Assert.IsNotNull(guildMember);
}
Assert.AreEqual(count, guild.MemberCount);
return(guild);
}
public void TestFeedPet()
{
TestMakePet();
Cat.Power = 100;
Cat.Level = 10;
Cat.Entry.FamilyId = CreatureFamilyId.Cat;
// Add some meat to the Master's inventory
var amount = 5;
var invErr = Master.Inventory.TryAdd(ItemId.KodoMeat, ref amount, InventorySlot.BackPack5);
Assert.IsTrue(invErr == InventoryError.OK);
var meat = Master.Inventory.GetItemByItemId(ItemId.KodoMeat, false);
Assert.IsNotNull(meat);
var spell = SpellHandler.Get(SpellId.ClassSkillFeedPet);
var preHappiness = Cat.Power;
Master.Map.AddMessageAndWait(new Message(() => {
var cast = Master.SpellCast;
cast.TargetItem = meat;
var err = cast.Start(spell, false);
Assert.AreEqual(SpellFailedReason.Ok, err);
Assert.IsTrue(Cat.Auras.Count > 0);
var aura = Cat.Auras[AuraType.PeriodicEnergize];
var handler = aura.GetHandler(AuraType.PeriodicEnergize);
Assert.IsNotNull(aura);
Assert.IsNotNull(handler);
Assert.IsTrue(handler.EffectValue > 0);
}));
var milis = (int)spell.Effects[0].TriggerSpell.Effects[0].Amplitude;
Cat.CallDelayed(milis, (obj) => Asser.GreaterThan(Cat.Power, preHappiness));
}
public static void ApplyAura(TestCharacter chr, Spell spell)
{
Assert.IsTrue(spell.IsAura || spell.IsAreaAura, "Spell {0} is not an Aura", spell);
chr.EnsureInWorld();
chr.ShapeshiftForm = ShapeshiftForm.Normal;
chr.Auras.Clear();
Assert.AreEqual(0, chr.Auras.Count);
// important: Execute this in the Map's thread
chr.Map.AddMessageAndWait(new Message(() => {
chr.SpellCast.TriggerSelf(spell);
var failure =
chr.FakeClient.DequeueSMSG(RealmServerOpCode.SMSG_SPELL_FAILURE);
Assert.IsNull(failure,
failure != null
? "Spell failed: " + failure["FailReason"].Value
: "");
Assert.AreEqual(1, chr.Auras.Count, "Aura was not added.");
var aura = chr.Auras[spell, !spell.HasHarmfulEffects];
Assert.IsNotNull(aura);
Assert.AreEqual(spell.GetDuration(chr.SharedReference, chr), (uint)aura.Duration);
Assert.AreNotEqual(0, spell.GetDuration(chr.SharedReference, chr));
Asser.GreaterOrEqual(spell.GetDuration(chr.SharedReference, chr), (uint)aura.TimeLeft);
aura.Cancel();
Assert.IsNull(chr.Auras[spell, !spell.HasHarmfulEffects]);
Assert.AreEqual(0, chr.Auras.Count);
}));
}
public void TestDuel()
{
Setup.EnsureBasicSetup();
var chr1 = Setup.AllianceCharacterPool.Create();
chr1.EnsureAloneInWorldAndLiving();
var chr2 = Setup.AllianceCharacterPool.Create();
chr2.EnsureInWorldAndLiving();
chr2.EnsureXDistance(chr1, 2, true);
Assert.IsNotNull(chr1.Map);
Assert.AreEqual(chr1.Map, chr2.Map);
Assert.AreEqual(2, chr1.Map.CharacterCount);
chr1.Map.ForceUpdateCharacters();
Assert.IsTrue(chr1.KnowsOf(chr2));
Assert.IsFalse(chr1.CanHarm(chr2));
Assert.IsFalse(chr2.CanHarm(chr1));
GOMgr.LoadAll();
// chr1 requests a duel with chr2
using (var packet = new RealmPacketOut(RealmServerOpCode.CMSG_CAST_SPELL))
{
packet.Write((byte)1);
packet.Write((uint)SpellId.NotDisplayedDuel);
packet.Write((byte)0);
packet.Write((uint)SpellTargetFlags.Unit);
chr2.EntityId.WritePacked(packet);
chr1.FakeClient.ReceiveCMSG(packet, false, true);
}
chr1.Map.WaitTicks(3);
Assert.IsFalse(chr1.IsUsingSpell, "Character is still casting Duel Spell.");
var spellFailure = chr1.FakeClient.DequeueSMSG(RealmServerOpCode.SMSG_SPELL_FAILURE);
Assert.IsNull(spellFailure, "Could not start duel - {0} ({1})",
spellFailure != null ? spellFailure["Spell"] : null,
spellFailure != null ? spellFailure["FailReason"] : null);
// server sent duel request to opposing party
var request = chr2.FakeClient.DequeueSMSG(RealmServerOpCode.SMSG_DUEL_REQUESTED);
Assert.IsNotNull(request);
request = chr1.FakeClient.DequeueSMSG(RealmServerOpCode.SMSG_DUEL_REQUESTED);
Assert.IsNotNull(request);
var duel = chr1.Duel;
Assert.IsNotNull(duel);
Assert.AreEqual(duel, chr2.Duel);
Assert.AreEqual(chr1.DuelOpponent, chr2);
Assert.AreEqual(chr2.DuelOpponent, chr1);
var flag = duel.Flag;
Assert.IsNotNull(flag);
Assert.AreEqual(chr1.Map, duel.Flag.Map);
var map = chr1.Map;
Assert.IsFalse(duel.IsActive);
Assert.AreEqual(duel.Flag.EntityId, request["FlagId"].Value);
Assert.AreEqual(chr1.EntityId, request["ChallengerId"].Value);
// opponent accepts duel
using (var packet = new RealmPacketOut(RealmServerOpCode.CMSG_DUEL_ACCEPTED))
{
chr2.FakeClient.ReceiveCMSG(packet, false, true);
}
Assert.IsFalse(duel.IsActive);
if (Duel.DefaultStartDelayMillis > 0)
{
Asser.InBetween(0.001f, Duel.DefaultStartDelayMillis, duel.StartDelay);
// lets speed it up
duel.StartDelay = 1;
}
map.WaitTicks(2);
// duel started
Assert.IsTrue(duel.IsActive);
Assert.IsTrue(chr1.CanHarm(chr2));
Assert.IsTrue(chr2.CanHarm(chr1));
map.AddMessage(() => {
// finish duel by having chr1 knockout chr2
duel.Finish(DuelWin.Knockout, chr2);
var winMsg = chr2.FakeClient.DequeueSMSG(RealmServerOpCode.SMSG_DUEL_WINNER);
Assert.AreEqual(DuelWin.Knockout, winMsg["Win"].Value);
Assert.AreEqual(chr1.Name, winMsg["Winner"].Value);
Assert.AreEqual(chr2.Name, winMsg["Looser"].Value);
// duel ended
Assert.IsNull(flag.Map);
Assert.IsNull(chr1.DuelOpponent);
Assert.IsNull(chr1.Duel);
Assert.IsNull(chr2.DuelOpponent);
Assert.IsNull(chr2.Duel);
Assert.IsFalse(chr1.CanHarm(chr2));
Assert.IsFalse(chr2.CanHarm(chr1));
});
}
