This is my working version of advbot originally written by ml2517. Additions include a loot command, mana command, and a moveto command.
All files necessary are posted in this thread with the exception of advpath.inc and spellcast.inc
Code:
Version Info Version # Last Updated
------------------------------------------------------
advbot.txt 2.01 2/1/2005 11:00am
advbot.mac 2.01 2/1/2005 11:00am
advbot.inc 2.01 2/1/2005 9:30pm
advbot2.inc 2.01 2/1/2005 11:00am
Advbot.mac -(Ver.2 Advanced Caster Bot - Heal/Debuff/Buff)
Moderator: MacroQuest Developers
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
Advbot.txt
Code: Select all
|
| advbot.txt
| Advanced Caster Bot Documentation
| Version 2.01
| Date:2/1/2005 11:00am
|
|
| Exclude/Include routines taken from Raebis' advchant.mac
| and adapted to work in this script. No need to reinvent the wheel.
|
| TIP: The easiest way to exclude/include mobs is to set up a hotkey like this:
| For Excludes:
| /echo exclude ${Target.CleanName}
|
| For Includes:
| /echo include ${Target.CleanName}
|
| Optional INI Name (No Spaces) --o
| |
| vvvvvvvv
| Syntax: /macro advbot.mac [INI_Name]
|
| Example: /macro advbot.mac Plane_Of_Fear
| Might Generate: AD_Johnny_Plane_Of_Fear.ini
|
|
| To set this script up modify the INI file that is generated.
|
| Commands Available via /echo and from a designated master:
|
| heal [pets] (Toggles healing on/off, if you use the 'pets' optional parameter it toggles pet healing on/off.)
|
| events (Toggles hp/mana events on/off)
|
| debuff (Toggles debuffing on/off) (** This was previously 'hold' it has been changed for clarity)
|
| face (Toggles facing before debuffs on/off)
|
| loot (Commands bot to loot any nearby npc corpses)
|
| mana (Commands bot to reply with it's current mana %)
|
| moveto [me|<playername>] (Commands bot to move to specified pc)
|
| master <playername> (Toggles master rights for a player on/off)
|
| sit (Toggles idle time sitting on/off)
|
| selfbuff [#|all|alias] (Toggles selfbuffs on/off, Buffs/Rebuffs self buff #, alias or if all parameter is used it rebuffs all self buffs.)
|
| groupbuff [#|all|alias] [player#|player name] (Toggles groupbuffs on/off, Buffs/Rebuffs group buff #, alias or if all parameter is used it rebuffs all group buffs,
| Buffs player# or player name you specified with the buff if specified.)
|
| buff <#|all|alias> <player name> (Buffs <player name> with buff #, alias or all group buffs. This is the command you use to buff people outside of your group.
| There is no timer on these buffs so they won't be refreshed when they wear off. This is just a manual buff command.
|
| exclude <mobname> (Excludes the mob name you specify. Spaces *are* allowed.
|
| include <mobname> (Includes the mob name you specify. Spaces *are* allowed. This essentially
| removes the mob from your INI file and the alert list.)
|
| announce (Toggles announcing on/off)
|
| reply (Toggles replying on/off)
|
| watch <targetname> (Toggles health watch on/off for <targetname>)
|
| pet [summon|optional /pet params] (Toggles pet functions on/off, if 'summon' parameter is supplied it will summon your pet. You can also feed
| parameters like 'back off', 'guard here' etc.)
|
| assist [assistname] (Toggles assist functions for debuffs/pet on/off, if an assist name is specified it will set your main assist name.)
|
| cmd [freeform command string] (This lets you perform generic commands on your bot. For instance, if you wanted to peform a mass group buff you can
| send a command like '/tell botname cmd alt activate 35' Just set up a hotkey on your master and you could issue the
| mass group buff and then '/tell botname groupbuff 1' to mass group buff your first groupbuff slot.
|
|
| Also added several advpath.inc commands that are able to be used from /echo or a designated master:
|
| follow <playername> (Starts following of <playername>)
|
| stop (Stops following.)
|
| pause (Pauses following.)
|
| goto locy locx [locz] (Sends the player to location y,x[,z] coordinate.)
|
| distance <#> (This sets the follow distance between you and the player you are following.)
|
|
| Commands can be issued via /echo and as a tell from a master.
| -----------------------------------------------------------------------------
|
| INI Setting Examples:
| ---------------------
| Radius=100 <------------------ Sets the mob search radius for the debuff function.
| TrackNumber=10 <-------------- Number of mobs to track within your radius. If more than this number enters, they will be ignored until a slot frees up.
| Announce=1 <------------------ If this is set to 1, announcements are on upon macro startup.
| AnnounceChannel=gsay;rsay <--- This sets the channel(s) where announcements will be sent. They can be sent to any channel, IE: 'AnnounceChannel=chat #mychannel;rsay;gsay'
| RetryCount=2 <---------------- Number of tries total, if resisted, for each debuff spell.
| NoSit=0 <--------------------- If this is set to 1, sitting is off upon macro startup.
| PauseEvents=1 <--------------- If this is set to 1, events are paused upon macro startup.
| PauseHeals=1 <---------------- If this is set to 1, heals are paused upon macro startup.
| PauseSelfBuffs=0 <------------ If this is set to 1, self buffs are paused upon macro startup.
| PauseGroupBuffs=0 <----------- If this is set to 1, group buffs are paused upon macro startup.
| PauseDebuffs=1 <-------------- If this is set to 1, debuffs are paused upon macro startup.
| PauseAssist=0 <--------------- If this is set to 1, pet/debuff MA assisting are paused upon macro startup.
| Reply=1 <--------------------- If this is set to 1, you will reply to commands sent to you from a master.
| MainAssistName=Johnny
| ReplyChannel=tell @ <--------- This is the channel that you acknowledge commands to. If you have a channel like gsay or chat #channelname that doesn't
| have a specific player name to respond to you juse use that channel IE: ReplyChannel=gsay or ReplyChannel=chat #channelname
| If you are replying to a channel that needs the masters name to reply back use this: ReplyChannel=tell @ or ReplyChannel=msg @
| The @ symbol lets it know that it needs to replace the @ with the masters name.
|
|
| xxxxCheckTime=xxx <----------- Each of these settings per section are used to regulate how often a given function is checked. If you'd like to give
| priority to any given section just lower the number (it is in seconds, IE -- 1s is one second.).
|
| PausePet=0 <------------------ If this is set to 1, pet functions are pause upon macro startup.
| PetAssistOnHPPct=98 <--------- Once the mob is under 98 percent and assisting is on, the pet will assist the MA and attack the target.
|
|
| WussyFactor=10 <-------------- This entry determines how much to compensate for pure casters during single target heal checking. If your thresholds were
| to heal from 30 to 60 percent and you had this set to ten, that would effectively be 30 to 70 percent for a pure caster.
|
| HealPets=0 <------------------ This entry is used to turn pet healing on/off upon macro startup. You can toggle it on/off in game with the 'heal pets' command.
|
| Dismount=nodismount <--------- This entry is used to determine whether or not you want to /dismount and duck to terminate casting when your target is lost.
| Valid entries are dismount and nodismount.
|
| SitAggroRadiusCheck=75 <------ If mobs are within this radius and facing directly at you, you will not sit down. I wouldn't recommend going much lower than 50 or so.
|
|
| Example for using spells:
|
| Debuff1=Tashania
| Debuff2=Bliss
| Debuff3=Cripple
| DebuffDuration1=0 <----------- Uses default spell duration IE: $spell("Spell Name",duration).
| DebuffDuration2=60 <---------- Uses custom duration of 60 seconds, after 60 seconds the debuff would be recast.
| DebuffDuration3=99999 <------- Uses INI default duration of 99999 seconds so that the debuff wouldn't be recast.
| DebuffStartWait1=0 <---------- Uses INI default wait time of 0 seconds which means to cast immediately.
| DebuffStartWait2=0 <---------- Uses INI default wait time of 0 seconds which means to cast immediately.
| DebuffStartWait3=20 <--------- Uses custom wait time of 20 seconds. After 20 seconds the mob will be debuffed. Then it uses the normal DebuffDuration timing from then on.
| DebuffMinHealth1=100 <-------- Uses INI default of 100 percent health, which would always cast on mobs.
| DebuffMinHealth2=100 <-------- Uses INI default of 100 percent health, which would always cast on mobs.
| DebuffMinHealth3=90 <--------- Uses custom value of 90 percent health. When the mobs health gets under 90 percent he would be debuffed.
| DebuffMinHealthNoCast1=0 <---- Uses INI default of 0 percent health, which would always cast on mobs.
| DebuffMinHealthNoCast2=95 <--- Uses custom value of 95 percent health. If the mob is at 95 percent or lower this debuff would not be cast.
| DebuffMinHealthNoCast3=0 <---- Uses INI default of 0 percent health, which would always cast on mobs.
| DebuffMinMobsInArea1=0 <------ Uses INI default of 0 mobs in area, which would always cast on mobs.
| DebuffMinMobsInArea2=2 <------ Uses custom value of 2 mobs in area, if there are at least 2 mobs in the area this debuff would be cast.
| DebuffMinMobsInArea3=0 <------ Uses INI default of 0 mobs in area, which would always cast on mobs.
| DebuffMinMana1=0 <------------ Uses INI default of 0 percent mana, which would always cast the debuff regardless of your mana percent.
| DebuffMinMana2=0 <------------ Uses INI default of 0 percent mana, which would always cast the debuff regardless of your mana percent.
| DebuffMinMana3=20 <----------- Uses custom value of 20 percent mana, this would stop casting this debuff if you were below 20 percent.
| DebuffAnnounce1=Debuffing -[ %T ]- with Tashania!
| DebuffAnnounce2=NULL <-------- This means that it would not announce anything for this particular debuff.
| DebuffAnnounce3=Debuffing -[ %T ]- with Cripple!
| DebuffMemToSlot1=0 <---------- If this spell is not memmed it would just throw it in the generic slot that spellcast.inc picks (Slot 5 currently)
| DebuffMemToSlot2=1 <---------- If this spell is not memmed it would mem this spell to slot 1. (I do not recommend using the mem function for debuffs)
| DebuffMemToSlot3=2 <---------- If this spell is not memmed it would mem this spell to slot 2. (I do not recommend using the mem function for debuffs)
|
| SelfBuff1=Invisibility
| SelfBuffDuration1=99999 <------- Tells it not to refresh for 99999 seconds.
| SelfBuffAtStart1=0 <------------ Uses default, not to buff yourself with this self buff when the macro is first start.
| SelfBuffIconCheck1=1 <---------- If this is set to 1 it will check for the buff name and recast if it isn't seen.
| SelfBuffIconName1=Invisibility
| SelfBuffMemToSlot1=7 <--------- If this spell is not memmed it would mem this spell to slot 7.
| SelfBuffAliasName1=invis <------ This is an alias name so that you don't have to remember the slot number when issuing the /echo selfbuff invis type commands.
|
| NOTE: All 4 conditions of each event must be met in order to trigger the event.
| EventSpell1=Cannablize II
| EventMinMana1=95 <-------------- If your character is equal to or less than 95 percent mana it will cast the event spell.
| EventMaxMana1=0 <--------------- Uses INI default, if your character is equal to or greater than 0 percent mana it will cast the event spell.
| EventMinHP1=100 <--------------- Uses INI default, if your character is equal to or less than 100 percent hp it will cast the event spell.
| EventMaxHP1=80 <---------------- If your character is equal to or greater than 80 percent hp it will cast the event spell.
| EventDuration=1 <--------------- This would tell the event to repeat constantly while the HP/Mana criteria are true.
| EventMemToSlot1=8 <------------ If this spell is not memmed it would mem this spell to slot 8. (The use of MemToSlot with events is situational)
|
| HealSpell1=Complete Healing
| HealMinHP1=40 <----------------- If the player in question is under 40 percent health this heal would NOT be cast.
| HealMaxHP1=50 <----------------- If the player in question is under 50 percent health this heal WOULD be cast.
| HealMinMana1=20 <--------------- This wouldn't try casting this heal if you were under 20 percent mana.
| HealMinGroupCount1=0 <---------- If this were a group based heal you could set this to the minimum number of group members to have to cast this spell.
| HealClass1=WAR|SHD|PAL <-------- This would only cast this heal on Warriors, Shadowknights and Paladins.
| HealAnnounce1=Complete Healing Incoming for -[ %T ]- !
| HealMemToSlot1=2 <-------------- If this spell is not memmed it would mem this spell to slot 2. (I do not recommend using the mem function for heal spells)
|
| GroupBuff1=Endure Magic
| GroupBuffDuration1=0 <---------- Set this to the duration of the buff, in seconds. 0 uses the spells normal duration. Using 1 for duration would chain cast it.
| GroupBuffAtStart1=0 <----------- This determines if the buff will be applied to the group immediately upon starting the script. 0 is no, 1 is yes.
| GroupBuffMinMana1=0 <----------- Minimum amount of mana you must have before trying to cast this group buff.
| GroupBuffMinGroupCount1=0 <----- This buff will not be cast unless there are 0 or more users in group. Max is 6. (NEVER set a single target buff to anything but 0.)
| GroupBuffAnnounce1=Casting Endure Magic on -[ %T ]- !
| GroupBuffClass1=WAR|SHD|PAL|RNG|MNK|ROG|BRD|BST|BER|SHM|CLR|DRU|WIZ|MAG|ENC|NEC
| GroupBuffMemToSlot1=7 <-------- If this spell is not memmed it would mem this spell to slot 7.
| GroupBuffAliasName1=endurem <---- This is an alias name so that you don't have to remember the slot number when issuing the /echo groupbuff endurem type commands.
|
| Example for using casting items:
|
| Debuff1=item Gloves of Fire <- Notice: the name of the item is preceded with "item ".
| DebuffDuration1=1 <----------- Set this to the duration of the debuff, in seconds. DO NOT use 0, as this is not a spell. Using 1 for duration would chain cast it.
| DebuffStartWait1=0 <---------- Uses INI default wait time of 0 seconds which means to cast immediately.
| DebuffMinHealth1=20 <--------- Uses INI value of 20 percent health, which means you wouldn't cast until the mob was at 20 percent.
| DebuffMinHealthNoCast1=0 <---- Uses INI default of 0 percent health, which would always cast on mobs.
| DebuffMinMobsInArea1=0 <------ Uses INI default of 0 mobs in area, which would always cast on mobs.
| DebuffMinMana1=0 <------------ Uses INI default of 0 percent mana, which would always cast the debuff regardless of your mana percent.
| DebuffAnnounce1=NULL <-------- This means that it would not announce anything for this particular debuff.
| DebuffMemToSlot1=0 <---------- Never change this from 0 if you are using an item.
|
| SelfBuff1=item White Rope Bridle<-- Notice: the name of the item is preceded with "item ".
| SelfBuffDuration1=3600 <----------- Waits 60 minutes before refreshing the buff. Never use 0 when using an item.
| SelfBuffAtStart1=1 <--------------- Buffs yourself immediately upon starting the macro.
| SelfBuffIconCheck1=1 <------------- If this is set to 1 it will check for the buff name and recast if it isn't seen.
| SelfBuffIconName1=Summon Horse <--- Since the item name and the buff name are different you'd set it like this.
| SelfBuffMemToSlot1=0 <------------ Never change this from 0 if you are using an item.
| SelfBuffAliasName1=horse <--------- This is an alias name so that you don't have to remember the slot number when issuing the /echo selfbuff horse type commands.
|
| NOTE: All 4 conditions of each event must be met in order to trigger the event.
| EventSpell1=item Rod O Power <-- Notice: the name of the item is preceded with "item ".
| EventMinMana1=95 <-------------- If your character is equal to or less than 95 percent mana it will cast the event item.
| EventMaxMana1=0 <--------------- Uses INI default, if your character is equal to or greater than 0 percent mana it will cast the event item.
| EventMinHP1=100 <--------------- Uses INI default, if your character is equal to or less than 100 percent hp it will cast the event item.
| EventMaxHP1=80 <---------------- If your character is equal to or greater than 80 percent hp it will cast the event item.
| EventDuration=600 <------------- This would tell the event to repeat no sooner than 10 minutes from the last event of this type.
| EventMemToSlot1=0 <------------ Never change this from 0 if you are using an item.
|
| HealSpell1=item Pants O Healing
| HealMinHP1=40 <----------------- If the group average is under 40 percent health this heal would NOT be cast.
| HealMaxHP1=50 <----------------- If the group average is under 50 percent health this heal WOULD be cast.
| HealMinMana1=20 <--------------- This wouldn't try casting this heal if you were under 20 percent mana.
| HealMinGroupCount1=4 <---------- This will not be cast unless you have 4 or more group members. (NEVER set a single target heal to anything but 0.)
| HealClass1=WAR|SHD|PAL <-------- This would only cast this heal on Warriors, Shadowknights and Paladins. (This is ignored because its a group spell.)
| HealAnnounce1=Casting Pants O Healing on the group!
| HealMemToSlot1=0 <-------------- Never change this from 0 if you are using an item.
|
| GroupBuff1=item Pants O Group Symbol
| GroupBuffDuration1=3600 <------- Set this to the duration of the buff, in seconds. You cannot use 0 for items! Using 1 for duration would chain cast it.
| GroupBuffAtStart1=0 <----------- This determines if the buff will be applied to the group immediately upon starting the script. 0 is no, 1 is yes.
| GroupBuffMinMana1=0 <----------- Minimum amount of mana you must have before trying to cast this group buff.
| GroupBuffMinGroupCount1=4 <----- This buff will not be cast unless there are 4 or more users in group. Max is 6. (NEVER set a single target buff to anything but 0.)
| GroupBuffAnnounce1=Casting Pants O Group Symbol on the group!
| GroupBuffClass1=WAR|SHD|PAL|RNG|MNK|ROG|BRD|BST|BER|SHM|CLR|DRU|WIZ|MAG|ENC|NEC
| GroupBuffMemToSlot1=0 <-------- Never change this from 0 if you are using an item.
| GroupBuffAliasName1=pants <----- This is an alias name so that you don't have to remember the slot number when issuing the /echo groupbuff pants type commands.
|
| Example for using AA skill activations:
|
| Debuff1=activate 169 <-------- Notice: the number of the AA Skill is preceded with "activate ".
| DebuffDuration1=1 <----------- AA skill duration in seconds. DO NOT use 0, as this is not a spell. Using 1 for duration would try to chain cast it.
| DebuffStartWait1=0 <---------- Uses INI default wait time of 0 seconds which means to activate the AA skill immediately.
| DebuffMinHealth1=20 <--------- Uses INI value of 20 percent health, which means you wouldn't activate the AA skill until the mob was at 20 percent.
| DebuffMinHealthNoCast1=0 <---- Uses INI default of 0 percent health, which would always activate the AA skill on mobs.
| DebuffMinMobsInArea1=0 <------ Uses INI default of 0 mobs in area, which would always actiavet the AA skill on mobs.
| DebuffMinMana1=0 <------------ Uses INI default of 0 percent mana, which would always cast the debuff regardless of your mana percent.
| DebuffAnnounce1=NULL <-------- This means that it would not announce anything for this particular debuff.
| DebuffMemToSlot1=0 <---------- Never change this from 0 if you are using an AA activate.
|
| SelfBuff1=activate 57 <------------ Notice: the number of the AA Skill is preceded with "activate ".
| SelfBuffDuration1=3600 <----------- Waits 60 minutes before refreshing the AA skill buff. Never use 0 when using an AA activation skill.
| SelfBuffAtStart1=1 <--------------- Buffs yourself with the AA skill immediately upon starting the macro.
| SelfBuffIconCheck1=1 <------------- If this is set to 1 it will check for the buff name and recast if it isn't seen.
| SelfBuffIconName1=AAIconNameBlah<-- If your AA skill puts an icon on you, you could use this to have it refresh if it goes away.
| SelfBuffMemToSlot1=0 <------------ Never change this from 0 if you are using an AA activate.
| SelfBuffAliasName1=gather <-------- This is an alias name so that you don't have to remember the slot number when issuing the /echo selfbuff gather type commands.
|
| NOTE: All 4 conditions of each event must be met in order to trigger the event.
| EventSpell1=activate 47 <------- Notice: the name of the AA skill is preceded with "activate ".
| EventMinMana1=95 <-------------- If your character is equal to or less than 95 percent mana it will activate the AA skill.
| EventMaxMana1=0 <--------------- Uses INI default, if your character is equal to or greater than 0 percent mana it will activate the AA skill.
| EventMinHP1=100 <--------------- Uses INI default, if your character is equal to or less than 100 percent hp it will activate the AA skill.
| EventMaxHP1=80 <---------------- If your character is equal to or greater than 80 percent hp it will activate the AA skill.
| EventDuration=4320 <------------ This would tell the event to repeat no sooner than 72 minutes from the last event of this type.
| EventMemToSlot1=0 <------------ Never change this from 0 if you are using an AA activate.
|
| HealSpell1=activate 169
| HealMinHP1=40 <----------------- If the group average is under 40 percent health this heal would NOT be cast.
| HealMaxHP1=50 <----------------- If the group average is under 50 percent health this heal WOULD be cast.
| HealMinMana1=20 <--------------- This wouldn't try casting this heal if you were under 20 percent mana.
| HealMinGroupCount1=4 <---------- This will not be cast unless you have 4 or more group members. (NEVER set a single target heal to anything but 0.)
| HealClass1=WAR|SHD|PAL <-------- This would only cast this heal on Warriors, Shadowknights and Paladins. (This is ignored because its a group spell.)
| HealAnnounce1=Casting Divine Arbitration on the group!
| HealMemToSlot1=0 <-------------- Never change this from 0 if you are using an AA activate.
|
| GroupBuff1=activate Paragon of Spirit
| GroupBuffDuration1=3600 <------- Set this to the duration of the buff, in seconds. You cannot use 0 for AA skills! Using 1 for duration would chain cast it.
| GroupBuffAtStart1=0 <----------- This determines if the buff will be applied to the group immediately upon starting the script. 0 is no, 1 is yes.
| GroupBuffMinMana1=0 <----------- Minimum amount of mana you must have before trying to cast this group buff.
| GroupBuffMinGroupCount1=4 <----- This buff will not be cast unless there are 4 or more users in group. Max is 6. (NEVER set a single target buff to anything but 0.)
| GroupBuffAnnounce1=Using AA skill Blah on the Group!
| GroupBuffClass1=WAR|SHD|PAL|RNG|MNK|ROG|BRD|BST|BER|SHM|CLR|DRU|WIZ|MAG|ENC|NEC
| GroupBuffMemToSlot1=0 <-------- Never change this from 0 if you are using an AA activate.
| GroupBuffAliasName1=paragon <--- This is an alias name so that you don't have to remember the slot number when issuing the /echo groupbuff paragon type commands.
|
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
Advbot.mac
part 1
part 1
Code: Select all
|
| advbot.mac
| Advanced Caster Bot macro. This macro lets you specify precise thresholds for debuffing/healing/events etc.
| Version 2.01
| Date:2/1/2005 11:00am
| modified by Blackcircle7
|
#turbo 40
#include advbot.inc
#include advbot2.inc
#include spellcast.inc
#include advpath.inc
| Uncomment these if you'd like commands to work via group and chat channels.
#chat group
|#chat chat
#chat tell
Sub Main(INI)
/declare a int local
/declare b int local
/call SetupADVars
/call InitAPFVars 1 15 20
/varset IniFile AD_${Me.Name}
/if (${Defined[INI]}) {
/varset IniFile ${IniFile}_${INI}
}
/varset IniFile ${IniFile}.ini
/call Startup
:MainLoop
/call AdvPathCall
/if (!${Zone.Name.Equal["${ZoneName}"]}) {
/for a 1 to ${TrackNumber}
/varset MobList[${a}] 0
/for b 1 to ${DebuffCount}
/varset MDL[${a},${b}] 0
/varset MobAnnounced[${a},${b}] 0
/next b
/next a
/varset VarNpcCount 0
/varset ZoneName ${Zone.Name}
}
/if (${PauseDebuffs}==0 && !${Me.Moving} && ${DebuffTimer}==0) /call DebuffSub
/if (${PauseDebuffs}==0) /call CheckNPC
/if (${PausePet}==0 && ${PetCheckTimer}==0) /call PetCheck
/if (${NoSit}==0 && !${Me.Moving} && ${SitCheckTimer}==0 && !${Me.Mount.ID}>0) /call SitCheck
/doevents
/if (${PauseDebuffs}==0 && !${Me.Moving}) /call IterateNPC
/if (${PauseSelfBuffs}==0 && !${Me.Moving} && ${SelfBuffTimer}==0 && (${VarNpcCount}<2 || ${PauseDebuffs}==1)) /call SelfBuffCheck
/if (${PauseGroupBuffs}==0 && !${Me.Moving} && ${GroupBuffTimer}==0 && (${VarNpcCount}<2 || ${PauseDebuffs}==1)) /call GroupBuffCheck
/if (${PausePet}==0 && !${Me.Moving} && ${PetBuffCheckTimer}==0 && (${VarNpcCount}<2 || ${PauseDebuffs}==1)) /call PetBuffCheck
/if (${PauseEvents}==0 && !${Me.Moving} && ${EventTimer}==0) /call EventCheck
/if (${PauseDebuffs}==0) /call CheckNPC
/if (${NoSit}==0 && !${Me.Moving}) /call SitCheck
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/doevents
/if (${MiscCheckTimer}==0) {
/varset MiscCheckTimer 5s
/if (${Me.Invited}) /timed 20 /disband
/if (${Window[ConfirmationDialogBox].Open}) /notify ConfirmationDialogBox Yes_Button leftmouseup
}
/goto :MainLoop
/return
Sub AdvPathCall
/if (${FollowFlag}==1) {
/if (!${Me.Mount.ID}>0 && !${Me.Standing} && ${Spawn[${FollowID}].Distance3D}>=${FollowDistance}) /stand
/call AdvPathPoll
}
/return
Sub SitCheck
/declare MobHeading int local
/declare MeHeading int local
/declare MiniIterate int local
/declare AggroFlag int local
/declare AggroID int local
/varset SitCheckTimer 2s
/if (${FollowFlag}==1 && ${Spawn[${FollowID}].Distance3D}>${FollowDistance}) /return
/varset MiniIterate 1
/varset AggroFlag 0
/varset AggroID 0
:CheckNext
/varset AggroID ${NearestSpawn[${MiniIterate},npc radius ${SitAggroRadiusCheck} zradius 10].ID}
/if (${AggroID}>0) {
/varset MobHeading ${Spawn[${AggroID}].Heading.Degrees}
/if (${Math.Abs[${Math.Calc[${Spawn[${AggroID}].HeadingTo.Degrees}+180]}]}>=359.99) {
/varset MeHeading ${Math.Calc[${Spawn[${AggroID}].HeadingTo.Degrees}-180+360]}
} else {
/varset MeHeading ${Math.Calc[${Spawn[${AggroID}].HeadingTo.Degrees}+180+360]}
}
/if ((${Math.Calc[${MobHeading}+360]}>${Math.Calc[${MeHeading}-15]})&&(${Math.Calc[${MobHeading}+360]}<${Math.Calc[${MeHeading}+15]})) {
/varset AggroFlag 1
/if (!${Me.Mount.ID}>0) {
/if (${Me.Sitting}) /stand
}
/goto :BreakOutCheckAggro
}
} else {
/if (${AggroFlag}==0) {
/if (!${Me.Mount.ID}>0) {
/if (${Me.Standing}) /sit on
}
/goto :BreakOutCheckAggro
}
}
/varset MiniIterate ${Math.Calc[${MiniIterate}+1]}
/goto :CheckNext
:BreakOutCheckAggro
/return
Sub IterateNPC
/declare npcid int local
/declare a int local
/declare b int local
/declare compare int local
/declare TempNpcCount int local
/varset npcid 0
/varset TempNpcCount 0
:GetSpawn
/doevents
/varset npcid ${NearestSpawn[${Math.Calc[${TempNpcCount}+1]},npc radius ${Radius} zradius 10 noalert ${AlertList}].ID}
/if (!${String[${npcid}].Equal[NULL]}) {
/varset TempNpcCount ${Math.Calc[${TempNpcCount}+1]}
/if (${TempNpcCount}>${TrackNumber}) /goto :DoneSearching
/varset compare 0
/for a 1 to ${TrackNumber}
/if (${npcid}==${MobList[${a}]}) {
/varset compare 1
/goto :BreakOutComp
}
/next a
:BreakOutComp
/if (${compare}==0) {
/for a 1 to ${TrackNumber}
/if (${MobList[${a}]}==0) {
/varset VarNpcCount ${Math.Calc[${VarNpcCount}+1]}
/varset MobList[${a}] ${npcid}
/for b 1 to ${DebuffCount}
/varset MDL[${a},${b}] ${Math.Calc[${DebuffStartWait[${b}]}+${Macro.RunTime}]}
/varset MobAnnounced[${a},${b}] 0
/next b
/goto :GetSpawn
}
/next a
}
} else {
/goto :DoneSearching
}
/goto :GetSpawn
:DoneSearching
/return
Sub DebuffSub
/call IterateNPC
/varset DebuffTimer ${DebuffCheckTime}
/declare a int local
/declare b int local
/declare c int local
/declare MATarget int local 0
/if (${PauseAssist}==0) {
/if (${TankName.Length}>0 && !${TankName.Equal[Main Assist Name]}) {
/if (${Spawn[pc ${TankName}].Distance}<200) {
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
/assist ${TankName}
/delay 1s ${Target.ID}!=${Me.ID}
/attack off
/varset MATarget ${Target.ID}
}
}
}
/for a 1 to ${TrackNumber}
/doevents Enraged
/call AdvPathCall
/if (${PauseDebuffs}==0 && !${Me.Moving}) {
/if (${MobList[${a}]}!=0) {
/for b 1 to ${DebuffCount}
/doevents Enraged
/if (${MobList[${a}]}!=${MATarget} && ${DebuffOnMATarget[${b}]}==1 && ${PauseAssist}==0) /goto :BreakOutDebuff
/if (${VarNpcCount}<${DebuffMinMobsInArea[${b}]}) /goto :BreakOutDebuff
/call AdvPathCall
/squelch /target id ${MobList[${a}]}
/delay 1s ${Target.ID}==${MobList[${a}]}
/if (!${Target.Type.Equal["NPC"]}) /goto :NotNPC
/if (${Spawn[${MobList[${a}]}].Distance}>${Radius}) /goto :NotNPC
/if (((${MDL[${a},${b}]}==0)||(${MDL[${a},${b}]}<${Math.Calc[${Macro.RunTime}]}))&&(${Spawn[${MobList[${a}]}].PctHPs}<=${DebuffMinHealth[${b}]})&&(${Spawn[${MobList[${a}]}].PctHPs}>${DebuffMinHealthNoCast[${b}]})&&(!${Spawn[${MobList[${a}]}].State.Equal["DEAD"]})&&(${Me.PctMana}>${DebuffMinMana[${b}]})) {
/if (((!${Debuff[${b}].Find["item"]})&&(!${Debuff[${b}].Find["activate"]}))&&((!${Me.SpellReady["${Debuff[${b}]}"]})&&(${Me.Gem["${Debuff[${b}]}"]}))) {
/for c 1 to 30
/delay 1
/if (${Me.SpellReady["${Debuff[${b}]}"]}) {
/goto :ContinueDebuff
}
/next c
/if (!${Me.SpellReady["${Debuff[${b}]}"]}) /goto :BreakOutDebuff
}
:ContinueDebuff
/if (!${Target.ID}>0) /goto :NotNPC
/echo Debuffing: -[ ${Spawn[${MobList[${a}]}].CleanName} ]- with ${Debuff[${b}]}.
/if (${FaceBeforeDebuff}==1) /face
/if (${Announce}==1) {
/call Debuff ${MobList[${a}]} "${Debuff[${b}]}" "${DebuffAnnounce[${b}]}" ${a} ${b} "${DebuffMemToSlot[${b}]}"
} else {
/call Debuff ${MobList[${a}]} "${Debuff[${b}]}" "NULL" ${a} ${b} "${DebuffMemToSlot[${b}]}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/return
}
/if (${Macro.Return.Equal["NODELAY"]}) {
/if (${DebuffDuration[${b}]}==99999) {
/varset MDL[${a},${b}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${DebuffDuration[${b}]}==0) {
/if (${Spell[${DebuffID[${b}]}].Duration.TotalSeconds}==0) {
/varset MDL[${a},${b}] ${Math.Calc[(1+${Macro.RunTime})-5]}
} else {
/varset MDL[${a},${b}] ${Math.Calc[${Spell[${DebuffID[${b}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset MDL[${a},${b}] ${Math.Calc[${DebuffDuration[${b}]}+${Macro.RunTime}-5]}
}
} else {
/varset MDL[${a},${b}] ${Math.Calc[15+${Macro.RunTime}]}
}
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/if (${PausePet}==0 && ${PetCheckTimer}==0) /call PetCheck
}
:BreakOutDebuff
/next b
/if (${PauseEvents}==0 && ${EventTimer}==0 && !${Me.Moving}) /call EventCheck
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
}
}
:NotNPC
/doevents
/next a
/return
Sub CheckNPC
/declare a int local
/declare b int local
/for a 1 to ${TrackNumber}
/if (${MobList[${a}]}!=0) {
/if ((${Spawn[${MobList[${a}]}].State.Equal["DEAD"]})||(!${Spawn[${MobList[${a}]}].ID})||(${Spawn[${MobList[${a}]}].Distance}>${Radius})) {
/varset MobList[${a}] 0
/varset VarNpcCount ${Math.Calc[${VarNpcCount}-1]}
/for b 1 to ${DebuffCount}
/varset MDL[${a},${b}] 0
/varset MobAnnounced[${a},${b}] 0
/next b
}
}
/next a
/return
Sub Debuff(mobid,debname,debannounce,a,b,memtoslot)
/declare resistcount int local
/declare retrytimer int local
/declare ParseAnnounceChannels string local
/declare TempHoldAnnounce string local
/varset resistcount 1
:RecastDebuff
/if (${PauseDebuffs}==1) /return
/if (${Me.Sitting}) /stand
/if (${debname.Left[4].Equal["item"]}) {
/call Cast "${debname.Right[-5]}" "item" "${Dismount}"
} else /if (${debname.Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${debname.Right[-9]}]}) /return DELAY
/call Cast "${debname.Right[-9]}" "activate" "${Dismount}"
} else {
/call Cast "${debname}" "gem${memtoslot}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) /return CAST_LOSTTARGET
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) /return DELAY
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/if (${Spell["${debname}"].RecastTime}) {
/if (${Spell["${debname}"].RecastTime}<=10) {
/varset retrytimer ${Math.Calc[${Spell["${debname}"].RecastTime}+1+${Macro.RunTime}]}
} else {
/return NODELAY
}
}
/if (${resistcount}<${RetryCount}) {
/varset resistcount ${Math.Calc[${resistcount}+1]}
:WaitForGem
/call AdvPathCall
/delay 1
/if (${debname.Left[4].Equal["item"]}) {
/squelch /target id ${mobid}
/delay 1s ${Target.ID}==${mobid}
/goto :RecastDebuff
} else /if (${debname.Left[8].Equal["activate"]}) {
/squelch /target id ${mobid}
/delay 1s ${Target.ID}==${mobid}
/goto :RecastDebuff
} else {
/if (${retrytimer}<${Math.Calc[${Macro.RunTime}]}) {
/return NODELAY
}
/if (!${Me.SpellReady["${debname}"]}) {
/goto :WaitForGem
}
}
/squelch /target id ${mobid}
/delay 1s ${Target.ID}==${mobid}
/goto :RecastDebuff
} else {
/return NODELAY
}
}
/if ((${Macro.Return.Equal["CAST_CANNOTSEE"]})||(${Macro.Return.Equal["CAST_OUTOFRANGE"]})) {
/echo -(( Mob out of range or cannot be seen. Waiting 15 seconds and trying again. ))-
/return DELAY
}
/if ((${Macro.Return.Equal["CAST_SUCCESS"]})&&(${Announce}==1)&&(!${debannounce.Equal["NULL"]})&&(${MobAnnounced[${a},${b}]}==0)) {
/if (${AnnounceChannel.Length}>0) {
/if (${AnnounceChannel.Find[;]}) {
/varset TempHoldAnnounce ${AnnounceChannel}
:ParseNext
/varset ParseAnnounceChannels ${TempHoldAnnounce.Arg[1,;]}
/varset TempHoldAnnounce ${TempHoldAnnounce.Right[-${TempHoldAnnounce.Find[;]}]}
:SendIt
/if (${ParseAnnounceChannels.Equal[gsay]} && ${Group}>0) {
/gsay ${debannounce}
} else /if (!${ParseAnnounceChannels.Equal[gsay]}) {
/docommand /${ParseAnnounceChannels} ${debannounce}
}
/if (${TempHoldAnnounce.Length}>0) {
/if (${TempHoldAnnounce.Find[;]}>0) {
/goto :ParseNext
} else {
/varset ParseAnnounceChannels ${TempHoldAnnounce}
/varset TempHoldAnnounce
/goto :SendIt
}
}
} else {
/if (${AnnounceChannel.Equal[gsay]} && ${Group}>0) {
/gsay ${debannounce}
} else /if (!${AnnounceChannel.Equal[gsay]}) {
/docommand /${AnnounceChannel} ${debannounce}
}
}
}
/varset MobAnnounced[${a},${b}] 1
}
/return NODELAY
Sub SelfBuffCheck
/varset SelfBuffTimer ${SelfBuffCheckTime}
/declare a int local
/declare f int local
/declare RetryBuffCount int local
/if (${SelfBuffCount}>0) {
/for a 1 to ${SelfBuffCount}
/if (${PauseSelfBuffs}==1 || ${Me.Moving}) /return
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/varset RetryBuffCount 0
/call AdvPathCall
/if ((${SelfBuffedList[${a}]}<${Math.Calc[${Macro.RunTime}]})||((${SelfBuffIconCheck[${a}]}==1)&&(!${Me.Buff["${SelfBuffIconName[${a}]}"].Duration})&&(${SelfBuffedList[${a}]}!=99999))) {
:RetryBuff
/if (${PauseSelfBuffs}==1) /return
/if ((!${SelfBuff[${a}].Find["item"]}>0)&&(!${SelfBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${SelfBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${SelfBuff[${a}]}"]}) {
/goto :ContinueSelfBuff
}
/next f
/if (!${Me.SpellReady["${SelfBuff[${a}]}"]}) /goto :BreakOutSelf
}
}
:ContinueSelfBuff
/if ((${Me.Gem[${SelfBuff[${a}]}]})||(${SelfBuff[${a}].Find["item"]})||(${SelfBuff[${a}].Find["activate"]})||(${SelfBuffMemToSlot[${a}]}>0)) {
/if (${Me.Sitting}) /stand
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
/if (${SelfBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Self Buff : ${SelfBuff[${a}]} ]-
/call Cast "${SelfBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${SelfBuff[${a}].Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${SelfBuff[${a}].Right[-9]}]}) /goto :BreakOutSelf
/echo -[ Casting Self Buff : ${SelfBuff[${a}]} ]-
/call Cast "${SelfBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Self Buff : ${SelfBuff[${a}]} ]-
/call Cast "${SelfBuff[${a}]}" "gem${SelfBuffMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset SelfBuffTimer 0
/return
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/varset SelfBuffedList[${a}] ${Math.Calc[15+${Macro.RunTime}]}
/goto :BreakOutSelf
}
/if (${SelfBuffDuration[${a}]}==99999) {
/varset SelfBuffedList[${a}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${SelfBuffDuration[${a}]}==0) {
/if (${Spell[${SelfBuffID[${a}]}].Duration.TotalSeconds}==0) {
/varset SelfBuffedList[${a}] ${Math.Calc[(1+${Macro.RunTime})-5]}
} else {
/varset SelfBuffedList[${a}] ${Math.Calc[${Spell[${SelfBuffID[${a}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset SelfBuffedList[${a}] ${Math.Calc[${SelfBuffDuration[${a}]}+${Macro.RunTime}-5]}
}
} else {
/if (${RetryBuffCount}==0) {
/if (!${Me.SpellReady["${SelfBuff[${a}]}"]}) {
/call Delay 3s
/varset RetryBuffCount ${Math.Calc[${RetryBuffCount}+1]}
/goto :RetryBuff
}
}
/echo -(( Self Buff:${SelfBuff[${a}]} not memmed or not ready. ))-
/echo -(( Waiting 60 seconds before retrying buff. ))-
/varset SelfBuffedList[${a}] ${Math.Calc[60+${Macro.RunTime}]}
}
}
:BreakOutSelf
/next a
}
/return
Sub PetCheck
/varset PetCheckTimer ${PetCheckTime}
/declare PetTarget int local 0
/if (${PauseAssist}==0) {
/if (${Me.Pet.ID}>0 && !${TankName.Equal[Main Assist Name]} && ${TankName.Length}>0) {
/if (${Spawn["${TankName}"].Distance}<150) {
/squelch /target id ${Me.Pet.ID}
/delay 1s ${Target.ID}==${Me.Pet.ID}
/assist
/delay 1s ${Target.ID}!=${Me.Pet.ID}
/if ((${Target.ID}>0) && (${Target.ID}!=${Me.Pet.ID}) && (!${Target.Type.Equal[CORPSE]})) {
/varset PetTarget ${Target.ID}
} else {
/varset PetTarget 0
}
/assist ${TankName}
/delay 7
/attack off
/if (${Target.ID}>0 && ${Target.Type.Equal[NPC]} && ${Target.PctHPs}<=${PetAssistOnHPPct}) {
/if (${PetTarget}==0) {
/pet attack
} else /if (${PetTarget}!=${Target.ID}) {
/pet back off
/delay 2
/pet attack
}
}
}
}
}
/return
Last edited by Blackcircle7 on Thu Feb 10, 2005 12:07 am, edited 1 time in total.
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
Advbot.mac
part 2
part 2
Code: Select all
Sub PetBuffCheck
/declare a int local
/declare f int local
/declare RetryPetBuffCount int local
/varset PetBuffCheckTimer ${PetBuffCheckTime}
/if (${Me.Pet.ID}>0 && ${PetBuffCount}>0) {
/for a 1 to ${PetBuffCount}
/varset RetryPetBuffCount 0
/if (!${Me.PetBuff["${PetBuffIconName[${a}]}"]}>0 && ${Me.Pet.Distance}<100) {
/if (${PausePet}==1) /return
:RetryPetBuff
/if ((!${PetBuff[${a}].Find["item"]}>0)&&(!${PetBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${PetBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${PetBuff[${a}]}"]}) {
/goto :ContinuePetBuff
}
/next f
/if (!${Me.SpellReady["${PetBuff[${a}]}"]}) /goto :BreakOutPetBuff
}
}
:ContinuePetBuff
/if ((${Me.Gem[${PetBuff[${a}]}]})||(${PetBuff[${a}].Find["item"]})||(${PetBuff[${a}].Find["activate"]})||(${PetBuffMemToSlot[${a}]}>0)) {
/if (${Me.Sitting}) /stand
/squelch /target id ${Me.Pet.ID}
/delay 1s ${Target.ID}==${Me.Pet.ID}
/if (${PetBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Pet Buff : ${PetBuff[${a}]} ]-
/call Cast "${PetBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${PetBuff[${a}].Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${PetBuff[${a}].Right[-9]}]}) /goto :BreakOutPetBuff
/echo -[ Casting Pet Buff : ${PetBuff[${a}]} ]-
/call Cast "${PetBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Pet Buff : ${PetBuff[${a}]} ]-
/call Cast "${PetBuff[${a}]}" "gem${PetBuffMemToSlot[${a}]}" "${Dismount}"
}
} else {
/if (${RetryPetBuffCount}==0) {
/if (!${Me.SpellReady["${PetBuff[${a}]}"]}) {
/call Delay 3s
/varset RetryPetBuffCount ${Math.Calc[${RetryPetBuffCount}+1]}
/goto :RetryPetBuff
}
}
}
}
:BreakOutPetBuff
/next a
}
/return
Sub EventCheck
/varset EventTimer ${EventCheckTime}
/declare a int local
/declare c int local
/declare RetryEventCount int local
/if (${EventCount}>0) {
/for a 1 to ${EventCount}
/call AdvPathCall
/if (${PauseEvents}==1 || ${Me.Moving}) /return
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/varset RetryEventCount 0
/if ((${Me.PctMana}<=${EventMinMana[${a}]})&&(${Me.PctMana}>=${EventMaxMana[${a}]})&&(${Me.PctHPs}<=${EventMinHP[${a}]})&&(${Me.PctHPs}>=${EventMaxHP[${a}]})) {
/if (${EventList[${a}]}<${Math.Calc[${Macro.RunTime}]}) {
:RetryEvent
/if (${PauseEvents}==1) /return
/if ((!${EventSpell[${a}].Find["item"]}>0)&&(!${EventSpell[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${EventSpell[${a}]}]}) {
/for c 1 to 30
/delay 1
/if (${Me.SpellReady["${EventSpell[${a}]}"]}) {
/goto :ContinueEvent
}
/next c
/if (!${Me.SpellReady["${EventSpell[${a}]}"]}) /goto :BreakOutEvent
}
}
:ContinueEvent
/if ((${Me.Gem[${EventSpell[${a}]}]})||(${EventSpell[${a}].Find["item"]})||(${EventSpell[${a}].Find["activate"]})||(${EventMemToSlot[${a}]}>0)) {
/if (${Me.Sitting}) /stand
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
/if (${EventSpell[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Event Spell : ${EventSpell[${a}]} ]-
/call Cast "${EventSpell[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${EventSpell[${a}].Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${EventSpell[${a}].Right[-9]}]}) /goto :BreakOutEvent
/echo -[ Casting Event Spell : ${EventSpell[${a}]} ]-
/call Cast "${EventSpell[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Event Spell : ${EventSpell[${a}]} ]-
/call Cast "${EventSpell[${a}]}" "gem${EventMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset EventTimer 0
/return
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/varset EventList[${a}] ${Math.Calc[15+${Macro.RunTime}]}
/goto :BreakOutEvent
}
/if (${EventDuration[${a}]}==99999) {
/varset EventList[${a}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${EventDuration[${a}]}==0) {
/if (${Spell[${EventSpellID[${a}]}].Duration.TotalSeconds}==0) {
/varset EventList[${a}] ${Math.Calc[(1+${Macro.RunTime})-5]}
} else {
/varset EventList[${a}] ${Math.Calc[${Spell[${EventSpellID[${a}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset EventList[${a}] ${Math.Calc[${EventDuration[${a}]}+${Macro.RunTime}-5]}
}
} else {
/if (${RetryEventCount}==0) {
/if (!${Me.SpellReady["${EventSpell[${a}]}"]}) {
/call Delay 3s
/varset RetryEventCount ${Math.Calc[${RetryEventCount}+1]}
/goto :RetryEvent
}
}
/echo -(( Event Spell:${EventSpell[${a}]} not memmed or not ready. ))-
/echo -(( Waiting 60 seconds before retrying event. ))-
/varset EventList[${a}] ${Math.Calc[60+${Macro.RunTime}]}
}
}
}
:BreakOutEvent
/next a
}
/return
Sub GroupBuffCheck
/varset GroupBuffTimer ${GroupBuffCheckTime}
/declare a int local
/declare b int local
/declare c int local
/declare f int local
/declare RetryBuffCount int local
/declare ParseAnnounceChannels string local
/declare TempHoldAnnounce string local
/if (${GroupBuffCount}>0) {
/for a 1 to ${GroupBuffCount}
/if (${PauseGroupBuffs}==1 || ${Me.Moving}) /return
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/call AdvPathCall
/for b 0 to ${Group}
/call AdvPathCall
/varset RetryBuffCount 0
/if (${Me.PctMana}>=${GroupBuffMinMana[${a}]}) {
/if (${GBL[${a},${Math.Calc[${b}+1]}]}<${Math.Calc[${Macro.RunTime}]}) {
/if (${Math.Calc[${Group}+1]}<${GroupBuffMinGroupCount[${a}]}) /goto :BreakOutBuff
/if (((${Spell[${GroupBuffID[${a}]}].TargetType.Find["Group"]})&&(${b}!=0))||((${GroupBuffMinGroupCount[${a}]}>0)&&(${b}!=0))) /goto :BreakOutBuff
/if ((${b}>0)&&(!${GroupBuffClass[${a}].Find["${Group[${b}].Class.ShortName}"]})) /goto :BreakOutMember
/if ((${b}==0)&&(!${GroupBuffClass[${a}].Find["${Me.Class.ShortName}"]})&&((!${Spell[${GroupBuffID[${a}]}].TargetType.Find["Group"]})||(${GroupBuffMinGroupCount[${a}]}==0))) /goto :BreakOutMember
:RetryBuff
/if (${PauseGroupBuffs}==1 || ${Me.Moving}) /return
/if ((${Me.Gem[${GroupBuff[${a}]}]})||(${GroupBuff[${a}].Find["item"]})||(${GroupBuff[${a}].Find["activate"]})||(${GroupBuffMemToSlot[${a}]}>0)) {
/if ((${GroupBuff[${a}].Find["activate"]})&&(!${Me.AltAbilityReady[${GroupBuff[${a}].Right[-9]}]})) /goto :BreakOutBuff
/if ((!${GroupBuff[${a}].Find["item"]}>0)&&(!${GroupBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${GroupBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/goto :ContinueGroupBuff
}
/next f
/if (!${Me.SpellReady["${GroupBuff[${a}]}"]}) /goto :BreakOutBuff
}
}
:ContinueGroupBuff
/if (${Spell[${GroupBuffID[${a}]}].TargetType.Find["Group"]} || ${b}==0) {
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
} else {
/squelch /target id ${Group[${b}].ID}
/delay 1s ${Target.ID}==${Group[${b}].ID}
}
/if (!${Target.CleanName.Equal[${Group[${b}]}]}) {
/echo -(( Target not in zone. Waiting 30 seconds and trying again. ))-
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[30+${Macro.RunTime}]}
/goto :BreakOutMember
}
/if (!${GroupBuff[${a}].Find[Item]} && !${GroupBuff[${a}].Find[Activate]} && ${Target.Distance3D}>${Spell[${GroupBuffID[${a}]}].Range}) /goto :BreakOutMember
/if ((${Announce}==1)&&(!${GroupBuffAnnounce[${a}].Equal["NULL"]})) {
/if (${AnnounceChannel.Length}>0) {
/if (${AnnounceChannel.Find[;]}) {
/varset TempHoldAnnounce ${AnnounceChannel}
:ParseNext
/varset ParseAnnounceChannels ${TempHoldAnnounce.Arg[1,;]}
/varset TempHoldAnnounce ${TempHoldAnnounce.Right[-${TempHoldAnnounce.Find[;]}]}
:SendIt
/if (${ParseAnnounceChannels.Equal[gsay]} && ${Group}>0) {
/gsay ${GroupBuffAnnounce[${a}]}
} else /if (!${ParseAnnounceChannels.Equal[gsay]}) {
/docommand /${ParseAnnounceChannels} ${GroupBuffAnnounce[${a}]}
}
/if (${TempHoldAnnounce.Length}>0) {
/if (${TempHoldAnnounce.Find[;]}>0) {
/goto :ParseNext
} else {
/varset ParseAnnounceChannels ${TempHoldAnnounce}
/varset TempHoldAnnounce
/goto :SendIt
}
}
} else {
/if (${AnnounceChannel.Equal[gsay]} && ${Group}>0) {
/gsay ${GroupBuffAnnounce[${a}]}
} else /if (!${AnnounceChannel.Equal[gsay]}) {
/docommand /${AnnounceChannel} ${GroupBuffAnnounce[${a}]}
}
}
}
}
/if (${Me.Sitting}) /stand
/if (${GroupBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Group Buff : ${GroupBuff[${a}]} ]-
/call Cast "${GroupBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${GroupBuff[${a}].Left[8].Equal["activate"]}) {
/echo -[ Casting Group Buff : ${GroupBuff[${a}]} ]-
/call Cast "${GroupBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Group Buff : ${GroupBuff[${a}]} ]-
/call Cast "${GroupBuff[${a}]}" "gem${GroupBuffMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[15+${Macro.RunTime}]}
/goto :BreakOutBuff
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset GroupBuffTimer 0
/return
}
/if ((${Macro.Return.Equal["CAST_CANNOTSEE"]})||(${Macro.Return.Equal["CAST_OUTOFRANGE"]})) {
/echo -(( Out of range or cannot be seen. Waiting 20 seconds and trying again. ))-
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[20+${Macro.RunTime}]}
/goto :BreakOutMember
}
/if (${GroupBuffDuration[${a}]}==99999) {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${GroupBuffDuration[${a}]}==0) {
/if (${Spell[${GroupBuffID[${a}]}].Duration.TotalSeconds}==0) {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[(1+${Macro.RunTime})-5]}
} else {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[${Spell[${GroupBuffID[${a}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[${GroupBuffDuration[${a}]}+${Macro.RunTime}-5]}
}
} else {
/if (${RetryBuffCount}==0) {
/if (!${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/call Delay 3s
/varset RetryBuffCount ${Math.Calc[${RetryBuffCount}+1]}
/goto :RetryBuff
}
}
/echo -(( Group Buff:${GroupBuff[${a}]} not memmed or not ready. ))-
/echo -(( Waiting 60 seconds before retrying buff. ))-
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[60+${Macro.RunTime}]}
}
}
}
:BreakOutMember
/next b
:BreakOutBuff
/next a
}
/return
Sub HealCheck
/varset HealTimer ${HealCheckTime}
/declare a int local
/declare b int local
/declare c int local
/declare d int local
/declare e int local
/declare f int local
/declare RetryHealCount int local
/declare GroupHPTotal int local
/declare GroupHealFlag int local
/declare TempIndex int local
/declare TempGroupCount int local
/declare ParseAnnounceChannels string local
/declare TempHoldAnnounce string local
/declare PetHealFlag int local 0
/declare TempGrpCt int local 0
/declare TempClass string local Nothing
/declare TempHealth int local 0
/declare TempTargetType string local
/varset TempGroupCount ${Group}
/if (${HealCount}>0) {
/for a 1 to ${HealCount}
/doevents Enraged
/call AdvPathCall
/if (${PauseHeals}==1) /return
/if (${Group}!=${TempGroupCount}) /return
/varset GroupHealFlag 0
/if (${Me.PctMana}>=${HealMinMana[${a}]}) {
/varset GroupHPTotal 0
/for b 0 to ${Math.Calc[${Group}+${WatchListCount}]}
/varset PetHealFlag 0
/call AdvPathCall
/if (${b}>${Group}) {
/varset d ${Math.Calc[${b}-${Group}]}
/if (!${WatchList[${d}].Equal[Empty]}) {
/for e 0 to 5
/if (${WatchList[${d}].Equal[${Group[${e}]}]}) {
/goto :BreakOutHoT
}
/next e
}
}
/if (${Group}!=${TempGroupCount}) /return
/varset TempIndex ${Math.Calc[${b}-${Group}]}
/if (${b}>${Group}) {
/if (!${WatchList[${TempIndex}].Equal[Empty]}) {
/if (${Spawn[${WatchList[${TempIndex}]}].ID}) {
/if (${Spawn[${WatchList[${TempIndex}]}].Distance}<250) {
/if (${Math.Calc[${Macro.RunTime}]}>${WatchTimer[${TempIndex}]}) {
/if (${Target.ID}!=${Spawn[${WatchList[${TempIndex}]}].ID}) {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].ID}
}
/if (${Spawn[${WatchList[${TempIndex}]}].Pet.ID}>0 && ${HealPets}==1) {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
}
/varset WatchTimer[${Math.Calc[${TempIndex}]}+1]}] ${Math.Calc[${Macro.RunTime}+2]}
}
}
}
}
}
/varset RetryHealCount 0
/if (${Math.Calc[${Group}+1]}<${HealMinGroupCount[${a}]}) /goto :BreakOutHeal
/varset TempTargetType ${Spell[${HealSpellID[${a}]}].TargetType}
/if ((${TempTargetType.Find["Group"]})||(${HealMinGroupCount[${a}]}>0)) {
/if (${b}<=${Group}) {
/if (${Group[${b}].ID}>0) /varset GroupHPTotal ${Math.Calc[${GroupHPTotal}+${Group[${b}].PctHPs}]}
/goto :BreakOutHoT
} else {
/goto :BreakOutHoT
}
}
/if (${b}<=${Group}) {
/varset TempClass ${Group[${b}].Class.ShortName}
/varset TempHealth ${Group[${b}].PctHPs}
/if (${String["WIZ|MAG|ENC|NEC"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+${WussyFactor}]}) /goto :ContinueHeal
} else /if (${String["SHM|CLR|DRU"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+(${WussyFactor}/2)]}) /goto :ContinueHeal
} else {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) /goto :ContinueHeal
}
/if (${HealPets}==1) {
/varset TempHealth ${Group[${b}].Pet.PctHPs}
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) {
/varset PetHealFlag 1
/goto :ContinueHealPet
}
}
} else {
/varset TempClass ${Spawn[${WatchList[${TempIndex}]}].Class.ShortName}
/varset TempHealth ${Spawn[${WatchList[${TempIndex}]}].PctHPs}
/if (${String["WIZ|MAG|ENC|NEC"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+${WussyFactor}]}) /goto :ContinueHeal
} else /if (${String["SHM|CLR|DRU"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+(${WussyFactor}/2)]}) /goto :ContinueHeal
} else {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) /goto :ContinueHeal
}
/if (${HealPets}==1) {
/varset TempHealth ${Spawn[${WatchList[${TempIndex}]}].Pet.PctHPs}
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) {
/varset PetHealFlag 1
/goto :ContinueHealPet
}
}
}
/goto :BreakOutHoT
:ContinueHeal
/call AdvPathCall
/if (!${HealClass[${a}].Find["${TempClass}"]}>0) /goto :BreakOutHoT
:ContinueHealPet
/if (${PetHealFlag}==0 && ${Math.Calc[${Macro.RunTime}]}<${HoTList[${Math.Calc[${b}+1]},1]} && ${TempTargetType.Find["Single"]}) /goto :BreakOutHoT
/if (${PetHealFlag}==1 && ${Math.Calc[${Macro.RunTime}]}<${HoTList[${Math.Calc[${b}+1]},2]} && ${TempTargetType.Find["Single"]}) /goto :BreakOutHoT
:RetryHeal
/if (${PauseHeals}==1) /return
/if (${Me.Gem[${HealSpell[${a}]}]} || ${HealSpell[${a}].Find["item"]} || ${HealSpell[${a}].Find["activate"]} || ${HealMemToSlot[${a}]}>0) {
/if (${HealSpell[${a}].Find["activate"]} && !${Me.AltAbilityReady[${HealSpell[${a}].Right[-9]}]}) /goto :BreakOutHeal
/if (!${HealSpell[${a}].Find["item"]}>0 && !${HealSpell[${a}].Find["activate"]}>0) {
/if (${Me.Gem[${HealSpell[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${HealSpell[${a}]}"]}) {
/goto :ContinueHeal2
}
/next f
/if (!${Me.SpellReady["${HealSpell[${a}]}"]}) /goto :BreakOutHeal
}
}
:ContinueHeal2
/if (${b}<=${Group} && !${Group[${b}].ID}>0) /goto :BreakOutHoT
/if (${b}>${Group} && !${Spawn[${WatchList[${TempIndex}]}].ID}>0) /goto :BreakOutHoT
/if ((${TempTargetType.Find["Group"]} || ${b}==0) && ${PetHealFlag}==0) {
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
} else /if (${b}<=${Group} && ${PetHealFlag}==0) {
/squelch /target id ${Group[${b}].ID}
/delay 1s ${Target.ID}==${Group[${b}].ID}
} else /if (${PetHealFlag}==1) {
/if (${b}<=${Group}) {
/squelch /target id ${Group[${b}].Pet.ID}
/delay 1s ${Target.ID}==${Group[${b}].Pet.ID}
} else {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
}
} else {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].ID}
}
/if (${Target.CleanName.Equal[${Group[${b}]}]}) /goto :TargetInZone
/if (${Target.CleanName.Equal[${WatchList[${TempIndex}]}]}) /goto :TargetInZone
/if (${Target.CleanName.Equal[${Group[${b}].Pet.CleanName}]}) /goto :TargetInZone
/if (${Target.CleanName.Equal[${Spawn[${WatchList[${TempIndex}]}].Pet.CleanName}]}) /goto :TargetInZone
/echo -(( Target not in zone. Waiting 10 seconds and trying again. ))-
/if (${PetHealFlag}==0) /varset HoTList[${Math.Calc[${b}+1]},1] ${Math.Calc[10+${Macro.RunTime}]}
/if (${PetHealFlag}==1) /varset HoTList[${Math.Calc[${b}+1]},2] ${Math.Calc[10+${Macro.RunTime}]}
/goto :BreakOutHoT
:TargetInZone
/if (!${HealSpell[${a}].Find[Item]} && !${HealSpell[${a}].Find[Activate]} && ${Target.Distance3D}>${Spell[${HealSpellID[${a}]}].Range}) /goto :BreakOutHoT
/if (${Announce}==1 && !${HealAnnounce[${a}].Equal["NULL"]}) {
/if (${AnnounceChannel.Length}>0) {
/if (${AnnounceChannel.Find[;]}) {
/varset TempHoldAnnounce ${AnnounceChannel}
:ParseNext
/varset ParseAnnounceChannels ${TempHoldAnnounce.Arg[1,;]}
/varset TempHoldAnnounce ${TempHoldAnnounce.Right[-${TempHoldAnnounce.Find[;]}]}
:SendIt
/if (${ParseAnnounceChannels.Equal[gsay]} && ${Group}>0) {
/gsay ${HealAnnounce[${a}]}
} else /if (!${ParseAnnounceChannels.Equal[gsay]}) {
/docommand /${ParseAnnounceChannels} ${HealAnnounce[${a}]}
}
/if (${TempHoldAnnounce.Length}>0) {
/if (${TempHoldAnnounce.Find[;]}>0) {
/goto :ParseNext
} else {
/varset ParseAnnounceChannels ${TempHoldAnnounce}
/varset TempHoldAnnounce
/goto :SendIt
}
}
} else {
/if (${AnnounceChannel.Equal[gsay]} && ${Group}>0) {
/gsay ${HealAnnounce[${a}]}
} else /if (!${AnnounceChannel.Equal[gsay]}) {
/docommand /${AnnounceChannel} ${HealAnnounce[${a}]}
}
}
}
}
/if (${Me.Sitting}) /stand
/if (${HealSpell[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Heal Spell : ${HealSpell[${a}]} ]-
/call Cast "${HealSpell[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${HealSpell[${a}].Left[8].Equal["activate"]}) {
/echo -[ Casting Heal Spell : ${HealSpell[${a}]} ]-
/call Cast "${HealSpell[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Heal Spell : ${HealSpell[${a}]} ]-
/call Cast "${HealSpell[${a}]}" "gem${HealMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset HealTimer 0
/return
}
/if (${Macro.Return.Equal["CAST_CANNOTSEE"]} || ${Macro.Return.Equal["CAST_OUTOFRANGE"]}) {
/echo -(( Out of range or cannot be seen. Waiting 10 seconds and trying again. ))-
/if (${PetHealFlag}==0) /varset HoTList[${Math.Calc[${b}+1]},1] ${Math.Calc[10+${Macro.RunTime}]}
/if (${PetHealFlag}==1) /varset HoTList[${Math.Calc[${b}+1]},2] ${Math.Calc[10+${Macro.RunTime}]}
/goto :BreakOutHoT
}
/if (${GroupHealFlag}==1) {
/delay 15
/varset GroupHealFlag 0
}
/if (${Spell[${HealSpellID[${a}]}].Duration}>0 && ${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${PetHealFlag}==0) /varset HoTList[${Math.Calc[${b}+1]},1] ${Math.Calc[${Spell[${HealSpellID[${a}]}].Duration.Seconds}+${Macro.RunTime}]}
/if (${PetHealFlag}==1) /varset HoTList[${Math.Calc[${b}+1]},2] ${Math.Calc[${Spell[${HealSpellID[${a}]}].Duration.Seconds}+${Macro.RunTime}]}
/if (${Spell[${HealSpellID[${a}]}].Duration}>0 && ${Macro.Return.Equal["CAST_SUCCESS"]} && (${TempTargetType.Find["Group"]} || ${HealMinGroupCount[${a}]}>0)) {
/for c 0 to ${Group}
/varset HoTList[${Math.Calc[${c}+1]},1] ${Math.Calc[${Spell[${HealSpellID[${a}]}].Duration.Seconds}+${Macro.RunTime}]}
/next c
/varset GroupHPTotal ${Math.Calc[100*${Math.Calc[${Group}+1]}]}
/goto :BreakOutHeal
}
}
/varset GroupHPTotal ${Math.Calc[100*${Math.Calc[${Group}+1]}]}
} else {
/if (${RetryHealCount}==0) {
/if (!${Me.SpellReady["${HealSpell[${a}]}"]}) {
/call Delay 3s
/varset RetryHealCount ${Math.Calc[${RetryHealCount}+1]}
/goto :RetryHeal
}
}
/echo -(( Heal Spell:${HealSpell[${a}]} not memmed or not ready. ))-
/goto :BreakOutHeal
}
:BreakOutHoT
/next b
/if (${TempTargetType.Find["Group"]} || ${HealMinGroupCount[${a}]}>0) {
/varset TempGrpCt 0
/for c 0 to ${Group}
/if (${Group[${c}].ID}>0) /varset TempGrpCt ${Math.Calc[${TempGrpCt}+1]}
/next c
/if (${Math.Calc[${GroupHPTotal}\${TempGrpCt}]}>${HealMinHP[${a}]} && ${Math.Calc[${GroupHPTotal}\${TempGrpCt}]}<${HealMaxHP[${a}]}) {
/for c 0 to ${Group}
/if (${Math.Calc[${Macro.RunTime}]}<${HoTList[${Math.Calc[${c}+1]},1]}) /goto :BreakOutHeal
/next c
/varset GroupHealFlag 1
/varset b 0
/goto :RetryHeal
}
}
}
:BreakOutHeal
/next a
}
/return
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
Advbot.inc
Part 1
Part 1
Code: Select all
| advbot.inc
| Include file for advbot.mac
| Version 2.01
| Date:2/1/2005 11:00am
| modified by Blackcircle7
|
| Event Slain - now ends macro
#Event Master "[MQ2] master#*#"
#Event Debuff "[MQ2] debuff#*#"
#Event Sit "[MQ2] sit#*#"
#Event SelfBuff "[MQ2] selfbuff#*#"
#Event GroupBuff "[MQ2] groupbuff#*#"
#Event Evts "[MQ2] events#*#"
#Event Heal "[MQ2] heal#*#"
#Event Pet "[MQ2] pet#*#"
#Event Exclude "[MQ2] exclude#*#"
#Event Include "[MQ2] include#*#"
#Event Announce "[MQ2] announce#*#"
#Event Reply "[MQ2] reply#*#"
#Event Watch "[MQ2] watch#*#"
#Event Assist "[MQ2] assist#*#"
#Event Cmd "[MQ2] cmd#*#"
#Event Face "[MQ2] face#*#"
#Event Buff "[MQ2] buff#*#"
#Event Invite "#*#invites you to join a group.#*#"
#Event Slain "#*#Returning to home point, please wait...#*#"
#Event DelayOnZone "#*#You have entered#*#"
#Event Enraged "#*#has become ENRAGED#*#"
Sub DebuffFunction
/if (${PauseDebuffs}==0) {
/varset PauseDebuffs 1
/echo -[ Debuffing Paused. ]-
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm not going to debuff.
} else {
/varset PauseDebuffs 0
/echo -[ Debuffing Un-Paused. ]-
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to debuff.
}
/return
Sub Loot
/declare GenFor int local
/declare MoveDelay int local
/declare LootSlot int local 1
/if (${Me.Combat}) /return
/if (!${Target.ID}) /squelch /target corpse radius 50
/if (${Target.Type.NotEqual[corpse]}) /return
/call MoveToLoc ${Target.Y} ${Target.X}
/lootn never
/loot
/varset GenFor 0
:CoreWaitLoot
/call Delay 5
/doevents chat
/varcalc GenFor ${GenFor}+1
/if (${GenFor}>12) /goto :donelooting
/if (!${Corpse.Items}) /goto :CoreWaitLoot
/delay 2s
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Looting ${Target.CleanName}.
:lootloop
/if (!${Corpse.Items}) /goto :donelooting
/doevents chat
/itemnotify loot${LootSlot} rightmouseup
/call Delay 1s
/varcalc LootSlot ${LootSlot}+1
/if (${LootSlot}>31) /varset LootSlot 1
/doevents chat
/if (${Cursor.ID}) /autoinv
/goto :lootloop
:donelooting
/lootn always
/notify LootWnd DoneButton leftmouseup
/delay 2s ${Me.Standing}
/return
Sub Event_Debuff(EvtText)
/varset EvtText ${EvtText.Right[-6]}
/if (${EvtText.Equal["debuff"]}) {
/varset SenderName nobody
/call DebuffFunction
}
/return
Sub MoveTo(MoveTarget)
/echo -[Moving]-
:MoveTar
/target pc ${MoveTarget}
/delay 1s ${Target.Name.Equal[${MoveTarget}]}
/if (${Target.Name.Equal[${MoveTarget}]}) {
/goto :Loop
} else /goto :MoveTar
:Loop
/face fast
/if (${Int[${Target.Distance}]}>20) {
/keypress forward hold
}
/if (${Int[${Target.Distance}]}<15) {
/keypress back
/return
}
/goto :Loop
Sub ManaFunction
/declare RoundMana int local ${Math.Calc[${Math.Calc[${Me.PctMana}/5].Int}*5].Int}
/if (${RoundMana}==100) {
/echo -[ full mana ]-
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} full mana
} else {
/echo -[ ${RoundMana}m ]-
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} ${RoundMana}m
}
/return
Sub EvtsFunction
/if (${PauseEvents}==0) {
/varset PauseEvents 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm not going to pay attention to hp or mana events.
/echo -[ HP/Mana events Paused. ]-
} else {
/varset PauseEvents 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to pay attention to hp or mana events.
/echo -[ HP/Mana events Unpaused. ]-
}
/return
Sub Event_Evts
/varset SenderName nobody
/call EvtsFunction
/return
Sub HealFunction(HealCmd)
/if (${Defined[HealCmd]}) {
/if (${HealCmd.Equal[pets]}) {
/if (${HealPets}==1) {
/varset HealPets 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not going to heal pets anymore.
/echo -[ Pet Healing Paused. ]-
} else {
/varset HealPets 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll heal pets.
/echo -[ Pet Healing Unpaused. ]-
}
}
/return
} else {
/if (${PauseHeals}==0) {
/varset PauseHeals 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not going to watch your health, so don't die!
/echo -[ Healing Paused. ]-
} else {
/varset PauseHeals 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'll watch you for heals.
/echo -[ Healing Unpaused. ]-
}
}
/return
Sub Event_Heal(EvtText)
/if (${EvtText.Right[-11].Length}>0) {
/varset SenderName nobody
/call HealFunction "${EvtText.Right[-11]}"
} else {
/varset SenderName nobody
/call HealFunction
}
/return
Sub PetFunction(PetCmd)
/declare f int local
/declare Reason string local
/if (${Defined[PetCmd]}) {
/if (${PetCmd.Equal[summon]}) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll summon a pet.
/echo -[ Summoning a pet. ]-
/if ((${Me.Gem[${PetSummonSpell}]})||(${PetSummonSpell.Find["item"]})||(${PetSummonSpell.Find["activate"]})||(${PetSummonMemToSlot}>0)) {
/if ((${PetSummonSpell.Find["activate"]})&&(!${Me.AltAbilityReady[${PetSummonSpell.Right[-9]}]})) {
/varset Reason Ability Not Ready
/goto :ErrorSummon
}
/if ((!${PetSummonSpell.Find["item"]}>0)&&(!${PetSummonSpell.Find["activate"]}>0)) {
/if (${Me.Gem[${PetSummonSpell}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${PetSummonSpell}"]}) {
/goto :ContinueSummon
}
/next f
/if (!${Me.SpellReady["${PetSummonSpell}"]}) {
/varset Reason Spell Not Ready
/goto :ErrorSummon
}
}
}
:ContinueSummon
/if (${Me.Sitting}) /stand
/if (${PetSummonSpell.Left[4].Equal["item"]}) {
/echo -[ Casting Pet Summon : ${PetSummonSpell}. ]-
/call Cast "${PetSummonSpell.Right[-5]}" "item" "nocheck"
} else /if (${PetSummonSpell.Left[8].Equal["activate"]}) {
/echo -[ Casting Pet Summon : ${PetSummonSpell}. ]-
/call Cast "${PetSummonSpell.Right[-9]}" "activate" "nocheck"
} else {
/echo -[ Casting Pet Summon : ${PetSummonSpell}. ]-
/call Cast "${PetSummonSpell}" "gem${PetSummonMemToSlot}" "nocheck"
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/echo -(( Cast took too long, aborting. ))-
/varset Reason Cast Took Too Long
/goto :ErrorSummon
}
} else {
/varset Reason Unknown Error
/goto :ErrorSummon
}
} else {
/pet ${PetCmd}
}
/return
:ErrorSummon
/delay 15
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Couldn't summon pet because ${Reason}.
/echo -(( Couldn't Summon Pet - Reason:${Reason}. ))-
} else {
/if (${PausePet}==0) {
/varset PausePet 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm not going to have my pet assist you.
/echo -[ Pet Assisting Paused. ]-
} else {
/varset PausePet 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to have my pet assist you.
/echo -[ Pet Assisting Unpaused. ]-
}
}
/return
Sub Event_Pet(EvtText)
/if (${EvtText.Right[-10].Length}>0) {
/varset SenderName nobody
/call PetFunction "${EvtText.Right[-10]}"
} else {
/varset SenderName nobody
/call PetFunction
}
/return
Sub CmdFunction(CmdStr)
/if (${Defined[CmdStr]}) {
/if (${CmdStr.Length}>0) {
/docommand /${CmdStr}
}
}
/return
Sub Event_Invite(EvtText)
/declare TempVar int local
/varset TempVar 0
:CheckAuth
/if (!${MasterList[${TempVar}].Equal["UNDEFINED-ARRAY-ELEMENT"]}) {
/if (${MasterList[${TempVar}].Equal["${EvtText.Arg[1]}"]}) {
/invite
/return
}
/varset TempVar ${Math.Calc[${TempVar}+1]}
/goto :CheckAuth
}
/return
Sub Event_Cmd(EvtText)
/if (${EvtText.Right[-10].Length}>0) {
/varset SenderName nobody
/call CmdFunction "${EvtText.Right[-10]}"
}
/return
Sub AssistFunction(TankNm)
/if (${Defined[TankNm]}) {
/varset TankName ${TankNm}
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm going to assist ${TankName} while we are fighting.
/echo -[ Assisting ${TankName} During Combat. ]-
} else {
/if (${PauseAssist}==0) {
/varset PauseAssist 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not going to assist the tank while we are fighting.
/echo -[ Assisting Paused. ]-
} else {
/varset PauseAssist 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'll assist the tank while we are fighting.
/echo -[ Assisting Unpaused. ]-
}
}
/return
Sub Event_Assist(EvtText)
/if (${EvtText.Arg[3].Length}>0) {
/varset SenderName nobody
/call AssistFunction "${EvtText.Arg[3]}"
} else {
/varset SenderName nobody
/call AssistFunction
}
/return
Sub ReplyFunction
/if (${Reply}==0) {
/varset Reply 1
/echo ${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm going to reply.
/if (!${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm going to reply.
/echo -[ Replies turned ON. ]-
} else {
/varset Reply 0
/if (!${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not going to reply.
/echo -[ Replies turned OFF. ]-
}
/return
Sub Event_Reply(EvtText)
/varset SenderName nobody
/call ReplyFunction
/return
Sub AnnounceFunction
/if (${Announce}==0) {
/varset Announce 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm going to tell people what I'm doing.
/echo -[ Announcements turned ON. ]-
} else {
/varset Announce 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not going to bother telling people what I'm doing.
/echo -[ Announcements turned OFF. ]-
}
/return
Sub Event_Announce(EvtText)
/varset SenderName nobody
/call AnnounceFunction
/return
Sub FaceFunction
/if (${FaceBeforeDebuff}==0) {
/varset FaceBeforeDebuff 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not going to bother looking at mobs when I debuff them.
/echo -[ Facing before debuffs turned ON. ]-
} else {
/varset FaceBeforeDebuff 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'll look at mobs when I debuff them.
/echo -[ Facing before debuffs turned OFF. ]-
}
/return
Sub Event_Face
/varset SenderName nobody
/call FaceFunction
/return
Sub SelfBuffFunction(CmdText)
/declare a int local
/declare b int local
/declare c int local
/declare TempIndex int local
/declare TempIndex2 int local
/if (${SelfBuffCount}>0) {
/if (${CmdText.Equal["selfbuff"]}) {
/if (${PauseSelfBuffs}==0) {
/varset PauseSelfBuffs 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm not going to self buff.
/echo -[ Self Buffs Paused. ]-
} else {
/varset PauseSelfBuffs 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to self buff.
/echo -[ Self Buffs Unpaused. ]-
}
} else /if (${CmdText.Right[-9].Equal["all"]}) {
/for a 1 to ${SelfBuffCount}
/varset SelfBuffedList[${a}] 0
/next a
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll totally buff myself.
/echo -[ Self Buffing with all buffs. ]-
} else {
/for b 1 to 8
/if (${CmdText.Arg[2].Equal["${b}"]}) {
/if ((${CmdText.Arg[2]}>0)&&(${CmdText.Arg[2]}<${Math.Calc[${SelfBuffCount}+1]})) {
/varset TempIndex ${CmdText.Arg[2]}
/if (${TempIndex}>0) {
/varset SelfBuffedList[${TempIndex}] 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff myself with ${SelfBuff[${b}]}.
/echo -[ Self Buffing with ${SelfBuff[${b}]}. ]-
}
/goto :BreakOutRebuff
}
}
/next b
:LookUpAlias
/varset TempIndex2 0
/for c 1 to 8
/if (${SelfBuffAliasName[${c}].Equal[${CmdText.Arg[2]}]}) /varset TempIndex2 ${c}
/next c
/if ((${TempIndex2}>0)&&(${TempIndex2}<${Math.Calc[${SelfBuffCount}+1]})) {
/varset TempIndex ${TempIndex2}
/if (${TempIndex}>0) {
/varset SelfBuffedList[${TempIndex}] 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff myself with ${SelfBuff[${TempIndex}]}.
/echo -[ Self Buffing with ${SelfBuff[${TempIndex}]}. ]-
}
}
:BreakOutRebuff
}
}
/return
Sub Event_Slain
/echo -(( Death detected ))-
/keypress forward
/keypress back
/end
/return
Sub Event_SelfBuff(EvtText)
/varset EvtText ${EvtText.Right[-6]}
/varset SenderName nobody
/call SelfBuffFunction "${EvtText}"
/return
Sub BuffFunction(CmdText)
/declare a int local
/declare b int local
/declare c int local
/declare f int local
/declare Reason string local
/declare TempIndex int local
/declare TempIndex2 string local
/declare PlayerID int local
/declare BuffPlayerName string local
/if (!${CmdText.Arg[3].Length}>0) {
/varset Reason You didn't give a name
/goto :ErrorBuff
}
/varset BuffPlayerName ${CmdText.Right[-5]}
/varset BuffPlayerName ${BuffPlayerName.Mid[${BuffPlayerName.Find[" "]},${BuffPlayerName.Length}]}
/varset PlayerID ${NearestSpawn[1,pc ${BuffPlayerName}].ID}
/if (!${PlayerID}>0) /varset PlayerID ${NearestSpawn[1,pet ${BuffPlayerName}].ID}
/if (!${PlayerID}>0) {
/varset Reason I don't see them around
/goto :ErrorBuff
}
/if (${GroupBuffCount}>0) {
/if (${CmdText.Right[-5].Arg[2].Length}>0) {
/varset TempIndex2 0
/for c 1 to 8
/if (${GroupBuffAliasName[${c}].Equal[${CmdText.Arg[2]}]}) /varset TempIndex2 ${c}
/next c
/if (${TempIndex2.Equal[0]}) /varset TempIndex2 ${CmdText.Arg[2]}
/for a 1 to 8
/if (${TempIndex2.Equal["${Int[${a}]}"]}) {
/if ((${Int[${TempIndex2}]}>0)&&(${Int[${TempIndex2}]}<${Math.Calc[${GroupBuffCount}+1]})) {
/if (${PlayerID}>0 && ${Spawn[${PlayerID}].Distance}<85) {
/varset TempIndex ${TempIndex2}
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff ${BuffPlayerName} with ${GroupBuff[${a}]}.
/echo -[ Buffing ${BuffPlayerName} with ${GroupBuff[${a}]}. ]-
/if ((${Me.Gem[${GroupBuff[${a}]}]})||(${GroupBuff[${a}].Find["item"]})||(${GroupBuff[${a}].Find["activate"]})||(${GroupBuffMemToSlot[${a}]}>0)) {
/if ((${GroupBuff[${a}].Find["activate"]})&&(!${Me.AltAbilityReady[${GroupBuff[${a}].Right[-9]}]})) {
/varset Reason Ability Not Ready
/goto :ErrorBuff
}
/if ((!${GroupBuff[${a}].Find["item"]}>0)&&(!${GroupBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${GroupBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/goto :ContinueGroupBuff
}
/next f
/if (!${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/varset Reason Spell Not Ready
/goto :ErrorBuff
}
}
}
:ContinueGroupBuff
/if (${Me.ID}!=${PlayerID}) {
/squelch /target id ${PlayerID}
} else {
/squelch /target myself
}
/delay 1s ${Target.ID}==${PlayerID}
/if (!${Target.CleanName.Equal[${BuffPlayerName}]}) {
/varset Reason Can't target ${BuffPlayerName}
/goto :ErrorBuff
}
/if (${Me.Sitting}) /stand
/if (${GroupBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Buff : ${GroupBuff[${a}]} on ${BuffPlayerName}. ]-
/call Cast "${GroupBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${GroupBuff[${a}].Left[8].Equal["activate"]}) {
/echo -[ Casting Buff : ${GroupBuff[${a}]} on ${BuffPlayerName}. ]-
/call Cast "${GroupBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Buff : ${GroupBuff[${a}]} on ${BuffPlayerName}. ]-
/call Cast "${GroupBuff[${a}]}" "gem${GroupBuffMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]} || ${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/echo -(( Cast took too long or lost target, aborting. ))-
/varset Reason Cast Took Too Long or Lost Target
/goto :ErrorBuff
}
/if ((${Macro.Return.Equal["CAST_CANNOTSEE"]})||(${Macro.Return.Equal["CAST_OUTOFRANGE"]})) {
/echo -(( Out of range or cannot be seen, aborting. ))-
/varset Reason Target Out of Range
/goto :ErrorBuff
}
} else {
/varset Reason Unknown Error
/goto :ErrorBuff
}
/goto :BreakOutRebuff1
} else {
/varset Reason Target Not in Zone or too far away
/goto :ErrorBuff
}
}
}
/next a
/if (${CmdText.Arg[2].Equal[all]}) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, buffing ${BuffPlayerName} with every buff.
/echo -[ Buffing Target ${BuffPlayerName} with all group buffs. ]-
/for a 1 to ${GroupBuffCount}
/if (${PlayerID}>0 && ${Spawn[${PlayerID}].Distance}<85) {
/varset TempIndex ${CmdText.Arg[2]}
/echo -[ Buffing ${BuffPlayerName} with ${GroupBuff[${a}]}. ]-
/if ((${Me.Gem[${GroupBuff[${a}]}]})||(${GroupBuff[${a}].Find["item"]})||(${GroupBuff[${a}].Find["activate"]})||(${GroupBuffMemToSlot[${a}]}>0)) {
/if ((${GroupBuff[${a}].Find["activate"]})&&(!${Me.AltAbilityReady[${GroupBuff[${a}].Right[-9]}]})) {
/varset Reason Ability Not Ready
/goto :ErrorBuff
}
/if ((!${GroupBuff[${a}].Find["item"]}>0)&&(!${GroupBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${GroupBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/goto :ContinueGroupBuff2
}
/next f
/if (!${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/varset Reason Spell Not Ready
/goto :ErrorBuff
}
}
}
:ContinueGroupBuff2
/if (${Me.ID}!=${PlayerID}) {
/squelch /target id ${PlayerID}
} else {
/squelch /target myself
}
/delay 1s ${Target.ID}==${PlayerID}
/if (!${Target.CleanName.Equal[${BuffPlayerName}]}) {
/varset Reason Can't target ${BuffPlayerName}
/goto :ErrorBuff
}
/if (${Me.Sitting}) /stand
/if (${GroupBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Buff : ${GroupBuff[${a}]} on ${BuffPlayerName}. ]-
/call Cast "${GroupBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${GroupBuff[${a}].Left[8].Equal["activate"]}) {
/echo -[ Casting Buff : ${GroupBuff[${a}]} on ${BuffPlayerName}. ]-
/call Cast "${GroupBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Buff : ${GroupBuff[${a}]} on ${BuffPlayerName}. ]-
/call Cast "${GroupBuff[${a}]}" "gem${GroupBuffMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/echo -(( Cast took too long, aborting. ))-
/varset Reason Cast Took Too Long
/goto :ErrorBuff
}
/if ((${Macro.Return.Equal["CAST_CANNOTSEE"]})||(${Macro.Return.Equal["CAST_OUTOFRANGE"]})) {
/echo -(( Out of range or cannot be seen, aborting. ))-
/varset Reason Target Out of Range
/goto :ErrorBuff
}
} else {
/varset Reason Unknown Error
/goto :ErrorBuff
}
} else {
/varset Reason Target Not in Zone or too far away
/goto :ErrorBuff
}
/next a
/goto :BreakOutRebuff1
} else {
/goto :ErrorBuff
}
}
:ErrorBuff
/delay 15
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Couldn't buff ${BuffPlayerName} because ${Reason}.
/echo -(( Couldn't buff ${BuffPlayerName} Reason:${Reason}. ))-
}
}
:BreakOutRebuff1
/return
Sub Event_Buff(EvtText)
/varset EvtText ${EvtText.Right[-6]}
/varset SenderName nobody
/call BuffFunction "${EvtText}"
/return
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
Advbot.inc
Part 2
Part 2
Code: Select all
Sub GroupBuffFunction(CmdText)
/declare a int local
/declare b int local
/declare c int local
/declare TempIndex int local
/declare TempIndex2 int local
/if (${GroupBuffCount}>0) {
/if (${CmdText.Equal["groupbuff"]}) {
/if (${PauseGroupBuffs}==0) {
/varset PauseGroupBuffs 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm not going to group buff.
/echo -[ Group Buffs Paused. ]-
} else {
/varset PauseGroupBuffs 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to group buff.
/echo -[ Group Buffs Unpaused. ]-
}
} else /if (${CmdText.Right[-10].Equal["all"]}) {
/for a 1 to ${GroupBuffCount}
/for b 1 to 6
/if (${Spell[${GroupBuffID[${a}]}].TargetType.Find["Group"]}) {
/varset GBL[${a},${b}] 99999
/if (${b}==1) /varset GBL[${a},${b}] 0
} else {
/varset GBL[${a},${b}] 0
}
/next b
/next a
/echo -[ Group Buffing with all buffs. ]-
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll totally buff everyone.
} else /if (${CmdText.Right[-10].Arg[2].Length}>0) {
/for a 1 to 8
/if (${CmdText.Arg[2].Equal["${Int[${a}]}"]}) {
/if ((${CmdText.Arg[2]}>0)&&(${CmdText.Arg[2]}<${Math.Calc[${GroupBuffCount}+1]})) {
/for b 1 to 6
/if (${Group[${Math.Calc[${b}-1]}].Name.Equal[${CmdText.Arg[3]}]} || ${String[${b}].Equal[${CmdText.Arg[3]}]}) {
/varset TempIndex ${CmdText.Arg[2]}
/if (!${Spell[${GroupBuffID[${TempIndex}]}].TargetType.Find["Group"]}>0) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff ${Group[${Math.Calc[${b}-1]}].CleanName} with ${GroupBuff[${a}]}.
/echo -[ Group Buffing ${Group[${Math.Calc[${b}-1]}].CleanName} with ${GroupBuff[${a}]}. ]-
/varset GBL[${TempIndex},${b}] 0
} else {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Sorry, thats a group buff.
/echo -(( Buff requested is a group based buff, not a single target buff. ))-
}
}
/next b
/goto :BreakOutRebuff1
}
} else /if (${CmdText.Arg[2].Equal[all]}) {
/for b 1 to 6
/if (${Group[${Math.Calc[${b}-1]}].Name.Equal[${CmdText.Arg[3]}]} || ${String[${b}].Equal[${CmdText.Arg[3]}]}) {
/varset TempIndex ${a}
/if (!${Spell[${GroupBuffID[${TempIndex}]}].TargetType.Find["Group"]}>0) {
/varset GBL[${TempIndex},${b}] 0
} else {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Sorry, thats a group buff.
/echo -(( Buff requested is a group based buff, not a single target buff. ))-
}
}
/next b
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff ${Group[${Math.Calc[${b}-1]}].CleanName} with every buff.
/echo -[ Group Buffing ${Group[${Math.Calc[${b}-1]}].CleanName} with every buff. ]-
}
/next a
/if (${a}>8) /goto :LookUpAlias
/goto :BreakOutRebuff1
:LookUpAlias
/varset TempIndex2 0
/for c 1 to 8
/if (${GroupBuffAliasName[${c}].Equal[${CmdText.Arg[2]}]}) /varset TempIndex2 ${c}
/next c
/if ((${TempIndex2}>0)&&(${TempIndex2}<${Math.Calc[${GroupBuffCount}+1]})) {
/for b 1 to 6
/if (${Group[${Math.Calc[${b}-1]}].Name.Equal[${CmdText.Arg[3]}]} || ${String[${b}].Equal[${CmdText.Arg[3]}]}) {
/varset TempIndex ${TempIndex2}
/if (!${Spell[${GroupBuffID[${TempIndex}]}].TargetType.Find["Group"]}>0) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff ${Group[${Math.Calc[${b}-1]}].CleanName} with ${GroupBuff[${TempIndex}]}.
/echo -[ Group Buffing ${Group[${Math.Calc[${b}-1]}].CleanName} with ${GroupBuff[${TempIndex}]}. ]-
/varset GBL[${TempIndex},${b}] 0
} else {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Sorry, thats a group buff.
/echo -(( Buff requested is a group based buff, not a single target buff. ))-
}
}
/next b
/goto :BreakOutRebuff1
}
:BreakOutRebuff1
} else {
/for a 1 to 8
/if (${CmdText.Arg[2].Equal["${Int[${a}]}"]}) {
/if ((${CmdText.Arg[2]}>0)&&(${CmdText.Arg[2]}<${Math.Calc[${GroupBuffCount}+1]})) {
/for b 1 to 6
/varset TempIndex ${CmdText.Arg[2]}
/if (${Spell[${GroupBuffID[${TempIndex}]}].TargetType.Find["Group"]}) {
/varset GBL[${TempIndex},${b}] 99999
/if (${b}==1) /varset GBL[${TempIndex},${b}] 0
} else {
/varset GBL[${TempIndex},${b}] 0
}
/next b
/goto :BreakOutRebuff2
}
}
/next a
/if (${a}>8) /goto :LookUpAlias2
:BreakOutRebuff2
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff everyone with ${GroupBuff[${a}]}.
/echo -[ Group Buffing everyone with ${GroupBuff[${a}]}. ]-
/return
:LookUpAlias2
/varset TempIndex2 0
/for c 1 to 8
/if (${GroupBuffAliasName[${c}].Equal[${CmdText.Arg[2]}]}) /varset TempIndex2 ${c}
/next c
/if (${TempIndex2}==0) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I couldn't find that buff.
/echo -(( Group Buff: ${CmdText.Arg[2]} could not be found. ))-
/return
}
/if ((${TempIndex2}>0)&&(${TempIndex2}<${Math.Calc[${GroupBuffCount}+1]})) {
/for b 1 to 6
/varset TempIndex ${TempIndex2}
/if (${Spell[${GroupBuffID[${TempIndex}]}].TargetType.Find["Group"]}) {
/varset GBL[${TempIndex},${b}] 99999
/if (${b}==1) /varset GBL[${TempIndex},${b}] 0
} else {
/varset GBL[${TempIndex},${b}] 0
}
/next b
}
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll buff everyone with ${GroupBuff[${TempIndex}]}.
/echo -[ Group Buffing everyone with ${GroupBuff[${TempIndex}]}. ]-
}
}
/return
Sub Event_GroupBuff(EvtText)
/varset EvtText ${EvtText.Right[-6]}
/varset SenderName nobody
/call GroupBuffFunction "${EvtText}"
/return
Sub Event_Exclude(EvtText)
/varset EvtText ${EvtText.Right[-14]}
/if (${EvtText.Length}>0) {
/varset SenderName nobody
/call AddExclude "${EvtText}"
}
/return
Sub Event_Include(EvtText)
/varset EvtText ${EvtText.Right[-14]}
/if (${EvtText.Length}>0) {
/varset SenderName nobody
/call DelExclude "${EvtText}"
}
/return
Sub Event_Enraged(EvtText)
/if (${PausePet}==0) {
/assist ${Me.Pet.CleanName}
/delay 6
/attack off
/if (${Target.CleanName.Find[${EvtText.Mid[1,${Math.Calc[${EvtText.Find[ has become ENRAGED]}-1]}]}]}>0) {
/pet back off
/delay 5
/pet back off
/varset PetCheckTimer 20s
}
}
/return
Sub SitFunction
/if (${NoSit}==0) {
/if (${Me.Sitting}) /stand
/varset NoSit 1
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'll just stay standing for now.
/echo -[ You will no longer sit during idle time. ]-
} else {
/varset NoSit 0
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'll sit when I'm not busy with things.
/echo -[ You will now sit during idle time. ]-
}
/return
Sub Event_Sit
/varset SenderName nobody
/call SitFunction
/return
Sub LoadWatchList
/declare TempVar int local
/declare a int local
/declare b string local
/for a 1 to 10
/varset WatchList[${a}] Empty
/varset HoTList[${a},1] 0
/varset HoTList[${a},2] 0
/next a
/varset TempVar 1
/varset WatchListCount 0
:LoadWatch
/varset b ${Ini[${IniFile},Watch,${Int[${TempVar}]},NOTFOUND]}
/if ((${WatchListCount}>10)||(${b.Equal["NOTFOUND"]})) {
/return
}
/if (!${b.Equal[Empty]}) {
/varset WatchListCount ${Math.Calc[${WatchListCount}+1]}
/varset WatchList[${WatchListCount}] ${b}
}
/varset TempVar ${Math.Calc[${TempVar}+1]}
/goto :LoadWatch
/return
Sub LoadMasterList
/declare TempVar int local
/declare TempList string local
/varset TempVar 0
:ClearMasters
/varset TempList ${Ini[${IniFile},Masters,${Int[${TempVar}]},NOTFOUND]}
/if (${TempList.Equal["NOTFOUND"]}) /goto :DoneClearMasters
/varset MasterList[${Math.Calc[${TempVar}+1]}] Empty
/varset TempVar ${Math.Calc[${TempVar}+1]}
/goto :ClearMasters
:DoneClearMasters
/varset TempVar 0
:LoadMasters
/varset MasterList[${Math.Calc[${TempVar}+1]}] ${Ini[${IniFile},Masters,${Int[${TempVar}]},NOTFOUND]}
/if (${MasterList[${Math.Calc[${TempVar}+1]}].Equal["NOTFOUND"]}) /return
/varset TempVar ${Math.Calc[${TempVar}+1]}
/goto :LoadMasters
/return
Sub AddExclude(ExcludeName)
/declare Category string local
/declare EachExclude int local
/declare Exclude string local
/declare BlankExclude int local
/varset BlankExclude 0
/varset Category Excludes
/varset EachExclude 0
:NextExclude1
/varset Exclude ${Ini[${IniFile},${Category},exclude_${Int[${EachExclude}]},NOTFOUND]}
/if (${Exclude.Find["NOTFOUND"]}) {
/goto :IniParsed
}
/if (${Exclude.Find["NONE"]}) {
/varset BlankExclude ${EachExclude}
}
/if (${Exclude.Find["${ExcludeName}"]}) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Yeah, I'm ignoring ${ExcludeName} already.
/echo -(( ${ExcludeName} already on Exclude List ))-
/return
}
/varset EachExclude ${Math.Calc[${EachExclude}+1]}
/goto :NextExclude1
:IniParsed
/if (${BlankExclude}==0) {
/ini ${IniFile} "${Category}" exclude_${Int[${EachExclude}]} "${ExcludeName}"
} else {
/ini ${IniFile} "${Category}" exclude_${Int[${BlankExclude}]} "${ExcludeName}"
}
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to ignore ${ExcludeName}.
/echo -[ Added ${ExcludeName} to the exclusions list. ]-
/alert add ${AlertList} NPC "${ExcludeName}"
/return
Sub LoadExcludes
/declare Category string local
/declare EachExclude int local
/declare Exclude string local
/varset Category Excludes
/alert clear ${AlertList}
/alert add ${AlertList} advbot.mac
/alert add ${AlertList} NPC "eye of "
/if (${String["${Ini[${IniFile},${Category},-1,NOTFOUND]}"].Find["NOTFOUND"]}) {
/echo -(( No Exclude list exists. ))-
/return
}
/varset EachExclude 0
:NextExclude2
/varset Exclude ${Ini[${IniFile},${Category},exclude_${Int[${EachExclude}]},NOTFOUND]}
/if (${Exclude.Equal["NOTFOUND"]}) {
/return
}
/if (${Exclude.Find["NONE"]}) {
} else {
/alert add ${AlertList} NPC "${Exclude}"
}
/varset EachExclude ${Math.Calc[${EachExclude}+1]}
/goto :NextExclude2
/return
Sub DelExclude(ExcludeName)
/declare Category string local
/declare EachExclude int local
/declare Exclude string local
/varset Category Excludes
/if (${String["${Ini[${IniFile},${Category},-1,NOTFOUND]}"].Find["NOTFOUND"]}) {
/echo -(( No Exclude list exists. ))-
/return
}
/varset EachExclude 0
:NextExclude3
/varset Exclude ${Ini[${IniFile},${Category},exclude_${Int[${EachExclude}]},NOTFOUND]}
/if (${Exclude.Find["NOTFOUND"]}) {
/call LoadExcludes
/return
}
/if (${Exclude.Find["${ExcludeName}"]}) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm not going to ignore ${ExcludeName} any more.
/echo -[ Removed ${ExcludeName} from the exclusions list. ]-
/ini ${IniFile} "${Category}" exclude_${Int[${EachExclude}]} NONE
}
/varset EachExclude ${Math.Calc[${EachExclude}+1]}
/goto :NextExclude3
/return
Sub SetupADVars
/declare VarNpcCount int outer 0
/declare DebuffCount int outer
/declare SelfBuffCount int outer
/declare Radius int outer
/declare ZoneName string outer
/declare TrackNumber int outer
/declare PauseAssist int outer
/declare MobList[51] int outer
/declare MDL[51,10] int outer
/declare SelfBuff[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare SelfBuffAliasName[8] string outer
/declare SelfBuffID[8] int outer 0
/declare SelfBuffDuration[8] int outer
/declare SelfBuffedList[8] int outer
/declare SelfBuffAtStart[8] int outer
/declare SelfBuffIconCheck[8] int outer
/declare SelfBuffIconName[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare SelfBuffMemToSlot[8] int outer
/declare SelfBuffTimer timer outer 0
/declare SelfBuffCheckTime string outer
/declare Debuff[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare DebuffID[8] int outer 0
/declare DebuffDuration[8] int outer
/declare DebuffStartWait[8] int outer
/declare DebuffMinHealth[8] int outer
/declare DebuffMinMana[8] int outer
/declare DebuffMinHealthNoCast[8] int outer
/declare DebuffMinMobsInArea[8] int outer
/declare DebuffMemToSlot[8] int outer
/declare DebuffOnMATarget[8] int outer
/declare DebuffTimer timer outer 0
/declare DebuffCheckTime string outer
/declare EventCount int outer
/declare EventMinMana[8] int outer
/declare EventMaxMana[8] int outer
/declare EventMinHP[8] int outer
/declare EventMaxHP[8] int outer
/declare EventList[8] int outer
/declare EventDuration[8] int outer
/declare EventSpell[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare EventSpellID[8] int outer 0
/declare EventMemToSlot[8] int outer
/declare EventTimer timer outer 0
/declare EventCheckTime string outer
/declare MasterList[100] string outer UNDEFINED-ARRAY-ELEMENT
/declare RetryCount int outer
/declare IniFile string outer
/declare PauseDebuffs int outer
/declare NoSit int outer
/declare PauseEvents int outer
/declare HealCount int outer
/declare HealSpell[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare HealSpellID[8] int outer 0
/declare HealMinHP[8] int outer
/declare HealMaxHP[8] int outer
/declare HealMinMana[8] int outer
/declare HealMinGroupCount[8] int outer
/declare HealClass[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare HealAnnounce[8] string outer
/declare HealMemToSlot[8] int outer
/declare HealTimer timer outer 0
/declare HealCheckTime string outer
/declare HealPets int outer 0
/declare WussyFactor int outer 10
/declare PauseHeals int outer
/declare HoTList[20,2] int outer 0
/declare MobAnnounced[51,10] int outer
/declare DebuffAnnounce[8] string outer
/declare Announce int outer
/declare AnnounceChannel string outer
/declare GroupBuffCount int outer
/declare GroupBuff[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare GroupBuffAliasName[8] string outer
/declare GroupBuffID[8] int outer 0
/declare GroupBuffDuration[8] int outer
/declare GroupBuffAtStart[8] int outer
/declare GroupBuffMinMana[8] int outer
/declare GroupBuffMinGroupCount[8] int outer
/declare GroupBuffMemToSlot[8] int outer
/declare GroupBuffTimer timer outer 0
/declare GroupBuffCheckTime string outer
/declare GBL[9,20] int outer
/declare GroupBuffAnnounce[8] string outer
/declare GroupBuffClass[8] string outer UNDEFINED-ARRAY-ELEMENT
/declare WatchList[11] string outer UNDEFINED-ARRAY-ELEMENT
/declare WatchListCount int outer 0
/declare WatchTimer[20] int outer
/declare GroupCount int outer
/varset GroupCount 0
/declare AlertList int outer
/varset AlertList 20
/declare PauseSelfBuffs int outer
/declare PauseGroupBuffs int outer
/declare PausePet int outer
/declare PetAssistOnHPPct int outer 98
/declare TankName string outer Main Assist Name
/declare PetCheckTimer timer outer 0
/declare PetBuffCheckTimer timer outer 0
/declare PetCheckTime string outer
/declare PetBuffCheckTime string outer
/declare PetBuff[8] string outer
/declare PetBuffIconName[8] string outer
/declare PetBuffCount int outer
/declare PetBuffMemToSlot[8] int outer
/declare PetSummonSpell string outer
/declare PetSummonMemToSlot int outer
/declare FaceBeforeDebuff int outer 1
/declare MiscCheckTimer timer outer 0
/declare SenderName string outer nobody
/declare Reply int outer
/declare ReplyChannel string outer
/declare Dismount string outer nodismount
/declare BotFollowDistance int outer 10
/declare SitCheckTimer timer outer 0
/declare SitAggroRadiusCheck int outer 75
/return
Sub Startup
/declare a int local
/declare b int local
/declare c int local
/call LoadINIVals
/call LoadExcludes
/call DistanceFunction ${BotFollowDistance}
/for a 1 to ${TrackNumber}
/varset MobList[${a}] 0
/for b 1 to ${DebuffCount}
/varset MDL[${a},${b}] 0
/varset MobAnnounced[${a},${b}] 0
/next b
/next a
/for a 1 to ${SelfBuffCount}
/if (${SelfBuffAtStart[${a}]}==1) {
/varset SelfBuffedList[${a}] 0
} else {
/if (${SelfBuffedList[${a}]}==12345) {
/if (${Me.Buff["${SelfBuffIconName[${a}]}"].Name.Length}>0) {
/varset SelfBuffedList[${a}] ${Me.Buff["${SelfBuffIconName[${a}]}"].Duration.TotalSeconds}
} else {
/varset SelfBuffedList[${a}] 0
}
} else {
/varset SelfBuffedList[${a}] 99999
}
}
/next a
/for a 1 to ${GroupBuffCount}
/for b 0 to 5
/if (${GroupBuffAtStart[${a}]}==1) {
/varset GBL[${a},${Math.Calc[${b}+1]}] 0
} else {
/varset GBL[${a},${Math.Calc[${b}+1]}] 99999
}
/next b
/next a
/for a 1 to ${EventCount}
/varset EventList[${a}] 0
/next a
/for a 1 to 16
/varset HoTList[${a},1] 0
/varset HoTList[${a},2] 0
/varset WatchTimer[${a}] 0
/next a
/for a 1 to 10
/varset WatchList[${a}] Empty
/next a
/varset ZoneName ${Zone.Name}
/if (${PauseDebuffs}==1) {
/echo -[ Debuffing Paused. ]-
}
/if (${FaceBeforeDebuff}==1) {
/echo -[ Facing before debuffs turned ON. ]-
}
/if (${PauseEvents}==1) {
/echo -[ HP and Mana Events Paused. ]-
}
/if (${PauseHeals}==1) {
/echo -[ Healing Paused. ]-
}
/if (${Announce}==0) {
/echo -[ Announcements OFF. ]-
}
/if (${PauseSelfBuffs}==1) {
/echo -[ Self Buffs Paused. ]-
}
/if (${PauseGroupBuffs}==1) {
/echo -[ Group Buffs Paused. ]-
}
/if (${PausePet}==0) {
/echo -[ Pet assisting un-paused. ]-
}
/if (${PauseAssist}==0) {
/echo -[ Assisting un-paused${If[!${TankName.Equal[Main Assist Name]}, you will be assisting ${TankName},]}. ]-
}
/call LoadMasterList
/call MasterFunction "master"
/call LoadWatchList
/call WatchFunction "watch"
/doevents flush
/return
Sub Event_DelayOnZone
/varset HealTimer 8s
/return
Sub Event_chat(MsgType,MsgFrom,MsgText)
/declare TempVar int local
/varset TempVar 0
/if (${MsgType.Equal[TELL]} && !${MsgFrom.Equal[Evilmd]}) {
|/if (${MsgType.Equal[TELL]} && !${MasterList[${TempVar}].Equal[${MsgFrom}]}) {
/varset SenderName ${MsgFrom}
|/if (${Spawn[npc ${MsgFrom} radius 100].ID}) /return
/if (${MsgFrom.Equal[Evilmd]}) /return
|/tell ${MasterList[${TempVar}]} ${MsgFrom} told me: ${MsgText}
|/tell evilmd ${MsgFrom} told me: ${MsgText}
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} ${MsgFrom} told me: ${MsgText}
/return
}
:CheckAuth
/if (!${MasterList[${TempVar}].Equal["UNDEFINED-ARRAY-ELEMENT"]}) {
/if (${MasterList[${TempVar}].Equal["${MsgFrom}"]}) {
/varset SenderName ${MsgFrom}
/if (${MsgText.Equal["debuff"]}) {
/call DebuffFunction
/return
}
/if (${MsgText.Left[6].Equal["master"]}) {
/call MasterFunction "${MsgText}"
/return
}
/if (${MsgText.Left[8].Equal["selfbuff"]}) {
/call SelfBuffFunction "${MsgText}"
/return
}
/if (${MsgText.Left[9].Equal["groupbuff"]}) {
/call GroupBuffFunction "${MsgText}"
/return
}
/if (${MsgText.Left[4].Equal["buff"]}) {
/call BuffFunction "${MsgText}"
/return
}
/if (${MsgText.Left[4].Equal["mana"]}) {
/call ManaFunction
/return
}
/if (${MsgText.Left[6].Equal["follow"]}) {
/if (${Me.Sitting}) /stand
/if ((${MsgText.Equal["follow me"]})||(${MsgText.Equal["follow"]})) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to follow you.
/call FollowFunction "${MsgFrom}"
} else {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to follow ${MsgText.Right[-7]}.
/call FollowFunction "${MsgText.Right[-7]}"
}
/return
}
/if (${MsgText.Left[4].Equal["goto"]}) {
/if (${Me.Sitting}) /stand
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to head to ${SenderName}}.
/call GotoFunction "${MsgText.Arg[2]}" "${MsgText.Arg[3]}"
/return
}
/if (${MsgText.Left[6].Equal["moveto"]}) {
/if (${Me.Sitting}) /stand
/if ((${MsgText.Equal["moveto me"]})||(${MsgText.Equal["moveto"]})) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to moveto you.
/call Moveto "${MsgFrom}"
} else {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to moveto ${MsgText.Right[-7]}.
/call Moveto "${MsgText.Right[-7]}"
}
/return
}
/if (${MsgText.Left[4].Equal["stop"]}) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'll just stop here.
/call StopFunction
/return
}
/if (${MsgText.Left[3].Equal["sit"]}) {
/call SitFunction
/return
}
/if (${MsgText.Left[6].Equal["events"]}) {
/call EvtsFunction
/return
}
/if (${MsgText.Left[4].Equal["loot"]}) {
/target npc corpse
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, looting.
/call Loot
/return
}
/if (${MsgText.Left[4].Equal["heal"]}) {
/if (${MsgText.Right[-5].Length}>0) {
/call HealFunction "${MsgText.Right[-5]}"
} else {
/call HealFunction
}
/return
}
/if (${MsgText.Left[4].Equal["face"]}) {
/call FaceFunction
/return
}
/if (${MsgText.Left[3].Equal["pet"]}) {
/if (${MsgText.Right[-4].Length}>0) {
/call PetFunction "${MsgText.Right[-4]}"
} else {
/call PetFunction
}
/return
}
/if (${MsgText.Left[3].Equal["cmd"]}) {
/if (${MsgText.Right[-4].Length}>0) {
/call CmdFunction "${MsgText.Right[-4]}"
}
/return
}
/if (${MsgText.Left[6].Equal["assist"]}) {
/if (${MsgText.Arg[2].Length}>0) {
/call AssistFunction "${MsgText.Arg[2]}"
} else {
/call AssistFunction
}
/return
}
/if (${MsgText.Left[7].Equal["exclude"]}) {
/call AddExclude "${MsgText.Right[-8]}"
/return
}
/if (${MsgText.Left[7].Equal["include"]}) {
/call DelExclude "${MsgText.Right[-8]}"
/return
}
/if (${MsgText.Left[5].Equal["watch"]}) {
/call WatchFunction "${MsgText}"
/return
}
/if (${MsgText.Left[8].Equal["announce"]}) {
/call AnnounceFunction
/return
}
/if (${MsgText.Left[5].Equal["reply"]}) {
/call ReplyFunction
/return
}
/if (${MsgText.Left[8].Equal["distance"]}) {
/call DistanceFunction "${MsgText.Right[-9]}"
/return
}
/if (${MsgText.Left[5].Equal["pause"]}) {
/if (${Reply}==1 && !${SenderName.Equal[nobody]} ${PauseFlag}==1) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm going to wait here. Let me know when you want me to proceed.
/if (${Reply}==1 && !${SenderName.Equal[nobody]} ${PauseFlag}==0) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I'm coming.
/call PauseFunction
/return
}
}
/varset TempVar ${Math.Calc[${TempVar}+1]}
/goto :CheckAuth
}
/return
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
Advbot2.inc
Code: Select all
|
| advbot2.inc
| Include file 2 for advbot.mac
| Version 2.01
| Date:2/1/2005 11:00am
| modified by Blackcircle7
|
Sub LoadINIVals
/declare a int local
/declare b int local
/declare INIFlag int local
/declare TempStr string local
/varset INIFlag 0
/varset TempStr ${Ini[${IniFile},Settings,Radius,NOTFOUND]}
/varset Radius ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings Radius 100
/varset Radius 100
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,NoSit,NOTFOUND]}
/varset NoSit ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings NoSit 0
/varset NoSit 0
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,TrackNumber,NOTFOUND]}
/varset TrackNumber ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings TrackNumber 10
/varset TrackNumber 10
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,Announce,NOTFOUND]}
/varset Announce ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings Announce 0
/varset Announce 0
/varset INIFlag 1
}
/varset AnnounceChannel ${Ini[${IniFile},Settings,AnnounceChannel,NOTFOUND]}
/if (${AnnounceChannel.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings AnnounceChannel gsay
/varset AnnounceChannel gsay
/varset INIFlag 1
}
| Remove this after a few weeks. This auto-upgrades the old announce INI entry.
/if (${AnnounceChannel.Equal[group]}) {
/ini "${IniFile}" Settings AnnounceChannel gsay
/varset AnnounceChannel gsay
} else /if (${AnnounceChannel.Equal[raid]}) {
/ini "${IniFile}" Settings AnnounceChannel rsay
/varset AnnounceChannel rsay
}
| Remove this after a few weeks. This auto-upgrades the old announce INI entry.
/varset TempStr ${Ini[${IniFile},Settings,Reply,NOTFOUND]}
/varset Reply ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings Reply 0
/varset Reply 0
/varset INIFlag 1
}
/varset ReplyChannel ${Ini[${IniFile},Settings,ReplyChannel,NOTFOUND]}
/if (${ReplyChannel.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings ReplyChannel "tell @"
/varset ReplyChannel tell @
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,RetryCount,NOTFOUND]}
/varset RetryCount ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings RetryCount 2
/varset RetryCount 2
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,PauseDebuffs,NOTFOUND]}
/varset PauseDebuffs ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings PauseDebuffs 1
/varset PauseDebuffs 1
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,PauseEvents,NOTFOUND]}
/varset PauseEvents ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings PauseEvents 1
/varset PauseEvents 1
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,PauseHeals,NOTFOUND]}
/varset PauseHeals ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings PauseHeals 1
/varset PauseHeals 1
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,PauseAssist,NOTFOUND]}
/varset PauseAssist ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings PauseAssist 0
/varset PauseAssist 0
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,PauseSelfBuffs,NOTFOUND]}
/varset PauseSelfBuffs ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings PauseSelfBuffs 0
/varset PauseSelfBuffs 0
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,PauseGroupBuffs,NOTFOUND]}
/varset PauseGroupBuffs ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings PauseGroupBuffs 0
/varset PauseGroupBuffs 0
/varset INIFlag 1
}
/varset TankName ${Ini[${IniFile},Settings,MainAssistName,NOTFOUND]}
/if (${TankName.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings MainAssistName "Main Assist Name"
/varset TankName Main Assist Name
/varset INIFlag 1
}
/varset Dismount ${Ini[${IniFile},Settings,Dismount,NOTFOUND]}
/if (${Dismount.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings Dismount "nodismount"
/varset Dismount nodismount
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,FollowDistance,NOTFOUND]}
/varset BotFollowDistance ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings FollowDistance 20
/varset BotFollowDistance 20
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Settings,SitAggroRadiusCheck,NOTFOUND]}
/varset SitAggroRadiusCheck ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Settings SitAggroRadiusCheck 75
/varset SitAggroRadiusCheck 75
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},SelfBuff,SelfBuffCount,NOTFOUND]}
/varset SelfBuffCount ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffCount 0
/varset SelfBuffCount 0
/varset INIFlag 1
}
/for a 1 to 8
/varset SelfBuff[${a}] ${Ini[${IniFile},SelfBuff,SelfBuff${a},NOTFOUND]}
/if (${SelfBuff[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuff${a} "Self Buff Spell Name"
/varset SelfBuff[${a}] "Self Buff Spell Name"
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset SelfBuffAliasName[${a}] ${Ini[${IniFile},SelfBuff,SelfBuffAliasName${a},NOTFOUND]}
/if (${SelfBuffAliasName[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffAliasName${a} "Self Buff Alias Name"
/varset SelfBuffAliasName[${a}] Self Buff Alias Name
/varset INIFlag 1
}
/next a
/if (${SelfBuffCount}>0) {
/for a 1 to ${SelfBuffCount}
/varset SelfBuffID[${a}] ${Spell["${SelfBuff[${a}]}"].ID}
/next a
}
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},SelfBuff,SelfBuffDuration${a},NOTFOUND]}
/varset SelfBuffDuration[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffDuration${a} 0
/varset SelfBuffDuration[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},SelfBuff,SelfBuffAtStart${a},NOTFOUND]}
/varset SelfBuffAtStart[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffAtStart${a} 0
/varset SelfBuffAtStart[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},SelfBuff,SelfBuffIconCheck${a},NOTFOUND]}
/varset SelfBuffIconCheck[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffIconCheck${a} 0
/varset SelfBuffIconCheck[${a}] 0
/varset INIFlag 1
}
/if (${SelfBuffIconCheck[${a}]}==1) {
/varset SelfBuffedList[${a}] 12345
}
/next a
/for a 1 to 8
/varset SelfBuffIconName[${a}] ${Ini[${IniFile},SelfBuff,SelfBuffIconName${a},NOTFOUND]}
/if (${SelfBuffIconName[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffIconName${a} "Self Buff Icon Name"
/varset SelfBuffIconName[${a}] Self Buff Icon Name
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},SelfBuff,SelfBuffMemToSlot${a},NOTFOUND]}
/varset SelfBuffMemToSlot[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffMemToSlot${a} 0
/varset SelfBuffMemToSlot[${a}] 0
/varset INIFlag 1
}
/next a
/varset SelfBuffCheckTime ${Ini[${IniFile},SelfBuff,SelfBuffCheckTime,NOTFOUND]}
/if (${SelfBuffCheckTime.Equal["NOTFOUND"]}) {
/ini "${IniFile}" SelfBuff SelfBuffCheckTime 15s
/varset SelfBuffCheckTime 15s
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Debuff,DebuffCount,NOTFOUND]}
/varset DebuffCount ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffCount 0
/varset DebuffCount 0
/varset INIFlag 1
}
/for a 1 to 8
/varset Debuff[${a}] ${Ini[${IniFile},Debuff,Debuff${a},NOTFOUND]}
/if (${Debuff[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff Debuff${a} "Debuff Spell Name"
/varset Debuff[${a}] Debuff Spell Name
/varset INIFlag 1
}
/next a
/if (${DebuffCount}>0) {
/for a 1 to ${DebuffCount}
/varset DebuffID[${a}] ${Spell["${Debuff[${a}]}"].ID}
/next a
}
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffDuration${a},NOTFOUND]}
/varset DebuffDuration[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffDuration${a} 99999
/varset DebuffDuration[${a}] 99999
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffStartWait${a},NOTFOUND]}
/varset DebuffStartWait[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffStartWait${a} 0
/varset DebuffStartWait[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffMinHealth${a},NOTFOUND]}
/varset DebuffMinHealth[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffMinHealth${a} 100
/varset DebuffMinHealth[${a}] 100
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffMinHealthNoCast${a},NOTFOUND]}
/varset DebuffMinHealthNoCast[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffMinHealthNoCast${a} 0
/varset DebuffMinHealthNoCast[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffMinMana${a},NOTFOUND]}
/varset DebuffMinMana[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffMinMana${a} 0
/varset DebuffMinMana[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffMinMobsInArea${a},NOTFOUND]}
/varset DebuffMinMobsInArea[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffMinMobsInArea${a} 0
/varset DebuffMinMobsInArea[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset DebuffAnnounce[${a}] ${Ini[${IniFile},Debuff,DebuffAnnounce${a},NOTFOUND]}
/if (${DebuffAnnounce[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffAnnounce${a} "Debuff Announcement"
/varset DebuffAnnounce[${a}] Debuff Announcement
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffMemToSlot${a},NOTFOUND]}
/varset DebuffMemToSlot[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffMemToSlot${a} 0
/varset DebuffMemToSlot[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Debuff,DebuffOnMATarget${a},NOTFOUND]}
/varset DebuffOnMATarget[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffOnMATarget${a} 0
/varset DebuffOnMATarget[${a}] 0
/varset INIFlag 1
}
/next a
/varset DebuffCheckTime ${Ini[${IniFile},Debuff,DebuffCheckTime,NOTFOUND]}
/if (${DebuffCheckTime.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff DebuffCheckTime 3s
/varset DebuffCheckTime 3s
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Debuff,FaceBeforeDebuff,NOTFOUND]}
/varset FaceBeforeDebuff ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Debuff FaceBeforeDebuff 1
/varset FaceBeforeDebuff 1
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Events,EventCount,NOTFOUND]}
/varset EventCount ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventCount 0
/varset EventCount 0
/varset INIFlag 1
}
/for a 1 to 8
/varset EventSpell[${a}] ${Ini[${IniFile},Events,EventSpell${a},NOTFOUND]}
/if (${EventSpell[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventSpell${a} "Event Spell Name"
/varset EventSpell[${a}] Event Spell Name
/varset INIFlag 1
}
/next a
/if (${EventCount}>0) {
/for a 1 to ${EventCount}
/varset EventSpellID[${a}] ${Spell["${EventSpell[${a}]}"].ID}
/next a
}
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Events,EventMinMana${a},NOTFOUND]}
/varset EventMinMana[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventMinMana${a} 100
/varset EventMinMana[${a}] 100
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Events,EventMaxMana${a},NOTFOUND]}
/varset EventMaxMana[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventMaxMana${a} 0
/varset EventMaxMana[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Events,EventMinHP${a},NOTFOUND]}
/varset EventMinHP[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventMinHP${a} 100
/varset EventMinHP[${a}] 100
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Events,EventMaxHP${a},NOTFOUND]}
/varset EventMaxHP[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventMaxHP${a} 0
/varset EventMaxHP[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Events,EventDuration${a},NOTFOUND]}
/varset EventDuration[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventDuration${a} 0
/varset EventDuration[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Events,EventMemToSlot${a},NOTFOUND]}
/varset EventMemToSlot[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventMemToSlot${a} 0
/varset EventMemToSlot[${a}] 0
/varset INIFlag 1
}
/next a
/varset EventCheckTime ${Ini[${IniFile},Events,EventCheckTime,NOTFOUND]}
/if (${EventCheckTime.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Events EventCheckTime 10s
/varset EventCheckTime 10s
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Heal,HealCount,NOTFOUND]}
/varset HealCount ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealCount 0
/varset HealCount 0
/varset INIFlag 1
}
/for a 1 to 8
/varset HealSpell[${a}] ${Ini[${IniFile},Heal,HealSpell${a},NOTFOUND]}
/if (${HealSpell[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealSpell${a} "Heal Spell Name"
/varset HealSpell[${a}] Heal Spell Name
/varset INIFlag 1
}
/next a
/if (${HealCount}>0) {
/for a 1 to ${HealCount}
/varset HealSpellID[${a}] ${Spell["${HealSpell[${a}]}"].ID}
/next a
}
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Heal,HealMinHP${a},NOTFOUND]}
/varset HealMinHP[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealMinHP${a} 0
/varset HealMinHP[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Heal,HealMaxHP${a},NOTFOUND]}
/varset HealMaxHP[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealMaxHP${a} 100
/varset HealMaxHP[${a}] 100
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Heal,HealMinMana${a},NOTFOUND]}
/varset HealMinMana[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealMinMana${a} 0
/varset HealMinMana[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Heal,HealMinGroupCount${a},NOTFOUND]}
/varset HealMinGroupCount[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealMinGroupCount${a} 0
/varset HealMinGroupCount[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset HealClass[${a}] ${Ini[${IniFile},Heal,HealClass${a},NOTFOUND]}
/if (${HealClass[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealClass${a} WAR|SHD|PAL|RNG|MNK|ROG|BRD|BST|BER|SHM|CLR|DRU|WIZ|MAG|ENC|NEC
/varset HealClass[${a}] WAR|SHD|PAL|RNG|MNK|ROG|BRD|BST|BER|SHM|CLR|DRU|WIZ|MAG|ENC|NEC
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Heal,HealMemToSlot${a},NOTFOUND]}
/varset HealMemToSlot[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealMemToSlot${a} 0
/varset HealMemToSlot[${a}] 0
/varset INIFlag 1
}
/next a
/varset HealCheckTime ${Ini[${IniFile},Heal,HealCheckTime,NOTFOUND]}
/if (${HealCheckTime.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealCheckTime 2s
/varset HealCheckTime 2s
/varset INIFlag 1
}
/for a 1 to 8
/varset HealAnnounce[${a}] ${Ini[${IniFile},Heal,HealAnnounce${a},NOTFOUND]}
/if (${HealAnnounce[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealAnnounce${a} "Heal Announcement"
/varset HealAnnounce[${a}] Heal Announcement
/varset INIFlag 1
}
/next a
/varset TempStr ${Ini[${IniFile},Heal,HealPets,NOTFOUND]}
/varset HealPets ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal HealPets 1
/varset HealPets 1
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Heal,WussyFactor,NOTFOUND]}
/varset WussyFactor ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Heal WussyFactor 10
/varset WussyFactor 10
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},GroupBuff,GroupBuffCount,NOTFOUND]}
/varset GroupBuffCount ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffCount 0
/varset GroupBuffCount 0
/varset INIFlag 1
}
/for a 1 to 8
/varset GroupBuff[${a}] ${Ini[${IniFile},GroupBuff,GroupBuff${a},NOTFOUND]}
/if (${GroupBuff[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuff${a} "Group Buff Spell Name"
/varset GroupBuff[${a}] Group Buff Spell Name
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset GroupBuffAliasName[${a}] ${Ini[${IniFile},GroupBuff,GroupBuffAliasName${a},NOTFOUND]}
/if (${GroupBuffAliasName[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffAliasName${a} "Group Buff Alias Name"
/varset GroupBuffAliasName[${a}] Group Buff Alias Name
/varset INIFlag 1
}
/next a
/if (${GroupBuffCount}>0) {
/for a 1 to ${GroupBuffCount}
/varset GroupBuffID[${a}] ${Spell["${GroupBuff[${a}]}"].ID}
/next a
}
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},GroupBuff,GroupBuffDuration${a},NOTFOUND]}
/varset GroupBuffDuration[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffDuration${a} 99999
/varset GroupBuffDuration[${a}] 99999
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},GroupBuff,GroupBuffAtStart${a},NOTFOUND]}
/varset GroupBuffAtStart[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffAtStart${a} 0
/varset GroupBuffAtStart[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},GroupBuff,GroupBuffMinMana${a},NOTFOUND]}
/varset GroupBuffMinMana[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffMinMana${a} 0
/varset GroupBuffMinMana[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},GroupBuff,GroupBuffMinGroupCount${a},NOTFOUND]}
/varset GroupBuffMinGroupCount[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffMinGroupCount${a} 0
/varset GroupBuffMinGroupCount[${a}] 0
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset GroupBuffAnnounce[${a}] ${Ini[${IniFile},GroupBuff,GroupBuffAnnounce${a},NOTFOUND]}
/if (${GroupBuffAnnounce[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffAnnounce${a} "Group Buff Announcement"
/varset GroupBuffAnnounce[${a}] Group Buff Announcement
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset GroupBuffClass[${a}] ${Ini[${IniFile},GroupBuff,GroupBuffClass${a},NOTFOUND]}
/if (${GroupBuffClass[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffClass${a} WAR|SHD|PAL|RNG|MNK|ROG|BRD|BST|BER|SHM|CLR|DRU|WIZ|MAG|ENC|NEC
/varset GroupBuffClass[${a}] WAR|SHD|PAL|RNG|MNK|ROG|BRD|BST|BER|SHM|CLR|DRU|WIZ|MAG|ENC|NEC
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},GroupBuff,GroupBuffMemToSlot${a},NOTFOUND]}
/varset GroupBuffMemToSlot[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffMemToSlot${a} 0
/varset GroupBuffMemToSlot[${a}] 0
/varset INIFlag 1
}
/next a
/varset GroupBuffCheckTime ${Ini[${IniFile},GroupBuff,GroupBuffCheckTime,NOTFOUND]}
/if (${GroupBuffCheckTime.Equal["NOTFOUND"]}) {
/ini "${IniFile}" GroupBuff GroupBuffCheckTime 15s
/varset GroupBuffCheckTime 15s
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Pet,PausePet,NOTFOUND]}
/varset PausePet ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PausePet 1
/varset PausePet 1
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Pet,PetAssistOnHPPct,NOTFOUND]}
/varset PetAssistOnHPPct ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetAssistOnHPPct 98
/varset PetAssistOnHPPct 98
/varset INIFlag 1
}
/varset PetCheckTime ${Ini[${IniFile},Pet,PetAssistCheckTime,NOTFOUND]}
/if (${PetCheckTime.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetAssistCheckTime 5s
/varset PetCheckTime 5s
/varset INIFlag 1
}
/varset PetBuffCheckTime ${Ini[${IniFile},Pet,PetBuffCheckTime,NOTFOUND]}
/if (${PetBuffCheckTime.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetBuffCheckTime 15s
/varset PetBuffCheckTime 15s
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Pet,PetBuffCount,NOTFOUND]}
/varset PetBuffCount ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetBuffCount 0
/varset PetBuffCount 0
/varset INIFlag 1
}
/for a 1 to 8
/varset PetBuff[${a}] ${Ini[${IniFile},Pet,PetBuff${a},NOTFOUND]}
/if (${PetBuff[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetBuff${a} "Pet Buff Name"
/varset PetBuff[${a}] Pet Buff Name
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset PetBuffIconName[${a}] ${Ini[${IniFile},Pet,PetBuffIconName${a},NOTFOUND]}
/if (${PetBuffIconName[${a}].Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetBuffIconName${a} "Pet Buff Icon Name"
/varset PetBuffIconName[${a}] Pet Buff Icon Name
/varset INIFlag 1
}
/next a
/for a 1 to 8
/varset TempStr ${Ini[${IniFile},Pet,PetBuffMemToSlot${a},NOTFOUND]}
/varset PetBuffMemToSlot[${a}] ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetBuffMemToSlot${a} 0
/varset PetBuffMemToSlot[${a}] 0
/varset INIFlag 1
}
/next a
/varset PetSummonSpell ${Ini[${IniFile},Pet,PetSummonSpell,NOTFOUND]}
/if (${PetSummonSpell.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetSummonSpell "Pet Summon Spell Name"
/varset PetSummonSpell Pet Summon Spell Name
/varset INIFlag 1
}
/varset TempStr ${Ini[${IniFile},Pet,PetSummonMemToSlot,NOTFOUND]}
/varset PetSummonMemToSlot ${TempStr}
/if (${TempStr.Equal["NOTFOUND"]}) {
/ini "${IniFile}" Pet PetSummonMemToSlot 0
/varset PetSummonMemToSlot 0
/varset INIFlag 1
}
/if (${INIFlag}==1) {
/echo INI file created and populated. Please customize ${IniFile} in your macros directory.
/endmacro
}
/tgb on
/return
Sub INIListUpdate(a,b,c)
/declare TempItem string local
/declare TempVar int local
/declare TempVar2 int local
/varset TempVar 0
/if (${c}==1) /varset TempVar 1
/if (${a.Length}>0) {
:ListSearch
/varset TempItem ${Ini[${IniFile},${b},${Int[${TempVar}]},NOTFOUND]}
/if (${TempItem.Equal["NOTFOUND"]}) /goto :AddItem
/if (${TempItem.Equal["${a}"]}) {
/echo -[ ${a} REMOVED from ${b} list. ]-
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I guess I won't ${If[${b.Equal[Watch]},watch,listen to]} ${a} anymore.
/ini "${IniFile}" "${b}" "${Int[${TempVar}]}" "Empty"
/goto :DoneCategory
}
/varset TempVar ${Math.Calc[${TempVar}+1]}
/goto :ListSearch
:AddItem
/varset TempVar 0
/if (${c}==1) /varset TempVar 1
:AddItemLoop
/varset TempItem ${Ini[${IniFile},${b},${Int[${TempVar}]},NOTFOUND]}
/if (${TempItem.Equal["Empty"]}) /goto :FoundCategorySlot
/if (${TempItem.Equal["NOTFOUND"]}) /goto :FoundCategorySlot
/varset TempVar ${Math.Calc[${TempVar}+1]}
/goto :AddItemLoop
:FoundCategorySlot
/if ((${TempVar}>10)&&(${b.Equal["Watch"]})) {
/echo -(( All slots full, 10 Maximum. ))-
/return
}
/echo -[ ${a} ADDED to ${b} list. ]-
/if (${Reply}==1 && !${SenderName.Equal[nobody]}) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} Ok, I will ${If[${b.Equal[Watch]},watch,listen to]} ${a} now.
/ini "${IniFile}" "${b}" "${Int[${TempVar}]}" "${a}"
}
:DoneCategory
/return
Sub Event_Master(EvtText)
/varset EvtText ${EvtText.Right[-6]}
/varset SenderName nobody
/call MasterFunction "${EvtText}"
/return
Sub MasterFunction(CmdText)
/declare TempItem string local
/declare TempVar int local
/declare TempVar2 int local
/declare MakeReply string local
/varset CmdText ${CmdText.Right[-7]}
/if (${CmdText.Length}>0) {
/call INIListUpdate "${CmdText}" "Masters" "0"
/call LoadMasterList
} else {
/varset TempVar2 0
/varset TempVar 0
/varset MakeReply I'll do whatever these guys say -
/echo -[ Allowed Masters ]-
:CategoryList
/varset TempItem ${Ini[${IniFile},Masters,${Int[${TempVar}]},NOTFOUND]}
/if (${TempItem.Equal["NOTFOUND"]}) /goto :DoneCategoryList
/varset TempVar ${Math.Calc[${TempVar}+1]}
/if (!${TempItem.Equal["Empty"]}) {
/varset TempVar2 ${Math.Calc[${TempVar2}+1]}
/varset MakeReply ${MakeReply} ${TempItem},
/echo -- Master[${Int[${TempVar2}]}] ${TempItem}
}
/goto :CategoryList
:DoneCategoryList
/if (${Reply}==1 && !${SenderName.Equal[nobody]} && ${TempVar2}>0) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} ${MakeReply.Left[-1]}.
/if (${Reply}==1 && !${SenderName.Equal[nobody]} && ${TempVar2}==0) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not listening to anyone.
/if (${TempVar2}==0) /echo -(( No Masters Found ))-
}
/return
Sub Event_Watch(EvtText)
/varset EvtText ${EvtText.Right[-6]}
/varset SenderName nobody
/call WatchFunction "${EvtText}"
/return
Sub WatchFunction(CmdText)
/declare TempItem string local
/declare TempVar int local
/declare TempVar2 int local
/declare b int local
/declare MakeReply string local
/varset CmdText ${CmdText.Right[-6]}
/if (${CmdText.Length}>0) {
/call INIListUpdate "${CmdText}" "Watch" "1"
/call LoadWatchList
} else {
/varset TempVar2 0
/varset TempVar 1
/varset MakeReply I'll be watching the health of these guys -
/echo -[ Watch List ]-
:CategoryList
/varset TempItem ${Ini[${IniFile},Watch,${Int[${TempVar}]},NOTFOUND]}
/if (${TempItem.Equal["NOTFOUND"]}) /goto :DoneCategoryList
/varset TempVar ${Math.Calc[${TempVar}+1]}
/if (!${TempItem.Equal["Empty"]}) {
/varset TempVar2 ${Math.Calc[${TempVar2}+1]}
/varset MakeReply ${MakeReply} ${TempItem},
/echo -- Watch Target[${Int[${TempVar2}]}] ${TempItem}
}
/goto :CategoryList
:DoneCategoryList
/if (${Reply}==1 && !${SenderName.Equal[nobody]} && ${TempVar2}>0) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} ${MakeReply.Left[-1]}.
/if (${Reply}==1 && !${SenderName.Equal[nobody]} && ${TempVar2}==0) /docommand /${If[${ReplyChannel.Find[ @]}>0,${ReplyChannel.Mid[1,${Math.Calc[${ReplyChannel.Find[ @]}-1]}]} ${SenderName},${ReplyChannel}]} I'm not watching anyones health.
/if (${TempVar2}==0) /echo -(( No Watch List Found ))-
}
/return
-
aChallenged1
- a grimling bloodguard
- Posts: 1804
- Joined: Mon Jun 28, 2004 10:12 pm
-
Blackcircle7
- orc pawn
- Posts: 27
- Joined: Mon May 24, 2004 1:36 pm
