WorldPacket const* WorldPackets::CombatLog::SpellHealLog::Write()
{
*this << TargetGUID;
*this << CasterGUID;
*this << int32(SpellID);
*this << int32(Health);
*this << int32(OverHeal);
*this << int32(Absorbed);
WriteBit(Crit);
WriteBit(CritRollMade.is_initialized());
WriteBit(CritRollNeeded.is_initialized());
WriteLogDataBit();
WriteBit(SandboxScaling.is_initialized());
FlushBits();
if (CritRollMade)
*this << *CritRollMade;
if (CritRollNeeded)
*this << *CritRollNeeded;
WriteLogData();
if (SandboxScaling)
*this << *SandboxScaling;
return &_worldPacket;
}
void UnlockPixels(void)
{
if (m_locked_bits == nil)
return;
FlushBits(m_locked_bits, m_locked_area . width * sizeof(uint32_t));
free(m_locked_bits);
m_locked_bits = nil;
}
WorldPacket const* WorldPackets::CombatLog::SpellExecuteLog::Write()
{
*this << Caster;
*this << SpellID;
*this << uint32(Effects.size());
for (SpellLogEffect const& effect : Effects)
{
*this << effect.Effect;
*this << uint32(effect.PowerDrainTargets.size());
*this << uint32(effect.ExtraAttacksTargets.size());
*this << uint32(effect.DurabilityDamageTargets.size());
*this << uint32(effect.GenericVictimTargets.size());
*this << uint32(effect.TradeSkillTargets.size());
*this << uint32(effect.FeedPetTargets.size());
for (SpellLogEffectPowerDrainParams const& powerDrainTarget : effect.PowerDrainTargets)
{
*this << powerDrainTarget.Victim;
*this << powerDrainTarget.Points;
*this << powerDrainTarget.PowerType;
*this << powerDrainTarget.Amplitude;
}
for (SpellLogEffectExtraAttacksParams const& extraAttacksTarget : effect.ExtraAttacksTargets)
{
*this << extraAttacksTarget.Victim;
*this << extraAttacksTarget.NumAttacks;
}
for (SpellLogEffectDurabilityDamageParams const& durabilityDamageTarget : effect.DurabilityDamageTargets)
{
*this << durabilityDamageTarget.Victim;
*this << durabilityDamageTarget.ItemID;
*this << durabilityDamageTarget.Amount;
}
for (SpellLogEffectGenericVictimParams const& genericVictimTarget : effect.GenericVictimTargets)
*this << genericVictimTarget.Victim;
for (SpellLogEffectTradeSkillItemParams const& tradeSkillTarget : effect.TradeSkillTargets)
*this << tradeSkillTarget.ItemID;
for (SpellLogEffectFeedPetParams const& feedPetTarget : effect.FeedPetTargets)
*this << feedPetTarget.ItemID;
}
WriteLogDataBit();
FlushBits();
WriteLogData();
return &_worldPacket;
}
WorldPacket const* WorldPackets::CombatLog::EnvironmentalDamageLog::Write()
{
*this << Victim;
*this << uint8(Type);
*this << int32(Amount);
*this << int32(Resisted);
*this << int32(Absorbed);
WriteLogDataBit();
FlushBits();
WriteLogData();
return &_worldPacket;
}
WorldPacket const* WorldPackets::CombatLog::SpellPeriodicAuraLog::Write()
{
*this << TargetGUID;
*this << CasterGUID;
*this << int32(SpellID);
*this << uint32(Effects.size());
for (SpellLogEffect const& effect : Effects)
{
*this << int32(effect.Effect);
*this << int32(effect.Amount);
*this << int32(effect.OverHealOrKill);
*this << int32(effect.SchoolMaskOrPower);
*this << int32(effect.AbsorbedOrAmplitude);
*this << int32(effect.Resisted);
WriteBit(effect.Crit);
WriteBit(effect.DebugInfo.is_initialized());
WriteBit(effect.SandboxScaling.is_initialized());
FlushBits();
if (effect.SandboxScaling)
*this << *effect.SandboxScaling;
if (effect.DebugInfo)
{
*this << float(effect.DebugInfo->CritRollMade);
*this << float(effect.DebugInfo->CritRollNeeded);
}
}
WriteLogDataBit();
FlushBits();
WriteLogData();
return &_worldPacket;
}
WorldPacket const* WorldPackets::CombatLog::SpellDamageShield::Write()
{
*this << Attacker;
*this << Defender;
*this << int32(SpellID);
*this << int32(TotalDamage);
*this << int32(OverKill);
*this << int32(SchoolMask);
*this << int32(LogAbsorbed);
WriteLogDataBit();
FlushBits();
WriteLogData();
return &_worldPacket;
}
WorldPacket const* WorldPackets::CombatLog::SpellEnergizeLog::Write()
{
*this << CasterGUID;
*this << TargetGUID;
*this << int32(SpellID);
*this << int32(Type);
*this << int32(Amount);
WriteLogDataBit();
FlushBits();
WriteLogData();
return &_worldPacket;
}
void UnlockGraphics(void)
{
if (m_locked_context == nil)
return;
MCscreen -> freecontext(m_locked_context);
m_locked_context = nil;
void *t_bits;
uint32_t t_stride;
MCscreen -> lockpixmap(m_locked_pixmap, t_bits, t_stride);
FlushBits(t_bits, t_stride);
MCscreen -> unlockpixmap(m_locked_pixmap, t_bits, t_stride);
MCscreen -> freepixmap(m_locked_pixmap);
}
void movePointerTo(mp4StreamType *psBits, int32 pos)
{
uint32 byte_pos;
if (pos < 0)
{
pos = 0;
}
byte_pos = pos >> 3;
if (byte_pos > (psBits->numBytes - psBits->bytePos))
{
byte_pos = (psBits->numBytes - psBits->bytePos);
}
psBits->bytePos = byte_pos & -4;
psBits->dataBitPos = psBits->bytePos << 3;
FlushBits(psBits, ((pos & 0x7) + ((byte_pos & 0x3) << 3)));
}
WorldPacket const* WorldPackets::CombatLog::SpellNonMeleeDamageLog::Write()
{
*this << Me;
*this << CasterGUID;
*this << CastID;
*this << int32(SpellID);
*this << int32(Damage);
*this << int32(Overkill);
*this << uint8(SchoolMask);
*this << int32(ShieldBlock);
*this << int32(Resisted);
*this << int32(Absorbed);
WriteBit(Periodic);
WriteBits(Flags, 7);
WriteBit(false); // Debug info
WriteLogDataBit();
WriteBit(SandboxScaling.is_initialized());
FlushBits();
WriteLogData();
if (SandboxScaling)
*this << *SandboxScaling;
return &_worldPacket;
}
static int writeData(void* _call)
{
WriterAVCallData_t* call = (WriterAVCallData_t*) _call;
unsigned char PesHeader[PES_MAX_HEADER_SIZE];
unsigned char FakeHeaders[64]; // 64bytes should be enough to make the fake headers
unsigned int FakeHeaderLength;
unsigned int ExtraLength = 0;
unsigned char Version = 5;
unsigned int FakeStartCode = (Version << 8) | PES_VERSION_FAKE_START_CODE;
unsigned int HeaderLength = 0;
unsigned int usecPerFrame = 41708; /* Hellmaster1024: default value */
BitPacker_t ld = {FakeHeaders, 0, 32};
divx_printf(10, "\n");
if (call == NULL)
{
divx_err("call data is NULL...\n");
return 0;
}
divx_printf(10, "AudioPts %lld\n", call->Pts);
if ((call->data == NULL) || (call->len <= 0))
{
divx_err("parsing NULL Data. ignoring...\n");
return 0;
}
if (call->fd < 0)
{
divx_err("file pointer < 0. ignoring ...\n");
return 0;
}
usecPerFrame = 1000000000 / call->FrameRate;
divx_printf(10, "Microsecends per frame = %d\n", usecPerFrame);
memset(FakeHeaders, 0, sizeof(FakeHeaders));
/* Create info record for frame parser */
/* divx4 & 5
VOS
PutBits(&ld, 0x0, 8);
PutBits(&ld, 0x0, 8);
*/
PutBits(&ld, 0x1b0, 32); // startcode
PutBits(&ld, 0, 8); // profile = reserved
PutBits(&ld, 0x1b2, 32); // startcode (user data)
PutBits(&ld, 0x53545443, 32); // STTC - an embedded ST timecode from an avi file
PutBits(&ld, usecPerFrame , 32);
// microseconds per frame
FlushBits(&ld);
FakeHeaderLength = (ld.Ptr - (FakeHeaders));
if (initialHeader) ExtraLength = call->private_size;
HeaderLength = InsertPesHeader (PesHeader, call->len, MPEG_VIDEO_PES_START_CODE, call->Pts, FakeStartCode);
int iovcnt = 0;
struct iovec iov[4];
iov[iovcnt].iov_base = PesHeader;
iov[iovcnt].iov_len = HeaderLength;
iovcnt++;
iov[iovcnt].iov_base = FakeHeaders;
iov[iovcnt].iov_len = FakeHeaderLength;
iovcnt++;
if (initialHeader) {
initialHeader = 0;
iov[iovcnt].iov_base = call->private_data;
iov[iovcnt].iov_len = call->private_size;
iovcnt++;
}
iov[iovcnt].iov_base = call->data;
iov[iovcnt].iov_len = call->len;
iovcnt++;
int len = writev(call->fd, iov, iovcnt);
divx_printf(10, "xvid_Write < len=%d\n", len);
return len;
}
WorldPacket const* WorldPackets::CombatLog::AttackerStateUpdate::Write()
{
ByteBuffer attackRoundInfo;
attackRoundInfo << uint32(HitInfo);
attackRoundInfo << AttackerGUID;
attackRoundInfo << VictimGUID;
attackRoundInfo << int32(Damage);
attackRoundInfo << int32(OverDamage);
attackRoundInfo << uint8(SubDmg.is_initialized());
if (SubDmg)
{
attackRoundInfo << int32(SubDmg->SchoolMask);
attackRoundInfo << float(SubDmg->FDamage);
attackRoundInfo << int32(SubDmg->Damage);
if (HitInfo & (HITINFO_FULL_ABSORB | HITINFO_PARTIAL_ABSORB))
attackRoundInfo << int32(SubDmg->Absorbed);
if (HitInfo & (HITINFO_FULL_RESIST | HITINFO_PARTIAL_RESIST))
attackRoundInfo << int32(SubDmg->Resisted);
}
attackRoundInfo << uint8(VictimState);
attackRoundInfo << uint32(AttackerState);
attackRoundInfo << uint32(MeleeSpellID);
if (HitInfo & HITINFO_BLOCK)
attackRoundInfo << int32(BlockAmount);
if (HitInfo & HITINFO_RAGE_GAIN)
attackRoundInfo << int32(RageGained);
if (HitInfo & HITINFO_UNK1)
{
attackRoundInfo << uint32(UnkState.State1);
attackRoundInfo << float(UnkState.State2);
attackRoundInfo << float(UnkState.State3);
attackRoundInfo << float(UnkState.State4);
attackRoundInfo << float(UnkState.State5);
attackRoundInfo << float(UnkState.State6);
attackRoundInfo << float(UnkState.State7);
attackRoundInfo << float(UnkState.State8);
attackRoundInfo << float(UnkState.State9);
attackRoundInfo << float(UnkState.State10);
attackRoundInfo << float(UnkState.State11);
attackRoundInfo << uint32(UnkState.State12);
}
if (HitInfo & (HITINFO_BLOCK | HITINFO_UNK12))
attackRoundInfo << float(Unk);
attackRoundInfo << uint8(SandboxScaling.Type);
attackRoundInfo << uint8(SandboxScaling.TargetLevel);
attackRoundInfo << uint8(SandboxScaling.Expansion);
attackRoundInfo << uint8(SandboxScaling.Class);
attackRoundInfo << uint8(SandboxScaling.TargetMinScalingLevel);
attackRoundInfo << uint8(SandboxScaling.TargetMaxScalingLevel);
attackRoundInfo << int16(SandboxScaling.PlayerLevelDelta);
attackRoundInfo << int8(SandboxScaling.TargetScalingLevelDelta);
WriteLogDataBit();
FlushBits();
WriteLogData();
*this << uint32(attackRoundInfo.size());
_worldPacket.append(attackRoundInfo);
_fullLogPacket.append(attackRoundInfo);
return &_worldPacket;
}
