c# pdf viewer open source : How to reorder pages in pdf online application Library tool html .net asp.net online World%20of%20Warcraft%20Programming%20(2nd%20Edition)44-part1843

Chapter 21
Responding to the Combat Log and Threat Information
399
COMBATLOG_OBJECT_REACTION_MASK
The reaction ofan entity is a bitmisleading—you might think thatif an enemy
is attacking you or one of your allies they would show up as hostile. Instead,
the reaction indicates the predisposition of an entity toward the player. As a
result, one of the yellow-colored mobs in the game that won’t automatically
attack you will show up as having a neutral reaction to you even if it’s
fighting you!
The valid results for these flags are:
COMBATLOG_OBJECT_REACTION_HOSTILE
COMBATLOG_OBJECT_REACTION_NEUTRAL
COMBATLOG_OBJECT_REACTION_FRIENDLY
COMBATLOG_OBJECT_AFFILIATION_MASK
An object’s affiliation indicates its relationship to the player. The possible
results start with the closest to the player (that is, something that is owned by
the player) and move out to outsiders (entities that are not part of the player’s
raid or party). Possible results are:
COMBATLOG_OBJECT_AFFILIATION_OUTSIDER
COMBATLOG_OBJECT_AFFILIATION_RAID
COMBATLOG_OBJECT_AFFILIATION_PARTY
COMBATLOG_OBJECT_AFFILIATION_MINE
The numeric values of the global variables starts with 1 for
MINE
and
increases toward
OUTSIDER
with 8. Although we recommend against relying
on the numeric values of these variablesratherthan using theglobal constants,
the ordering of the values isn’t likely to change in the future without notice.
You could therefore check to see that something is either owned by you or
someone in your party by checking that the result is less than or equal to
COMBATLOG_OBJECT_AFFILIATION_PARTY
.
COMBATLOG_OBJECT_SPECIAL_MASK
The special flags are used to indicate if the entity has some special way to be
distinguished, from the player’s perspective. An entity might have no special
flags set, giving the result:
COMBATLOG_OBJECT_NONE
The flags might indicate that the entity has one of the eight raid icons on it:
COMBATLOG_OBJECT_RAIDTARGET8
COMBATLOG_OBJECT_RAIDTARGET7
How to reorder pages in pdf online - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
pdf rearrange pages online; reorder pdf pages in preview
How to reorder pages in pdf online - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
pdf rearrange pages; how to move pages within a pdf
400
Part III
Advanced Addon Techniques
COMBATLOG_OBJECT_RAIDTARGET6
COMBATLOG_OBJECT_RAIDTARGET5
COMBATLOG_OBJECT_RAIDTARGET4
COMBATLOG_OBJECT_RAIDTARGET3
COMBATLOG_OBJECT_RAIDTARGET2
COMBATLOG_OBJECT_RAIDTARGET1
The entity might have been set as a Main Tank or Main Assist:
COMBATLOG_OBJECT_MAINTANK
COMBATLOG_OBJECT_MAINASSIST
In addition the flags could indicate that the entity was the player’s target or
focus at the time the event arrived (although it may have since changed):
COMBATLOG_OBJECT_FOCUS
COMBATLOG_OBJECT_TARGET
Using CombatLog_Object_IsA
There is a utility function that can make working with combat log flags a bit
easier. It takes in a set of unit flags and a ‘‘filter’’ mask. If the unit matches the
given mask, it returns
1
;otherwise it returns
nil
.These predefined filters are
as follows:
COMBATLOG_FILTER_EVERYTHING
—Any entity.
COMBATLOG_FILTER_FRIENDLY_UNITS
—Entity is a friendly unit.
COMBATLOG_FILTER_HOSTILE_PLAYERS
—Entity is a hostile player unit.
COMBATLOG_FILTER_HOSTILE_UNITS
—Entity is a hostile non-player unit.
COMBATLOG_FILTER_ME
—Entity is the player.
COMBATLOG_FILTER_MINE
—Entity is a non-unit object belonging to the
player; for example, a totem.
COMBATLOG_FILTER_MY_PET
—Entity is the player’s pet.
COMBATLOG_FILTER_NEUTRAL_UNITS
—Entity is a neutral unit.
COMBATLOG_FILTER_UNKNOWN_UNITS
—Entity is a unit currently unknown
to the WoW client.
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview. Reorder TIFF Pages in C#.NET Application.
how to move pages in a pdf; change page order in pdf online
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
how to move pages around in a pdf document; how to reorder pages in pdf reader
Chapter 21
Responding to the Combat Log and Threat Information
401
Writing CombatStatus
As an example of how the combat log can be used to get detailed information
about combat in World of Warcraft, you will create an addon called Com-
batStatus. The initial version will show the damage per second and heals per
second for your party, including pets.
The addon is structured with the following observations in mind:
You can take advantage of unit flags to make capturing all of your
party’s events easier.In particular, you can check for
COMBATLOG_OBJECT_
AFFILIATION_PARTY
to get the relevant events.
Because combat data arrives with GUID information ratherthan unitIDs,
you’ll need to make sure you store and index all data using GUIDs. This
will ensure that you don’t lose any information if the order of unitIDs
change.
Aplayer might have more than one pet (for example, druids and their
treant pets, or shaman elemental totems). Rather than trying to consider
them individual pets, you can just collapse them into a single ‘‘pet’’ unit
foreachofyourpartymembers.Youcan usethe
SPELL_SUMMON
combatlog
event to detect new units coming into play so we can track their GUIDs.
Creating the Basic Addon Structure
In your Addons folder, create a new directory called CombatStatus. Inside,
create a new file called
CombatStatus.toc
with the following contents:
## Interface: 30300
## Notes: Provides a DPS meter for your party
CombatStatus.lua
CombatStatus.xml
Although you aren’t using any XML templates in this addon currently, it’s
bettertocreatethefilenowin caseyouchoosetoaddsomeatalatertime.Create
anew
CombatStatus.xml
file and add the basic
<Ui>
element declaration:
<Ui xmlns=“http://www.blizzard.com/wow/ui/“
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance“
xsi:schemaLocation=“http://www.blizzard.com/wow/ui/
http://wowprogramming.com/FrameXML/UI.xsd“>
</Ui>
Read PDF in Web Image Viewer| Online Tutorials
"This online guide content is Out Dated! Extract images from PDF documents; Add, reorder pages in PDF files; Save and print PDF as you wish;
reorder pages in pdf reader; pdf page order reverse
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize or re-arrange PDF document files using C#.NET code.
move pages in pdf file; how to move pages in pdf converter professional
402
Part III
Advanced Addon Techniques
To add the frame declaration and a system for initialization that you’ll
expand on in later sections, create a new file
CombatStatus.lua
with the
following contents:
local CombatStatus = CreateFrame(“Frame“, “CombatStatus“, UIParent)
function CombatStatus:OnEvent(event, ...)
if event == “PLAYER_LOGIN“ then
self:Initialize()
end
end
-- Begin initialization section
-- Set the event handler so it can drive everything else
CombatStatus:SetScript(“OnEvent“, CombatStatus.OnEvent)
if IsLoggedIn() then
CombatStatus:Initialize()
else
CombatStatus:RegisterEvent(“PLAYER_LOGIN“)
end
The bulk of this code should seem familiar to you, but the section at the
bottommightseema bitodd.As you’veseenthroughout the book,a numberof
API functions don’toperateproperlybeforethe
PLAYER_LOGIN
event.Normally
you would just register for the
PLAYER_LOGIN
event, but when an addon is
flagged as load-on-demand it might be loaded after that event has already
fired. So you check the
IsLoggedIn()
API function to see if that event has
already passed, and if so, youcall the initialization function directly.
As you add new functions to this addon, make sure to add them before the
initialization section at the bottom (beginning with the
SetScript
call), but
after the frame creation on the first line. Due to the complexity of this addon,
you will want to wait until the addon is finished before you test because some
functions reference others that are not yet defined.
Initializing CombatStatus
The setup for your addon will occur in the
Initialize()
method. There
you will set up the data tables, register for events, and create the dis-
play components of the addon. Add the following initialization function
to
CombatStatus.lua
. It’s not necessary to include the comments in your
version of the code, but that is entirely up to you.
function CombatStatus:Initialize()
self.combat_time = 0
-- The amount of time in combat
self.party_damage = {}
-- Store the party’s DPS
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
pdf reverse page order preview; move pdf pages online
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Online C# class source codes enable the ability to rotate single NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
move pages in pdf online; pdf change page order
Chapter 21
Responding to the Combat Log and Threat Information
403
self.party_heals = {}
-- Store the party’s heals
self.pet_guids = {}
-- Store GUID mappings for pets
-- This is a metatable that returns 0 for any non-set values.
It will
-- allow us to use table entries without having to check them first
local zero_mt = {
__index = function(tbl, key)
return 0
end,
}
setmetatable(self.party_damage, zero_mt)
setmetatable(self.party_heals, zero_mt)
-- This table will be used to store snapshots of the data every few
-- seconds, allowing us to calculate DPS and HPS over a smaller
-- period of time.
It will be indexed by unitid and each value will
-- be a table that returns 0 for default and holds the damage in the
-- damage field, and the heals in the heals field.
self.snapshots = {}
local emptytbl_mt = {
__index = function(tbl, key)
local new = setmetatable({}, zero_mt)
rawset(tbl, key, new)
return new
end,
}
setmetatable(self.snapshots, emptytbl_mt)
self.player_guid = UnitGUID(“player“)
self:RegisterEvent(“PARTY_MEMBERS_CHANGED“)
self:RegisterEvent(“UNIT_PET“)
self:RegisterEvent(“COMBAT_LOG_EVENT_UNFILTERED“)
self:RegisterEvent(“PLAYER_REGEN_ENABLED“)
self:RegisterEvent(“PLAYER_REGEN_DISABLED“)
self:CreateFrames()
self:UpdateFrame()
end
You define a number of entries in the frame’s table to store the state of
the addon. The first variable will allow you to track the amount of time the
player has been in combat. This allows you to take the total amount ofdamage
done, and divide it by the total amount of time spent in combat to get a unit’s
DPS. You store the damage and heals in separate tables (although you could
certainly conceive of different ways of doing this). You also need a place to
C# Word: How to Create Word Document Viewer in C#.NET Imaging
Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; (Directly see online document viewer demo here.).
reordering pdf pages; how to reverse pages in pdf
VB.NET TIFF: VB.NET Sample Code to Process & Manage TIFF Page
certain TIFF page, and sort & reorder TIFF pages in Process TIFF Pages Independently in VB.NET Code. powerful & profession imaging controls, PDF document, image
rearrange pages in pdf reader; reordering pages in pdf
404
Part III
Advanced Addon Techniques
store a mapping from pet GUID to owner GUID to ensure you can properly
handle pets.
You create a new metatable that returns 0 for any non-set values. This
allows you to avoid having to check if a value in the table is set before you
try to add anything to it. In the case of the damage tables, you can do the
following:
self.party_damage[guid] = self.party_damage[guid] + damageAmount
instead of:
local oldValue = self.party_damage[guid] or 0
self.party_damage[guid] = oldValue + damageAmount
It may be a minimal gain, but it’s also less prone to error. The snapshots
table is used to store periodic snapshots of the damage so you can display a
running average of everyone’s DPS. The table will be indexed by GUID and
thevalueis atable that contains two entries (health andheals)thatboth default
to 0. You use a metatable to create these tables automatically in the same way
you have the prior metatable default to 0.
Finally, you register for the following events:
PARTY_MEMBERS_CHANGED
—Use this eventto see when the composition of
the player’s party changes. This enables you to re-scan the pet mappings
and update the frame.
UNIT_PET
—This event fires when a unit’s pet status changes, such as
when a Warlock orHuntersummons ordismisses a pet. This won’tcover
the cases where temporary pets are summoned; you’ll catch those in
another way.
COMBAT_LOG_EVENT_UNFILTERED
—Because this addon is all about collect-
ing information from the combat log, naturally you need to register for
this event. This event is likely to fire very frequently so you will want
to take precautions to ensure you don’t do anything computationally
intensive in response to it.
PLAYER_REGEN_DISABLED
—Likewise, this event fires when the player
enters combat.
PLAYER_REGEN_ENABLED
—This event indicates that theplayer is no longer
in combat, so you can use it to swap between your two different
states.
Finally, you call the
CreateFrame()
method to create the status bars. Then
you call the
UpdateFrame()
method to actually run the update function. For
now, these methods don’t exist, but they will be filled in later.
Chapter 21
Responding to the Combat Log and Threat Information
405
Updating Pet Mappings
The strategy you’re going to take with pets is to map the pet GUID to the
owner GUID, so multiple pets get collapsed into a single amount of damage.
Add the following function that will take a unitID and update the GUID map
for that unit’s pets:
function CombatStatus:UpdatePets(unit)
local petUnit
if unit == “player“ then
petUnit = “pet“
else
petUnit = unit:gsub(“(party)(%d)“, “%1pet%2“)
end
if petUnit and UnitExists(petUnit) then
local guid = UnitGUID(unit)
local petGUID = UnitGUID(petUnit)
self.pet_guids[petGUID] = guid .. “pet“
end
end
To look up information about pets you need to use the unitID for the pet,
but you’re only given the unitID for the owner. For party members these IDs
are
partypet1
,
partypet2
,
partypet3
,and
partypet4
.You can use a simple
substitution using patterns to transform
party1
into
partypet1
,as shown in
the preceding code.
You need to cover the special case of the player’s pet, which is just the
unitID ‘‘pet.’’ Once you have the correct unitID, you check to see if the unit
exists and if so you get the GUID. Rather than doing a direct mapping from
the pet GUID to theownerGUID, you do a mapping from the pet GUID to the
owner GUID with the string ‘‘pet’’ added to the end.
If you didn’t add this string you would need to store the pet’s damage in
another table (because the damage table is indexedby GUID). Otherwise, you
would no longer be able to distinguish between the pets and the original unit
itself.
Storing Damage and Healing Information
You’reusingthe
COMBAT_LOG_EVENT_UNFILTERED
togetinformationaboutyour
party’s damage and healing, so you need a function that extracts the right
information fromthe various possible events. Create the following function in
CombatStatus.lua
:
local damageEvents = {
SWING_DAMAGE = true,
406
Part III
Advanced Addon Techniques
RANGE_DAMAGE = true,
SPELL_DAMAGE = true,
SPELL_PERIODIC_DAMAGE = true,
DAMAGE_SHIELD = true,
DAMAGE_SPLIT = true,
}
local healEvents = {
SPELL_HEAL = true,
SPELL_PERIODIC_HEAL = true,
}
function CombatStatus:ProcessEntry(timestamp, combatEvent, srcGUID, i
srcName, srcFlags, destGUID, destName, destFlags, ...)
if damageEvents[combatEvent] then
local offset = combatEvent == “SWING_DAMAGE“ and 1 or 4
local amount, overkill, school, resisted, blocked, absorbed = i
select(offset, ...)
-- Check if this is a pet, and if so map the pet’s GUID to the party
-- member’s GUID using the mapping table.
if self.pet_guids[srcGUID] then
srcGUID = self.pet_guids[srcGUID]
end
self.party_damage[srcGUID] = self.party_damage[srcGUID] + amount
elseif healEvents[combatEvent] then
local amount, overhealing, absorbed = select(4, ...)
self.party_heals[srcGUID] = (self.party_heals[srcGUID] or 0) + i
(amount - overhealing)
elseif combatEvent == “SPELL_SUMMON“ then
-- A unit of ours has summoned a new pet/totem.
Here we map the
-- new GUID to the party member’s with the string “pet“ added.
-- This way we can use a single table to store damage for all units
self.pet_guids[destGUID] = srcGUID .. “pet“
end
end
Because you are only concerned about events that are caused by damage or
events that are caused by healing you can use a lookup table to know whether
to continue processing. If the incoming event doesn’t match one of the entries
in the table,the function just returns.
If you look at the prefix/suffix information earlier in this chapter, you’ll see
that
SWING_DAMAGE
is the only damage event that doesn’t contain information
aboutthe spell that causedthe damage (because it’s caused by auto-attacking).
Thefirstline ofthedamageeventprocessingblocksetsa variablecalled
offset
that is used to
select()
the right arguments from the arguments that were
passed in. If you’re on a
SWING_DAMAGE
event the
offset
is set to 1, otherwise
it’s set to 3.
Chapter 21
Responding to the Combat Log and Threat Information
407
You then select the amount of damage and other relevant information from
the arguments. You check the pet GUID mapping table to see if you need to
convert the pet GUID to the owner’s GUID. Then, you store the damage into
the damage table.
Heals are even easier because you don’t have to worry about pet’s healing
(for the purposes of this addon, we’re choosing not to track pet heals). You
don’t want to count overhealing, however, which is what happens when,
for example, a heal lands for 6000 healing but the target is only missing
3000 damage.In this case,the API will show 3000 overhealing,so you subtract
this from the amount healed.
The
SPELL_SUMMON
event indicates that someone in your party has sum-
moned a new pet (such as a totem or a druid’s treants). When this happens
and you don’t have the unitID, you just update the GUID mapping table
directly.
Taking ‘‘Snapshots’’ of Damage and Healing
Every few seconds youaregoing to take a snapshotofthe current damage and
healing,allowing youtocalculateaveragesovereveryfew seconds ratherthan
only being able to display overall stats. Add the following function definition
to
CombatStatus.lua
:
local units = {“player“, “pet“, “party1“, “partypet1“, “party2“, “partypet2“,
i
“party3“, “partypet3“, “party4“, “partypet4“}
function CombatStatus:TakeSnapshot()
-- This function loops through all the valid unit ids and stores
-- the current DPS or HPS so we can later subtract it.
for idx, unit in ipairs(units) do
local guid = UnitGUID(unit)
if guid then
if self.pet_guids[guid] then
guid = self.pet_guids[guid]
end
self.snapshots[guid].damage = self.party_damage[guid]
self.snapshots[guid].heals = self.party_heals[guid]
end
end
end
Because you need to loop over the unitIDs in both the update and the
snapshot functions, you create a table that has each of the unitIDs you’re
concerned with. For each unit, you look up the GUID and if it’s a known pet
GUID you translate it using your mapping table. Then you update the entry
in the snapshots table with the current damage and healing information.
408
Part III
Advanced Addon Techniques
Writing an OnUpdate Function
Youneedasimpletimertohandletheperiodicupdatestothedamageandheal-
ing information. Addthe following function definition to
CombatStatus.lua
:
local counter = 0
local throttle = 5.0
function CombatStatus:OnUpdate(elapsed)
counter = counter + elapsed
if counter >= throttle then
counter = 0
self:UpdateFrame(throttle)
self:TakeSnapshot()
end
end
Every five seconds when the frame is shown, the frame will beupdated and
then a newsnapshotwill betaken.Ifyoutookthesnapshot first,theneveryone
would always show 0 dps because it would have nothing to compare against.
You pass the
throttle
argument to the update function, so it knows what
time period to divide the damage by.
Responding to Events
You need to glue everything together by responding to the events you have
registered for. Replace the
OnEvent
function with the following version:
function CombatStatus:OnEvent(event, ...)
if event == “COMBAT_LOG_EVENT_UNFILTERED“ then
-- Check to see if the source of the event is someone within the
-- circle of our party
local srcFlags = select(5, ...)
if bit.band(srcFlags, COMBATLOG_OBJECT_AFFILIATION_MASK) > i
COMBATLOG_OBJECT_AFFILIATION_PARTY then
return
end
self:ProcessEntry(...)
elseif event == “PARTY_MEMBERS_CHANGED“ then
for i = 1, GetNumPartyMembers() do
local unit = “party“ .. i
self:UpdatePets(unit)
end
if not self.in_combat then
self:UpdateFrame()
end
elseif event == “UNIT_PET“ then
local unit = ...
self:UpdatePets(unit)
Documents you may be interested
Documents you may be interested