private static void WriteUnitDynFlags(ObjectBase obj, Character receiver, UpdatePacket packet)
{
Unit unit = (Unit)obj;
UnitDynamicFlags dynamicFlags = unit.DynamicFlags;
Asda2Loot loot = obj.Loot;
if (loot != null && receiver.LooterEntry.MayLoot(loot) && !unit.IsAlive)
{
dynamicFlags |= UnitDynamicFlags.Lootable;
}
else
{
Unit firstAttacker = unit.FirstAttacker;
if (firstAttacker != null)
{
if ((firstAttacker == receiver || firstAttacker.IsAlliedWith(receiver)) &&
unit.IsAlive)
{
dynamicFlags |= UnitDynamicFlags.TaggedByMe;
}
else
{
dynamicFlags |= UnitDynamicFlags.TaggedByOther;
}
}
}
packet.Write((uint)dynamicFlags);
}
private static void WriteUnitDynFlags(ObjectBase obj, Character receiver, UpdatePacket packet)
{
var unit = (Unit)obj;
//var flags = UnitDynamicFlags.None;
var flags = unit.DynamicFlags;
var loot = obj.Loot;
if (loot != null && receiver.LooterEntry.MayLoot(loot) && !unit.IsAlive)
{
flags |= UnitDynamicFlags.Lootable;
}
else
{
var firstAttacker = unit.FirstAttacker;
if (firstAttacker != null)
{
if ((firstAttacker == receiver ||
firstAttacker.IsAlliedWith(receiver)) &&
unit.IsAlive)
{
flags |= UnitDynamicFlags.TaggedByMe;
}
else
{
flags |= UnitDynamicFlags.TaggedByOther;
}
}
}
// TODO: TrackUnit, SpecialInfo
packet.Write((uint)flags);
}
private static void WriteCorpseDynFlags(ObjectBase obj, Character receiver, UpdatePacket packet)
{
if (((Corpse)obj).Owner == receiver)
{
packet.Write(1U);
}
else
{
packet.Write(0U);
}
}
private static void WriteCorpseDynFlags(ObjectBase obj, Character receiver, UpdatePacket packet)
{
if (((Corpse)obj).Owner == receiver)
{
packet.Write((uint)CorpseDynamicFlags.PlayerLootable);
}
else
{
packet.Write((uint)CorpseDynamicFlags.None);
}
}
private static void WriteAuraStateFlags(ObjectBase obj, Character reciever, UpdatePacket packet)
{
Unit unit = (Unit)obj;
Spell strongestImmolate = unit.GetStrongestImmolate();
if (strongestImmolate != null && unit.Auras[strongestImmolate].SpellCast.CasterChar == reciever)
{
packet.Write((uint)(unit.AuraState | AuraStateMask.Immolate));
}
else
{
packet.Write((uint)(unit.AuraState & ~AuraStateMask.Immolate));
}
}
private static void WriteAuraStateFlags(ObjectBase obj, Character reciever, UpdatePacket packet)
{
var unit = (Unit)obj;
Spell immolateAura = unit.GetStrongestImmolate();
//if there is a immolate aura on this object and the reciver casted it we can send that aurastate to him
if (immolateAura != null && unit.Auras[immolateAura].SpellCast.CasterChar == reciever)
{
packet.Write((uint)(unit.AuraState | AuraStateMask.Immolate));
}
else
{
packet.Write((uint)(unit.AuraState & ~AuraStateMask.Immolate));
}
}
private static void WriteNPCFlags(ObjectBase obj, Character chr, UpdatePacket packet)
{
var flags = (NPCFlags)obj.GetUInt32(UnitFields.NPC_FLAGS);
if (obj is NPC)
{
var npc = (NPC)obj;
if (npc.IsTrainer && !npc.TrainerEntry.CanTrain(chr))
{
// Cannot talk to this Guy
flags = 0;
}
}
packet.Write((uint)flags);
}
private static void WriteNPCFlags(ObjectBase obj, Character chr, UpdatePacket packet)
{
NPCFlags npcFlags = (NPCFlags)obj.GetUInt32(UnitFields.NPC_FLAGS);
if (obj is NPC)
{
NPC npc = (NPC)obj;
if (npc.IsTrainer && !npc.TrainerEntry.CanTrain(chr))
{
npcFlags = NPCFlags.None;
}
}
packet.Write((uint)npcFlags);
}
private static void WriteGODynamic(ObjectBase obj, Character receiver, UpdatePacket packet)
{
GameObject gameObject = (GameObject)obj;
if (gameObject is Transport || !gameObject.Flags.HasAnyFlag(GameObjectFlags.ConditionalInteraction))
{
packet.Write(obj.GetUInt32(GameObjectFields.DYNAMIC));
}
else
{
GODynamicLowFlags goDynamicLowFlags = !gameObject.CanBeUsedBy(receiver)
? GODynamicLowFlags.None
: GODynamicLowFlags.Clickable | GODynamicLowFlags.Sparkle;
packet.Write((ushort)goDynamicLowFlags);
packet.Write(ushort.MaxValue);
}
}
protected void WriteSpontaneousUpdate(UpdateMask mask, UpdatePacket packet, Character receiver, UpdateFieldId[] indices, bool visible)
{
// create mask
for (var i = 0; i < indices.Length; i++)
{
var index = indices[i].RawId;
var field = UpdateFieldMgr.Get(ObjectTypeId).Fields[index];
for (var j = 0; j < field.Size; j++)
{
mask.SetBit(index + j);
}
}
// write mask
mask.WriteTo(packet);
// write values
for (var i = mask.m_lowestIndex; i <= mask.m_highestIndex; i++)
{
if (mask.GetBit(i))
{
if (visible)
{
WriteUpdateValue(packet, receiver, i);
}
else
{
packet.Write(0);
}
}
}
}
public void SendSpontaneousUpdate(Character receiver, bool visible, params UpdateFieldId[] indices)
{
var highestIndex = 0;
foreach (var index in indices)
{
if (index.RawId > highestIndex)
{
highestIndex = index.RawId;
}
}
var mask = new UpdateMask(highestIndex);
using (var packet = new UpdatePacket(1024))
{
packet.Position = 4; // jump over header
packet.Write(1); // Update Count
packet.Write((byte)UpdateType.Values);
EntityId.WritePacked(packet);
WriteSpontaneousUpdate(mask, packet, receiver, indices, visible);
receiver.Send(packet);
}
}
protected void WriteUpdateValue(UpdatePacket packet, Character receiver, int index)
{
if (_UpdateFieldInfos.FieldFlags[index].HasAnyFlag(UpdateFieldFlags.Dynamic))
{
DynamicUpdateFieldHandlers[index](this, receiver, packet);
}
else
{
packet.Write(m_updateValues[index].UInt32);
}
}
private static void WriteCorpseDynFlags(ObjectBase obj, Character receiver, UpdatePacket packet)
{
if (((Corpse)obj).Owner == receiver)
{
packet.Write((uint)CorpseDynamicFlags.PlayerLootable);
}
else
{
packet.Write((uint)CorpseDynamicFlags.None);
}
}
private static void WriteUnitDynFlags(ObjectBase obj, Character receiver, UpdatePacket packet)
{
var unit = (Unit)obj;
//var flags = UnitDynamicFlags.None;
var flags = unit.DynamicFlags;
var loot = obj.Loot;
if (loot != null && receiver.LooterEntry.MayLoot(loot) && !unit.IsAlive)
{
flags |= UnitDynamicFlags.Lootable;
}
else
{
var firstAttacker = unit.FirstAttacker;
if (firstAttacker != null)
{
if ((firstAttacker == receiver ||
firstAttacker.IsAlliedWith(receiver)) &&
unit.IsAlive)
{
flags |= UnitDynamicFlags.TaggedByMe;
}
else
{
flags |= UnitDynamicFlags.TaggedByOther;
}
}
}
// TODO: TrackUnit, SpecialInfo
packet.Write((uint)flags);
}
private static void WriteGODynamic(ObjectBase obj, Character receiver, UpdatePacket packet)
{
packet.Write(obj.GetUInt32(GameObjectFields.DYNAMIC));
}
private static void WriteNPCFlags(ObjectBase obj, Character chr, UpdatePacket packet)
{
var flags = (NPCFlags)obj.GetUInt32(UnitFields.NPC_FLAGS);
if (obj is NPC)
{
var npc = (NPC)obj;
if (npc.IsTrainer && !npc.TrainerEntry.CanTrain(chr))
{
// Cannot talk to this Guy
flags = 0;
}
}
packet.Write((uint)flags);
}
protected UpdatePacket GetFieldUpdatePacket(UpdateFieldId field, EntityId value)
{
//UpdatePacket packet = new UpdatePacket(BufferManager.Small.CheckOut());
var packet = new UpdatePacket(128) { Position = 4 };
packet.Write(1); // Update Count
packet.Write((byte)UpdateType.Values);
EntityId.WritePacked(packet);
var blocks = (byte)((field.RawId + 1) / 32 + 2);
packet.Write(blocks);
if (blocks > 1)
{
packet.Zero((blocks - 2) * 4);
var updateBlocks = new int[blocks];
updateBlocks[field.RawId << 5] = (1 << (field.RawId & 31));
updateBlocks[field.RawId + 1 << 5] = (1 << (field.RawId + 1 & 31));
packet.Write(updateBlocks[0]);
packet.Write(updateBlocks[1]);
}
else
{
packet.Zero((blocks - 1) * 4);
packet.Write((1 << (field.RawId & 31) | 1 << (field.RawId + 1 & 31)));
}
packet.Write(value);
return packet;
}
private static void WriteAuraStateFlags(ObjectBase obj, Character reciever, UpdatePacket packet)
{
var unit = (Unit)obj;
Spell immolateAura = unit.GetStrongestImmolate();
//if there is a immolate aura on this object and the reciver casted it we can send that aurastate to him
if (immolateAura != null && unit.Auras[immolateAura].SpellCast.CasterChar == reciever)
{
packet.Write((uint)(unit.AuraState | AuraStateMask.Immolate));
}
else
packet.Write((uint)(unit.AuraState & ~AuraStateMask.Immolate));
}
private static void WriteGODynamic(ObjectBase obj, Character receiver, UpdatePacket packet)
{
var go = (GameObject)obj;
if (go is Transport || !go.Flags.HasAnyFlag(GameObjectFlags.ConditionalInteraction))
{
packet.Write(obj.GetUInt32(GameObjectFields.DYNAMIC));
}
else
{
GODynamicLowFlags lowFlags;
if (go.CanBeUsedBy(receiver))
{
lowFlags = GODynamicLowFlags.Clickable | GODynamicLowFlags.Sparkle;
}
else
{
lowFlags = GODynamicLowFlags.None;
}
packet.Write((ushort)lowFlags);
packet.Write(ushort.MaxValue);
}
}
public void SendOutOfRangeUpdate(Character receiver, HashSet<WorldObject> worldObjects)
{
using (var packet = new UpdatePacket(1024))
{
packet.Position = 4; // jump over header
packet.Write(1); // Update Count
packet.Write((byte)UpdateType.OutOfRange);
packet.Write(worldObjects.Count);
foreach (var worldObject in worldObjects)
{
worldObject.EntityId.WritePacked(packet);
}
receiver.Send(packet);
}
}
private static void WriteGOFlags(ObjectBase obj, Character receiver, UpdatePacket packet)
{
var go = (GameObject)obj;
if (go.Flags.HasFlag(GameObjectFlags.ConditionalInteraction))
{
if (go.CanInteractWith(receiver))
{
// remove conditional flag, if receiver may use the GO
packet.Write((uint) (go.Flags ^ GameObjectFlags.ConditionalInteraction));
}
else
{
packet.Write((uint)go.Flags);
}
}
else
{
packet.Write((uint)go.Flags);
}
}
protected UpdatePacket GetFieldUpdatePacket(UpdateFieldId field, byte[] value)
{
var blocks = (field.RawId >> 5) + 1;
var emptyBlockSize = (blocks - 1) * 4;
//UpdatePacket packet = new UpdatePacket(BufferManager.Small.CheckOut());
var packet = new UpdatePacket { Position = 4 };
packet.Write(1); // Update Count
packet.Write((byte)UpdateType.Values);
EntityId.WritePacked(packet);
packet.Write((byte)blocks);
//packet.TotalLength += emptyBlockSize;
packet.Zero(emptyBlockSize);
packet.Write(1 << (field.RawId & 31));
packet.Write(value);
return packet;
}
public void TestUpdatePacket()
{
var mgr = new BufferManager(2, 128);
var segment1 = mgr.CheckOut(); // 1st buffer
Assert.AreEqual(1, mgr.AvailableSegmentsCount);
var segment2 = mgr.CheckOut(); // 1st buffer
Assert.AreEqual(1, mgr.TotalBufferCount);
Assert.AreEqual(0, mgr.AvailableSegmentsCount);
//Assert.AreEqual(2, segment2.Buffer.UsedSegmentCount);
var segment3 = mgr.CheckOut(); // 2nd buffer
Assert.AreEqual(2, mgr.TotalBufferCount);
Assert.AreEqual(1, mgr.AvailableSegmentsCount);
//Assert.AreEqual(1, segment3.Buffer.UsedSegmentCount);
segment3.DecrementUsage();
Assert.AreEqual(2, mgr.AvailableSegmentsCount);
//Assert.AreEqual(0, segment3.Buffer.UsedSegmentCount);
//using (var outPacket = new UpdatePacket(segment2))
using (var outPacket = new UpdatePacket(128))
{
Assert.AreEqual(outPacket.PacketId, (PacketId)RealmServerOpCode.SMSG_UPDATE_OBJECT);
outPacket.Write(15);
outPacket.WriteCString("abc");
using (var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment1, outPacket))
{
Assert.AreEqual(0, inPacket.ReadInt32()); //update count
Assert.AreEqual(15, inPacket.ReadInt32());
Assert.AreEqual("abc", inPacket.ReadCString());
}
outPacket.Reset();
Assert.AreEqual(outPacket.PacketId, (PacketId)RealmServerOpCode.SMSG_UPDATE_OBJECT);
outPacket.WriteCString("def");
outPacket.WriteUShortBE(300);
using (var inPacket = DisposableRealmPacketIn.CreateFromOutPacket(segment1, outPacket))
{
Assert.AreEqual(0, inPacket.ReadInt32()); //update count
Assert.AreEqual((byte)0, inPacket.ReadByte()); //block count
Assert.AreEqual("def", inPacket.ReadCString());
Assert.AreEqual((ushort)300, inPacket.ReadUInt16BE());
}
}
}
protected static void SendUpdatePacket(Character character, UpdatePacket packet)
{
packet.SendTo(character.Client);
}
//protected override void WriteMovementUpdate(PrimitiveWriter packet, UpdateFieldFlags relation)
//{
// base.WriteMovementUpdate(packet, relation);
//}
void SendOwnUpdates()
{
m_updatePacket.Position = m_updatePacket.HeaderSize;
m_updatePacket.Write(UpdateCount);
SendUpdatePacket(this, m_updatePacket);
//m_updatePacket.Reset();
m_updatePacket.Close();
m_updatePacket = new UpdatePacket();
UpdateCount = 0;
}
