MacroQuest64

Code: Select all

   /for GenFor 1 to ${Math.Calc[${SectionsList.Count[ ]}+1]} 
      /if (${SectionsList.Arg[${GenFor}].NotEqual[Shortcuts]} && ${SectionsList.Arg[${GenFor}].NotEqual[Shortcuts]}) { 
         /if (${String[ ${cmds-${SectionsList.Arg[${GenFor}]}} ].Find[ ${CurrCommand} ]}) { 
            /echo doing Command ${CurrCommand} ${CommandParam} 
            /call Command-${CurrCommand} ${CommandParam} 
            /return 
         } 
      } 

Code: Select all

|   /if (${Defined[Param0]}) { 
|      /for GenFor 0 to ${Macro.Params} 
|         /call ListAppendElement MasterList ${Param${GenFor}} " "
|      /next GenFor 
|   } 

Code: Select all

   |---------------------------------------------------------------------- 
   |Initialize MasterList (characters that can control this bot) 
   |Checks to see if list already exists in case a reload is done 
   |---------------------------------------------------------------------- 
   /if (!${Defined[MasterList]}) { 
      /if (!${Defined[Param0]}) { 
         /echo Usage: /macro generic <Master Name1> <Master Name2>... 
         /endmacro 
      } 
      /declare MasterList string outer YourPlayerName1 YourPlayerName2
   } 
   |---------------------------------------------------------------------- 
   |clear and rebuild master list if a list is passed 
   |---------------------------------------------------------------------- 
|   /if (${Defined[Param0]}) { 
|      /for GenFor 0 to ${Macro.Params} 
|         /call ListAppendElement MasterList ${Param${GenFor}} " "
|      /next GenFor 
|   } 

Code: Select all

   /call AddCommands buff chainnuke chainstun evac loadlist 
   /call AddCommands mana selfbuff bufflist setlompct sn snt spellgem 
   /call AddCommands heal resetwatch setcasterheal setcasterhealpct 
   /call AddCommands setdefaultheal setpatchheal setpetheal setpethealpct 
   /call AddCommands settankheal settankhealpct watchtarget 

Code: Select all

|   /if (${myvar.Find[ ${ChatSender.Lower} ]}) { 

Code: Select all

|botmain.inc 
|Generic bot macro for any class. 
|Version 13.4.0 
|Date:07/08/2005 
| 
||** 
[genbot] 
version=13.4.0 
**|| 
| 

|------------------------------------------------------------------------- 
|Includes 
|------------------------------------------------------------------------- 
#include bothealer.inc 
#include botcombat.inc 
#include botspell.inc 
#include botcore.inc 
#include botcommon.inc 
#include advpath.inc 

|------------------------------------------------------------------------- 
|SUB: Main Program Sub 
|------------------------------------------------------------------------- 

Sub Main 
   /declare GenFor int local 
   /declare SectionName string outer 
   |---------------------------------------------------------------------- 
   |Initialize MasterList (characters that can control this bot) 
   |Checks to see if list already exists in case a reload is done 
   |---------------------------------------------------------------------- 
   /if (!${Defined[MasterList]}) { 
      /if (!${Defined[Param0]}) { 
         /echo Usage: /macro generic <Master Name1> <Master Name2>... 
         /endmacro 
      } 
      /declare MasterList string outer YourMasterName1 YourMasterName2
   } 
   |---------------------------------------------------------------------- 
   |clear and rebuild master list if a list is passed 
   |---------------------------------------------------------------------- 
|   /if (${Defined[Param0]}) { 
|      /for GenFor 0 to ${Macro.Params} 
|         /call ListAppendElement MasterList ${Param${GenFor}} " "
|      /next GenFor 
|   } 
   |---------------------------------------------------------------------- 
   |Call the Initialize Sub of each include file 
   |---------------------------------------------------------------------- 
   /declare SectionsList string outer Core Combat Spell Healer Shortcuts Common Individual 
   /for GenFor 1 to ${Math.Calc[${SectionsList.Count[ ]}+1]} 
      /declare cmds-${SectionsList.Arg[${GenFor}]} string outer 
   /next GenFor 
    
   /for GenFor 1 to ${Math.Calc[${SectionsList.Count[ ]}+1]} 
      /varset SectionName ${SectionsList.Arg[${GenFor}]} 
      /call Init-${SectionName} 
   /next GenFor 
    
   | Setting SectionName to blank let's SetToggle routine know it can talk again. 
   /varset SectionName 
   |---------------------------------------------------------------------- 
   |Main program loop performs subs for each include file 
   |---------------------------------------------------------------------- 
   :MainLoop 
   /doevents 
   /if (${Toggle-doheal}) /call HealerMain 
   /if (${CombatTargetID}) /call CombatMain 
   /call CoreMain 
   /call SpellMain 
   /call CommonMain 
   /call IndividualMain 
   /goto :MainLoop 

/return 


|------------------------------------------------------------------------- 
| SHORTCUT SUBROUTINES 
|------------------------------------------------------------------------- 

   |---------------------------------------------------------------------- 
   | Init-Shortcuts: to load in shortcuts from the .ini file 
   |---------------------------------------------------------------------- 

Sub Init-Shortcuts 
   /declare Shortcutlist string local 
   /declare ArgNum int local 0 
   /declare Short string local 0 
   /declare ParamS string outer 
    
   /varset ArgNum 1 
   /if (!${Defined[IniFile]}) /declare IniFile string outer genbot_${Me.CleanName}.ini 
   /varset Shortcutlist ${Ini[${IniFile},SHORTCUTS,-1,Undefined]} 
   /if (${Shortcutlist.NotEqual[Undefined||]}) { 
      :shortcuts 
      /if (${Shortcutlist.Arg[${ArgNum},|].Length}) { 
         /varset Short ${Shortcutlist.Arg[${ArgNum},|].Lower} 
         /call LoadSetting ${Short} shortcut ${Short} None 
         /varcalc ArgNum ${ArgNum}+1 
         /goto :shortcuts 
      } 
   } else { 
      /ini ${IniFile} SHORTCUTS default "/echo Put yer shortcuts in your .ini file!" 
   } 
/return 

   |---------------------------------------------------------------------- 
   | Command-shortcuts: to list available shortcuts 
   |---------------------------------------------------------------------- 


Sub Command-shortcuts 
/declare myvar string local
/varset myvar ${cmds-Shortcuts.Lower}
   /if (${Defined[Param0]}) { 
      /if (${myvar.Find[ ${Param0.Lower} ]}) { 
         /call ChatOut 3 "Shortcut ${Param0} does: ${ShortCuts-${Param0}-Text}" 
      } else { 
         /call ChatOut 3 "I don't know the shortcut ${Param0}." 
      } 
   } else { 
      /call ChatOut 3 "${cmds-Shortcuts}" 
      /call ChatOut 3 "Type: shortcuts name_of_shortcut for more information on any particular shortcut. 
   } 
/return 

   |---------------------------------------------------------------------- 
   | Init-Shortcuts: execute a shortcut 
   |---------------------------------------------------------------------- 

Sub ShortCut(string ShortCutCommand) 
   /declare Name string local 
   /declare ParseText string local 
   /declare GenFor int local 

   /varset Name ${ShortCutCommand.Arg[1].Lower} 
   /varset ParseText ${ShortCuts-${Name}-Text} 
   /if (${ParseText.Find[NameS]} && ${ShortCutCommand.Arg[2].Length}) { 
      /vardata CommandParam ParseText 
      /call StringReplaceAll CommandParam NameS "${ShortCutCommand.Right[${Math.Calc[-${ShortCutCommand.Arg[1].Length}-1]}]}" 
      /vardata ParseText CommandParam 
   } 
   /for GenFor 1 to ${Math.Calc[${ParseText.Count[|]}+1]} 
      /call ExecCommand "${ParseText.Arg[${GenFor},|]}" 
   /next GenFor 
/return 


|------------------------------------------------------------------------- 
| INITIALIZATION CONTROL SUBROUTINES 
|------------------------------------------------------------------------- 

   |---------------------------------------------------------------------- 
   | AddCommands: add a command 
   |---------------------------------------------------------------------- 

Sub AddCommands
/declare myvar string local 
/varset myvar  ${cmds-${SectionName}}
   /declare GenFor int local 
   /for GenFor 0 to ${Math.Calc[${Macro.Params}-1]} 
|/echo addcommands_routine
|/echo ${Param${GenFor}}
      /if (!${myvar.Find[ ${Param${GenFor}} ]}) { 
	       /call ListAppendElement cmds-${SectionName} ${Param${GenFor}} " " 
      } 
   /next GenFor 
/return 

   |---------------------------------------------------------------------- 
   | AddToggle: add a toggle command and load initial setting from .ini 
   |---------------------------------------------------------------------- 

Sub AddToggle(string Name,string TogDefault,string TogType,string OffText,string OnText,string CallSub) 
   /declare Setting string local 
   /if (!${Defined[Toggle-${Name}]}) { 
      /declare Toggle-${Name} bool outer 
      /declare Toggle-${Name}-OffText string outer 
      /declare Toggle-${Name}-OnText string outer 
      /declare Toggle-${Name}-ToggleType string outer 
      /declare Toggle-${Name}-CallSub bool outer 
   } 
   /varset Toggle-${Name}-OffText ${OffText} 
   /varset Toggle-${Name}-OnText ${OnText} 
   /varset Toggle-${Name}-ToggleType ${TogType} 
   /if (${CallSub.Lower.Equal[callsub]}) { 
      /varset Toggle-${Name}-CallSub TRUE 
   } else { 
      /varset Toggle-${Name}-CallSub FALSE 
   } 
   /if (${TogDefault.Equal[noini]}) { 
      /varset Toggle-${Name} FALSE 
   } else { 
      /call LoadSetting ${Name} toggle ${Name} ${TogDefault} 
   } 
   /call ListAppendElement cmds-${SectionName} ${Name} " " 
/return 

   |---------------------------------------------------------------------- 
   | SetToggle: set the value of the .ini and repeat current setting 
   |---------------------------------------------------------------------- 

Sub SetToggle(string Name,string newValue) 
   /declare OutputString string local
   /declare myvar string local
   /varset myvar " true on 1 yes " 
    
   | If no argument and Toggle is a toggle type, toggle it. 
   /if (!${Defined[newValue]}) { 
      /if (${Toggle-${Name}-ToggleType.Equal[toggle]}) { 
         /if (${${Toggle-${Name}}) { 
            /declare newValue string local 0 
         } else { 
            /declare newValue string local 1 
         } 
      } else { 
         /declare newValue string local ${${Toggle-${Name}} 
      } 
      
   | If it has an argument, set according to argument, and clear newValue. 
   } else { 
      /varset newValue ${newValue.Lower} 
      /if (${myvar.Find[ ${newValue} ]}) { 
         /varset Toggle-${Name} 1 
         /varset newValue 
      } else {
/varset myvar " false off 0 no "
	  /if (${myvar.Find[ ${newValue} ]}) { 
         /varset Toggle-${Name} 0 
         /varset newValue 
		}
	  } 
   } 
    
   | Call the extended function sub if indicated. 
   /if (${Toggle-${Name}-CallSub}) { 
      /call Toggle-${Name} ${newValue} 
   } 
    
   | If we're still initializing, don't output the setting. 
   /if (${SectionName.Length}) /return 
    
   | Find the appropriate response string for new toggle setting. 
   | Using CommandParam for the output string just cuz I'm too lazy 
   | to declare another outer string. 
   /if (${Toggle-${Name}}) { 
      /varset CommandParam ${Toggle-${Name}-OnText} 
   } else { 
      /varset CommandParam ${Toggle-${Name}-OffText} 
   } 
    
   | Replace any @'s with $'s for runtime values. 
   /if (${CommandParam.Count[@]}) { 
      /call CollapseParams CommandParam 
      /varset CommandParam ${Macro.Return} 
   } 
    
   | Say what you've come to say. 
   /call ChatOut 6 "${CommandParam}" 
/return 

   |---------------------------------------------------------------------- 
   | LoadSetting: load a variable value from the .ini file 
   |---------------------------------------------------------------------- 

Sub LoadSetting(string VarName,string VarType,string KeyName,string DefaultValue) 
   /declare RealSection string local ${SectionName.Upper} 
   /if (${VarType.Equal[shortcut]} || ${VarType.Equal[event]}) { 
      /varset RealSection ${VarType.Upper}S 
   } 
    
   | Initialize the .ini file. 
   /if (!${Defined[IniFile]}) { 
      /declare IniFile string outer INI_FILE_PREFIX${Me.CleanName}.ini 
   } 
    
   | Read value from .ini file 
   /declare IniValue string local ${Ini[${IniFile},${RealSection},${KeyName},NOTFOUND]} 
   | If no .ini value, use the DefaultValue 
   /if (${IniValue.Equal[NOTFOUND]}) { 
         /ini ${IniFile} "${RealSection}" "${KeyName}" "${DefaultValue}" 
         /varset IniValue ${DefaultValue} 
   } 
    
   | If it's a string, set the varname-DefaultValue variable 
   /if (${VarType.Equal[string]}) { 
      /if (!${Defined[${VarName}-DefaultValue]}) { 
         /declare ${VarName}-DefaultValue ${VarType} outer 
      } 
      /vardata ${VarName}-DefaultValue DefaultValue 

   |If it's a shortcut, then set the shortcut var and add to the list of shortcuts 
   } else /if (${VarType.Equal[shortcut]} || ${VarType.Equal[event]}) { 
      /if (!${IniValue.Lower.Equal[none]}) { 
         /if (!${Defined[ShortCuts-${VarName.Lower}-Text]}) { 
            /declare ShortCuts-${VarName.Lower}-Text string outer 
         } 
         /varset ShortCuts-${VarName.Lower}-Text ${IniValue} 
         /call ListAppendElement cmds-Shortcuts ${VarName.Lower} " " 
      } 
      /return 

   | If it's a toggle, then use SetToggle sub to give the value. 
   } else /if (${VarType.Equal[toggle]}) { 
      /call SetToggle ${VarName.Lower} ${IniValue} 
      /return 
   } 
    
   | Must be not a shortcut nor a toggle, since not /returned yet. 
   /if (!${Defined[${VarName}]}) { 
      /declare ${VarName} ${VarType} outer 
   } 
   /varset ${VarName} ${IniValue} 
/return 

   |---------------------------------------------------------------------- 
   | CollapseParams: replace @'s with $'s to evaluate datavars at runtime 
   |---------------------------------------------------------------------- 

Sub CollapseParams(string Parms) 
   /declare GenFor int local 
   /declare stemp string local 
   /declare sint int local 
    
   |/echo Parms ${Parms} ${${Parms}} 
    
   /varset sint ${${Parms}.Count[@]} 
   |/if (Debug) /echo name ${Name} schar @ sint ${sint} 
   /if (${sint}) { 
      /varset stemp ${${Parms}.Arg[${Math.Calc[${sint}+1]},@]} 
      |/if (Debug) /echo stemp ${stemp} 
      /for GenFor ${sint} downto 1 
         |/if (Debug) /echo In for loop 
         /if (${${Parms}.Arg[${GenFor},@].Length}) { 
            /varset stemp ${${Parms}.Arg[${GenFor},@]}$${stemp} 
         } else { 
            /varset stemp $${stemp} 
         } 
      /next GenFor 
   } else { 
      /varset stemp ${${Parms}} 
   } 
   |/echo new result ${stemp} 
/return ${stemp}

Code: Select all

|botspell.inc 
|Bot spell module. 
|Version 13.4.0 
|Date:07/08/2005 
| 
||** 
[botspell] 
version=13.4.0 
**|| 

#event CastFizzle "Your spell fizzles!" 
#event CastInterrupt "Your spell is interrupted." 
#event CastInterrupt "Your casting has been interrupted." 
#event CastNoMana "Insufficient Mana to cast this spell!" 
#event CastResist "Your target resisted #*#" 
#event CastTooFar "Your target is out of range, get closer!" 
#event Collapse "Your gate is too unstable, and collapses." 
#event Distracted "You are too distracted to cast a spell now!" 
#event ImmuneSlow "Your target is immune to changes in its attack speed." 
#event ImmuneRoot "Your target is immune to changes in its run speed." 
#event MissedNote "You miss a note, bringing your song to a close!" 
#event NoLOS "You cannot see your target." 
#event NoMem "You do not seem to have that spell memorized." 
#event NoOverWrite "Your spell would not have taken hold on your target." 
#event NoTarget "You must first select a target for this spell!" 
#event Recovered "You haven't recovered yet..." 
#event Recovered "Spell recovery time not yet met." 
#event RootOff "Your Immobilize spell has worn off." 
#event Sitting "You must be standing to cast a spell." 
#event Stunned "You can't cast spells while stunned!" 
#event Stunned "You *CANNOT* cast spells, you have been silenced!" 
#event Slowed "#*# yawns."

Sub Init-Spell 
   /declare cmds-SPELL string outer Spell: 
   |For each command 
   |/call AddCommand "Command Section" "Command Phrase" "Called Sub" 
   |Command Section - where the command will be listed in response to the cmd phrase 
   |Command Phrase to trigger bot - End User can change to suit prefferences 
   |Called Sub - Routine to execute in response to Command Phrase 
   /call AddCommands buff chainnuke chainstun evac loadlist 
   /call AddCommands mana selfbuff bufflist setlompct sn snt spellgem 
|/declare Vars 
   /declare BuffPtrList string outer 
   /declare BuffSelfIconList string outer 
   /declare TimedBuffList string outer
   /declare CastInfo string outer 
   /declare CastLastResult string outer 
   /declare CastName string outer 
   /declare CastOldTargetID int outer 
   /declare CastQueue string outer 
   /declare CastStep int outer 
   /declare CastTarget string outer 
   /declare CastType string outer 
   /declare ChainStunNum int outer 
   /declare DoAgain bool outer FALSE 
   /declare LastSn string outer NA 
   /declare SpellNeedToRemem bool outer 0 

|Timers 
   /declare CannAATimer timer outer 
   /declare ChainStunTime timer outer 
   /declare CannTimer timer outer 
   /declare CastTimer timer outer 
   /declare CTimer timer outer 
   /declare LomTimer timer outer 
   /declare ST-CheckSelfBuffs timer outer 1 
   /declare YaulpTimer timer outer 

|Load Settings 
   /call LoadSetting BuffSelfList string SelfBuffList "Buffs you wish to maintain on yourself separated with |" 
   /call AddToggle sitaftercast on return "I will no longer sit after casting." "I will now sit after casting." 
   /call LoadSetting DelayBeforeSit string DelayBeforeSit 3s 
   /call AddToggle canni off return "I won't eat myself for mana." "I will eat myself for mana." 
   /call LoadSetting CanniSpell string CanniSpell Cannibalize 
   /call LoadSetting CanniLimit string CanniUntilPctHPsLessThan 40 
   /call LoadSetting ChainNuke string ChainNuke "Your Chain Nuke Spells separated with |." 
   /call LoadSetting ChainStun string ChainStun "Your Chain Stun Spells separated with |." 
   /call LoadSetting DefaultSpellSet string DefaultSpellSet Default 
   /call AddToggle dobuff on return "I won't cast buffs until commanded." "I will cast buffs." 
   /call LoadSetting EvacSpell string EvacSpell "Enter the name of your Evac spell here." 
   /call LoadSetting LomMsg string LomMsg "Warning I'm running low on Mana." 
   /call AddToggle reportlom off return "I won't tell you when I'm low on Mana." "I'll let you know when I'm low on Mana." 
   /call AddToggle remem off return "I won't remem my spellset after casting." "I will remem my spellset after casting." 
   /call LoadSetting SpellGem int DefaultSpellGem 8 
   /call AddToggle yaulp off return "I won't Yaulp for mana." "I will Yaulp for mana." 
   /call LoadSetting YaulpSpell string YaulpSpell Yaulp 


   /if (${BuffSelfList.NotEqual[${BuffSelfList-DefaultValue}]}) { 
      /declare ArgNum int local 1 
      /for ArgNum 1 to ${Math.Calc[${BuffSelfList.Count[|]}+1]} 
         /varset CommandParam ${BuffSelfList.Arg[${ArgNum},|]} 
         /call Command-SelfBuff "${CommandParam}" 
      /next ArgNum 
   } 
/return 

Sub SpellMain 
   /call CastFromQueue 
   /if (${Toggle-canni}) /call CheckCann 
   /if (${Toggle-yaulp}) /call CheckYaulp 
/return 

||||| Do Subs 

Sub Command-buff 
   /declare BuffName string local 
   /declare BuffType string local 
   /if (!${Defined[Param0]}) /return 
   /if (${Param0.Equal[on]}) /return 
   /if (${Param0.Equal[off]}) { 
      /varset BuffListCount 0 
      /return 
   } 
   /declare SpellNameParam string local ${Param0} 
   /declare TargetName string local 
   /declare ParamCount int local 1 
   /if (${Param0.Equal[on]}) { 
      /varset SpellNameParam ${LastSn} 
      /goto :Command-BuffTargetStart 
   } 
   :Command-BuffSpellLoop 
      /if (${Defined[Param${ParamCount}]}) { 
         /if (${Param${ParamCount}.Equal[on]}) /goto :Command-BuffTargetStart 
         /varset SpellNameParam ${SpellNameParam} ${Param${ParamCount}} 
         /varcalc ParamCount ${ParamCount}+1 
         /goto :Command-BuffSpellLoop 
      } 
   :Command-BuffTargetStart 
   /varcalc ParamCount ${ParamCount}+1 
   /if (!${Defined[Param${ParamCount}]}) { 
      /varset TargetName me 
   } else { 
      /varset TargetName ${Param${ParamCount}} 
      /varcalc ParamCount ${ParamCount}+1 
      :Command-BuffTargetLoop 
         /if (${Defined[Param${ParamCount}]}) { 
            /varset TargetName ${TargetName} ${Param${ParamCount}} 
            /varcalc ParamCount ${ParamCount}+1 
            /goto :Command-BuffTargetLoop 
         } 
      /if (${TargetName.Equal[yourself]} || ${TargetName.Equal[${Me.CleanName}]}) { 
         /varset CommandParam ${SpellNameParam} 
         /call Command-SelfBuff ${CommandParam} 
         /return 
      } 
   } 
   /call AssignCastTarget "${TargetName}" 
   /varset TargetName ${Macro.Return} 
   /if (${TargetName.Equal[0]}) { 
      /call ChatOut 5 "I don't understand who to cast that buff on." 
      /return 
   } 
   /if (${DebugList.Find[spell]}) /echo Command-buff "${SpellNameParam}" "${TargetName}" 
   /call AddCast "${SpellNameParam}" "${TargetName}" b-0 
/return 


Sub BuffResult(string BuffType,string BuffCast,string BuffTarget,int Ptr) 
   /declare GenFor int local 
   /declare BuffSpell int local 
   /declare BuffDuration string local 0 
   /declare myvar string local
   /varset myvar ${BuffPtrList}

   | Find an available pointer for the buff and delete duplicates 
   /if (${Ptr}) { 
      /call ListDelbyName BuffPtrList ${Ptr} " " 
      /goto :gBuffPtrFound 
   } 
   /for GenFor 1 to ${Math.Calc[${BuffPtrList.Count[ ]}+2]} 
      /if (!${myvar.Find[ ${GenFor} ]} && !${Ptr}) { 
         /varset Ptr ${GenFor} 
      } 
      /if (${Buff-${BuffPtrList.Arg[${GenFor}]}-Text.Equal[${BuffType};${BuffCast};${BuffTarget}]}) { 
         /varset Ptr ${BuffPtrList.Arg[${GenFor}]} 
         /call ListDelbyArg BuffPtrList ${GenFor} " " 
         /varset ST-BuffRefresh-${Ptr} 0 
         /goto :gBuffPtrFound 
      } 
   /next GenFor 
   :gBuffPtrFound 
   /if (!${Defined[Buff-${Ptr}-Text]}) /declare Buff-${Ptr}-Text string outer 
   /if (!${Defined[Buff-${Ptr}-RetryNum]}) /declare Buff-${Ptr}-RetryNum int outer 0 

   /if (${DebugList.Find[spell]}) /echo BuffPtr ${Ptr} 

   /if (${CastLastResult.Equal[CAST_Successful]}) { 
      /varset Buff-${Ptr}-RetryNum 0 
      /if (${Spawn[${BuffTarget}].Name.Equal[${Me.Name}]} || ${BuffTarget.Equal[0]}) { 
         /call CheckForBuffIcon ${BuffType} "${BuffCast}" 
         /if (${Macro.Return}) { 
            /if (!${BuffSelfIconList.Find[|${BuffType};${BuffCast}|]}) { 
               /call ListAppendElement BuffSelfIconList "${BuffType};${BuffCast}" | 
            } 
            /return 
         } else { 
         /call ChatOut 8 "I don't recognize the icon for ${BuffType.Arg[1,-]} ${BuffName}.  Tell me 'timebuff ${BuffType.Arg[1,-]} ${BuffName}' some time when I don't have that buff active, and I'll record the buff and time how long it lasts." 
         } 
      } 
      /if (${TimedBuffList.Find[|${BuffSpell};]}) { 
         /call ListFindStringArg TimedBuffList "|${BuffSpell};" | 
         /varset BuffDuration ${TimedBuffList.Arg[${Macro.Return},|].Arg[2,;]} 
         /if (${Spawn[${BuffTarget}].Name.Equal[${Me.Name}]} && ${Me.Buff[${TimedBuffList.Arg[${Macro.Return},|].Arg[3,;]}].ID}) { 
            /if (!${BuffSelfList.Find[|${BuffType};${BuffCast}|]}) { 
               /call ListAppendElement BuffSelfList "${BuffType};${BuffCast}" | 
            } 
            /return 
         } 
      } 
      /if (!${BuffDuration}) { 
         /if (${BuffType.Arg[1,-].Equal[spell]}) { 
            /varset BuffDuration ${Spell[${BuffCast}].Duration.TotalSeconds}s 
        } else /if (${BuffType.Arg[1,-].Equal[item]}) { 
           /varset BuffDuration ${FindItem[${BuffCast}].Spell.Duration.TotalSeconds}s 
        } else /if (${BuffType.Equal[alt]}) { 
           /varset BuffDuration ${AltAbility[${BuffCast}].ReuseTime}s 
        } 
      } 
   } else { 
      /if (${CastLastResult.Equal[CAST_NoOverWrite]} || ${CastLastResult.Equal[TARGET_NOTEXIST]}) { 
         /varset BuffDuration 2m 
         /varset Buff-${Ptr}-RetryNum 0 
      } else /if (${Buff-${Ptr}-RetryNum}<2) { 
         /varcalc Buff-${Ptr}-RetryNum ${Buff-${Ptr}-RetryNum}+1 
         /varset BuffDuration 15s 
      } else { 
         /varset BuffDuration 95s 
         /varset Buff-${Ptr}-RetryNum 0 
      } 
   } 
   /if (!${Defined[ST-BuffRefresh-${Ptr}]}) /declare ST-BuffRefresh-${Ptr} timer outer 
   /varset ST-BuffRefresh-${Ptr} ${BuffDuration} 
   /varcalc ST-BuffRefresh-${Ptr} ${ST-BuffRefresh-${Ptr}}-50 
   /if (${DebugList.Find[spell]}) /echo ST-BuffRefresh-${Ptr} ${ST-BuffRefresh-${Ptr}} BuffDuration ${BuffDuration} 

   /varset Buff-${Ptr}-Text ${BuffType};${BuffCast};${BuffTarget} 
   /call ListAppendElement BuffPtrList ${Ptr} " " 
/return 

Sub BuffRefresh(int Ptr) 
   /call AddCast "${Buff-${Ptr}-Text.Arg[1,;]};${Buff-${Ptr}-Text.Arg[2,;]}" "${Buff-${Ptr}-Text.Arg[3,;]}" b-${Ptr} 
/return 

Sub Command-SelfBuff 
   /if (!${Defined[Param0]}) /return 
   /if (${Param0.Equal[off]}) { 
      /varset BuffSelfList 
      /return 
   } 
   /if (${DebugList.Find[spell]}) /echo Command-SelfBuff ${CommandParam} 
   /call RefineCast "${CommandParam}" 
   /if (${Macro.Return.Equal[0]}) /return 
   /varset CommandParam ${Macro.Return} 
   /if (${DebugList.Find[spell]}) /echo RefineCast Return ${Macro.Return} 
   /if (${CommandParam.NotEqual[0]}) { 
      /call CheckForBuffIcon ${Macro.Return.Arg[1,;]} "${Macro.Return.Arg[2,;]}" 
      /if (${DebugList.Find[spell]}) /echo CheckForBuffIcon Return ${Macro.Return} 
      /if (${Macro.Return}) { 
         /if (${BuffSelfIconList.Find[|${CommandParam}|]}) { 
            /call AddCast "${CommandParam}" "${Me.Name}" b-0 
         } else { 
            /call ListAppendElement BuffSelfIconList "${CommandParam}" | 
         } 
      } else { 
         /call AddCast "${CommandParam}" "${Me.Name}" b-0 
      } 
   } 
/return 

sub CheckSelfBuffs 
   /declare GenFor int local 
   /declare BuffType string local 
   /declare BuffName string local 
   /declare BuffSpell string local 
   /varset ST-CheckSelfBuffs 5s 
   /if (${BuffSelfIconList.Length}) { 
      /for GenFor 1 to ${Math.Calc[${BuffSelfIconList.Count[|]}+1]} 
         /varset BuffType ${BuffSelfIconList.Arg[${GenFor},|].Arg[1,;].Arg[1,-]} 
         /varset BuffName ${BuffSelfIconList.Arg[${GenFor},|].Arg[2,;]} 
         |/if (${DebugList.Find[spell]}) /echo Sub CheckSelfBuffs BuffSelfIconList ${BuffSelfIconList} BuffType ${BuffType} BuffName ${BuffName} 
         /call CheckForBuffIcon ${BuffType} "${BuffName}" 
         |/if (${DebugList.Find[spell]}) /echo CheckForBuffIcon Return ${Macro.Return} 
         /if (!${Macro.Return}) /call AddCast "${BuffType};${BuffName}" ${Me.Name} b-s 
      /next GenFor 
   } 
/return 

Sub CheckForBuffIcon(string BuffType,string BuffCast) 
   /declare BuffSpell string local 
   /if (${BuffType.Arg[1,-].Equal[spell]}) { 
      /varset BuffSpell ${Spell[${BuffCast}].Name} 
   } else /if (${BuffType.Arg[1,-].Equal[item]}) { 
      /varset BuffSpell ${FindItem[${BuffCast}].Spell.Name} 
   } else /if (${BuffType.Equal[alt]}) { 
      /varset BuffSpell ${AltAbility[${BuffCast}].Spell.Name} 
   } 
   /if (${TimedBuffList.Find[|${BuffSpell};]}) { 
      /call ListFindStringArg TimedBuffList "|${BuffSpell};" | 
      /if (${Me.Buff[${TimedBuffList.Arg[${Macro.Return},|].Arg[3,;]}].ID}) { 
         /return 1 
      } else { 
         /return 0 
      } 
   } 
   /if (${Me.Buff[${BuffSpell}].ID}) /return 1 
/return 0 

Sub Command-bufflist 
   /declare GenFor int local 
   /call ChatOut 1 "Buffs I have on myself now:" 
   /for GenFor 1 to 15 
      /if (${Me.Buff[${GenFor}].ID}) { 
         /call ChatOut 1 "${Me.Buff[${GenFor}].Name} with ${Me.Buff[${GenFor}].Duration.Minutes} minutes ${Me.Buff[${GenFor}].Duration.Seconds} seconds left." 
      } 
   /next GenFor 
   /if (${BuffPtrList.Length}) { 
      /call ChatOut 1 "Buffs I am timing for myself or others:" 
      /for GenFor 1 to ${Math.Calc[${BuffPtrList.Count[ ]}+1]} 
         /call ChatOut 1 "${GenFor}. ${Buff-${GenFor}-Text.Arg[1,;]} ${Buff-${GenFor}-Text.Arg[2,;]} for ${Spawn[${Buff-${GenFor}-Text.Arg[3,;]}]} to be cast in ${Math.Calc[${ST-BuffRefresh-${GenFor}}\600].Int} minutes ${Math.Calc[${ST-BuffRefresh-${GenFor}}%600/10].Int} seconds." 
      /next GenFor 
   } else { 
      /call ChatOut 1 "I am keeping up no other buffs at the moment." 
   } 
/return 


Sub Command-chainnuke 
   /if (${ChainNuke.Equal[${ChainNuke-DefaultValue}]}) /return 
   /declare NukeNum int local 1 
   /call StandardTarget "${CommandParam}" 
   :ChainNukeLoop 
      /if (!${Target.ID}) /return 
      /if (${Me.Gem[${ChainNuke.Arg[${NukeNum},|]}]}) /cast "${ChainNuke.Arg[${NukeNum},|]}" 
      /varcalc NukeNum ${NukeNum}+1 
      /if (!${ChainNuke.Arg[${NukeNum},|].Length}) /varset NukeNum 1 
   /goto :ChainNukeLoop 
/return 

Sub Command-chainstun 
   /if (${ChainStun.Equal[${ChainStun-DefaultValue}]}) /return 
   /call StandardTarget "${CommandParam}" 
   /if (!${Target.ID}) /return 
   /varset ChainStunNum 1 
   /call NextStun 
/return 

Sub Command-evac 
   /if (${EvacSpell.Equal[${EvacSpell-DefaultValue}]}) { 
      /call ChatOut 5 "Moving to you!" 
   } else { 
      /call ChatOut 5 "Moving to you and casting ${EvacSpell}!" 
   } 
   /varset CommandParam ${MasterName} 
   /call Command-moveto ${MasterName} 
   /call Command-anchor off 
   /if (!${EvacSpell.Equal[${EvacSpell-DefaultValue}]}) { 
      /if (${DebugList.Find[spell]}) /echo Command-evac "${EvacSpell}" ${Me.Name} heal 
      /call AddCast "${EvacSpell}" ${Me.Name} h-com 
   } 
/return 

Sub Command-loadlist(string Spellset) 
   /if (!${Defined[Spellset]}) /return 
   /memspellset ${Spellset} 
/return 

Sub Command-mana 
   /if (!${Me.Class.CanCast}) /return 
   /declare RoundMana int local ${Math.Calc[${Math.Calc[${Me.PctMana}/5].Int}*5].Int} 
   /if (${RoundMana}==100) { 
     /call ChatOut 2 "fm" 
   } else { 
     /call ChatOut 2 "${RoundMana}m" 
   } 

/return 

Sub Command-sn(string newSpell) 
   /declare snTarget string local 
   /call AssignCastTarget 0 
   /varset snTarget ${Macro.Return} 
   /if (!${Defined[newSpell]} && ${LastSn.Equal[NA]}) /return 
   /if (!${Defined[newSpell]}) /varset CommandParam "${LastSn}" 
   /if (${snTarget.Equal[0]}) { 
      /return 
   } 
   /varset LastSn ${CommandParam} 
   /if (${DebugList.Find[spell]}) /echo Command-sn "${CommandParam}" "${snTarget}" 
   /call AddCast "${CommandParam}" "${snTarget}" 
/return 

Sub Command-snt 
   /if (!${Defined[Param0]}) /return 
   /if (${Param0.Equal[on]} && ${LastSn.NotEqual[NA]}) /return 
   /declare sntCastText string local ${Param0} 
   /declare ParamCount int local 1 
   /declare sntTarget string local 0 
   /if (${Param0.Equal[on]}) { 
      /varset sntCastText ${LastSn} 
      /goto :Command-sntTargetStart 
   } 

   :Command-sntSpellLoop 
      /if (${Defined[Param${ParamCount}]}) { 
         /if (${Param${ParamCount}.Equal[on]}) /goto :Command-sntTargetStart 
         /varset sntCastText ${sntCastText} ${Param${ParamCount}} 
         /varcalc ParamCount ${ParamCount}+1 
         /goto :Command-sntSpellLoop 
      } 
   :Command-sntTargetStart 
   /varcalc ParamCount ${ParamCount}+1 
   /if (${Defined[Param${ParamCount}]}) { 
      /varset sntTarget ${Param${ParamCount}} 
      /varcalc ParamCount ${ParamCount}+1 
      :Command-sntTargetLoop 
         /if (${Defined[Param${ParamCount}]}) { 
            /varset sntTarget ${sntTarget} ${Param${ParamCount}} 
            /varcalc ParamCount ${ParamCount}+1 
            /goto :Command-sntTargetLoop 
         } 
   } 
   /if (${sntTarget.Equal[0]}) { 
      /if (${CombatTargetID}) { 
         /varset sntTarget id ${CombatTargetID} 
      } else /if (${Target.ID}) { 
         /varset sntTarget ${Target.Type} id ${Target.ID} 
      } else { 
         /varset sntTarget 0 
      } 
   } else { 
      /call AssignCastTarget "${sntTarget}" 
      /varset sntTarget ${Macro.Return} 
   } 
   /if (${DebugList.Find[spell]}) /echo Command-snt ${sntCastText} ${sntTarget} 
   /call AddCast "${sntCastText}" "${sntTarget}" 
   /varset LastSn ${sntCastText} 
/return 

Sub Command-spellgem 
   /if (!${Defined[Param0]}) { 
      /call ChatOut 3 "I use Gem ${SpellGem} when I need to mem new spells." 
      /return 
   } 
   /varset SpellGem ${Param0} 
   /call ChatOut 3 "I will now use Gem ${SpellGem} when I need to mem new spells." 
/return 




|||| Called Subs 

Sub AddCast(string AddCastText,string AddCastTarget,string AddCastInfo) 
   /declare AddCastType string local 
   /declare myvar string local
   /varset myvar " item spell alt "

   /if (!${Defined[AddCastTarget]}) /declare AddCastTarget string local ${Target.Name} 
   /if (!${Defined[AddCastInfo]}) /declare AddCastInfo string local 0 
   /if (!${myvar.Find[ ${AddCastText.Lower.Arg[1,;].Arg[1,-]} ]}) { 
      /if (${DebugList.Find[spell]}) /echo AddCastText ${AddCastText} 
      /call RefineCast "${AddCastText}" 
      /if (${Macro.Return.Equal[0]}) /return 
      /varset AddCastText ${Macro.Return} 
   } 
/varset myvar " pb ae self ae pc v2 group v1 "
   /if (${AddCastText.Arg[1,;].Arg[1,-].Equal[spell]}) { 
      /if (${myvar.Find[|${Spell[${AddCastText.Arg[2,;]}].TargetType.Lower}|]}) { 
         /varset AddCastTarget 0 
      } 
   } else /if (${AddCastText.Arg[1,;].Arg[1,-].Equal[item]}) { 
      /if (${myvar.Find[|${FindItem[${AddCastText.Arg[2,;]}].Spell.TargetType.Lower}|]}) { 
         /varset AddCastTarget 0 
      } 
   } 
/varset myvar " corpse pc npc pet assist- 0 "
   /if (!${myvar.Find[ ${AddCastTarget.Arg[1].Lower} ]}) { 
      /call RefineTarget "${AddCastTarget}" 
      /varset AddCastTarget ${Macro.Return} 
   } 
   /if (${DebugList.Find[spell]}) /echo AddCastText ${AddCastText}  AddCastTarget ${AddCastTarget} AddCastInfo ${AddCastInfo} 
   /if (!${CastQueue.Find[${AddCastText};${AddCastTarget};${AddCastInfo}]}) { 
      /if (${AddCastInfo.Left[1].Equal[h]}) { 
         /call ListPrependElement CastQueue "${AddCastText};${AddCastTarget};${AddCastInfo}" | 
      } else { 
         /call ListAppendElement CastQueue "${AddCastText};${AddCastTarget};${AddCastInfo}" | 
      } 
   } 
   /if (${DebugList.Find[spell]}) /echo CastQueue ${CastQueue} 
/return 

Sub CastFromQueue 
   /if (${Merchant.Open} || ${Window[BigBankWnd]}) /return 
   /declare ArgNum int local 0 
   /if (!${CastStep}) { 
      /if (!${CastQueue.Length}) /return 
      /if (${CastQueue.Find[assist-]}) { 
         /call Assist ${MasterName} 
         /if (${Target.ID}) { 
            /call RefineTarget "${Target.Name}" 
            /call StringReplaceAll CastQueue assist- "${Macro.Return}" 
         } else { 
            /call ChatOut 4 "Unable to assist you to find a target to cast on." 
         } 
      } 
      :gNextinQueue 
      /varcalc ArgNum ${ArgNum}+1 
      /if (!${Toggle-dobuff} && ${CastQueue.Arg[${ArgNum},|].Arg[4,;].Arg[1,-].Equal[b]}) /goto :gNextinQueue 
      /if (!${CastQueue.Arg[${ArgNum},|].Length}) /return 
      /varset CastType ${CastQueue.Arg[${ArgNum},|].Arg[1,;]} 
      /varset CastName ${CastQueue.Arg[${ArgNum},|].Arg[2,;]} 
      /varset CastTarget ${CastQueue.Arg[${ArgNum},|].Arg[3,;]} 
      /varset CastInfo ${CastQueue.Arg[${ArgNum},|].Arg[4,;]} 
      /if (${DebugList.Find[spell]}) /echo CastType ${CastType} CastName ${CastName} CastTarget ${CastTarget} 
      /varset CastTimer 0 
      /varset CastStep 1 
      /varset CastOldTargetID 0 
   } else /if (${Toggle-stopforheals} && ${CastQueue.Arg[1,|].Arg[4,;].Left[1].Equal[h]} && !${CastInfo.Left[1].Equal[h]}) { 
      /if (${Me.Casting.ID}) /stopcast 
      /varset CastStep 0 
      /call ChatOut 3 "Interrupted ${CastType.Arg[1,-]}: ${CastName}.  I need to heal somebody instead!" 
      /varset CastLastResult SPELL_IntentionalInterruption 
      /return 
   } 

   |/if (${DebugList.Find[spell]}) /echo CastType CastName CastStep ${CastType} ${CastName} ${CastStep} 
   /if (${CastQueue.Length}) /call Cast 
/return 

Sub Cast 
/declare myvar string local
/varset myvar " 1 2 3 4 5 6 7 "
   /if (${myvar.Find[ ${CastStep} ]}) { 
      |/echo going to sub 
      /goto :gCast-${CastStep} 
   } else { 
      /if (${DebugList.Find[spell]}) /echo CastStep = ${CastStep} -- No corresponding goto found.  Returning. 
      /varset CastStep 5 
      /return 
   } 
   | Wait for spell to pop up, stand up, and target correctly. 
:gCast-1 
   |/if (${DebugList.Find[spell]}) /echo Cast 1 ${CastName} 
   /if (${CastTimer}) /return 
   /varset CastLastResult CHECKING_Casting 
   /if (${Me.Casting.ID}) /return 
    
   | Check the target conditions if a target required. 
   /if (!${CastTarget.Equal[0]}) { 
      /if (!${Spawn[${CastTarget}].ID}) { 
         /if (${CastInfo.Arg[1,-].NotEqual[b]} || ${CastInfo.Arg[1,-].Equal[b-0]}) { 
            /call ChatOut 3 "I couldn't find the target for ${CastType.Arg[1,-]} ${CastName}." 
         } 
         /varset CastStep 5 
         /varset CastLastResult TARGET_NOTEXIST 
         /return 
      } 
      /if (!${NearestSpawn[${CastTarget} radius ${MaxTargetRange}].ID}) { 
         /call ChatOut 3 "${NearestSpawn[${CastTarget}]} is out of range of ${CastType.Arg[1,-]} ${CastName}." 
         /varset CastStep 5 
         /varset CastLastResult TARGET_OUTOFRANGE 
         /return 
      } 
      /if (${Target.ID}!=${NearestSpawn[${CastTarget}].ID}) { 
         /varset CastOldTargetID ${Target.ID} 
         /squelch /target ${CastTarget} 
         /delay 2s ${Target.ID}==${NearestSpawn[${CastTarget}].ID} 
         /varset CastTimer 5 
         /if (${Target.ID}!=${NearestSpawn[${CastTarget}].ID}) { 
            /call ChatOut 3 "Wasn't able to target: ${CastTarget}" 
            /varset CastStep 5 
            /varset CastLastResult TARGET_CANNOTTARGET 
            /return 
         } 
      } 
   } 
    
   /varset CastLastResult CHECKING_Moving 
   /if (${CastType.Arg[1,-].Equal[spell]}) { 
      /if (${Spell[${CastName}].MyCastTime}>0.1 && ${Me.Moving} && ${Me.Class.Name.NotEqual[Bard]}) { 
         /varset CastStep 2 
         /return 
      } 
      /varset CastLastResult CHECKING_SpellMemmed 
      /if (!${Me.Gem[${CastName}]}) { 
         /varset CastStep 3 
         /return 
      } 
      /varset CastLastResult CHECKING_SpellUp 
      /if (!${Me.SpellReady[${CastName}]}) /return 
   } else /if (${CastType.Arg[1,-].Equal[item]}) { 
      /if (${FindItem[${CastName}].CastTime}>0.1 && ${Me.Moving} && ${Me.Class.Name.NotEqual[Bard]}) { 
         /varset CastStep 2 
         /return 
      } 
   } 
    
   /varset CastLastResult CHECKING_Standing 
   /if (!${Me.Standing}) { 
      /stand 
   } 
   /if (${Toggle-sitaftercast}) /varset SitTimer 1140m 
   /varset CastLastResult CHECKING_Target 
   | Not accounting for items or alt yet. 
    
   | Announce the casting. 
   /if (${CastTarget.Equal[0]}) { 
      /call ChatOut 5 "Casting ${If[${CastInfo.Arg[1,-].Equal[b]},buff ,]}${CastType.Arg[1,-]} ${CastName}." 
   } else { 
      /call ChatOut 5 "Casting ${If[${CastInfo.Arg[1,-].Equal[b]},buff ,]}${CastType.Arg[1,-]} ${CastName} on ${Target.CleanName}." 
   } 
    
   | Cast the spell or item or alt. 
   /if (${CastType.Arg[1,-].Equal[spell]}) { 
      /cast "${CastName}" 
   } else /if (${CastType.Arg[1,-].Equal[item]}) { 
      /cast item "${CastName}" 
   } else { 
      /alt activate ${AltAbility[${spellName}].ID} 
   } 

   /varset CastLastResult CAST_StillCasting 
   /varset CastStep 4 
   /varset CastTimer 0 
   /return 
   |Stop moving 
:gCast-2 
   /if (${Me.Moving}) { 
      /if (!${CastTimer}) { 
         /call ChatOut 3 "Can't cast since I'm moving." 
         /keypress forward 
         /keypress back 
         /varset CastTimer 8 
      } 
      /return 
   } 
   /varcalc CastStep 1 
   /varset CastTimer 0 
   /return 
   | Memorize the spell 
:gCast-3 
   /if (!${Me.Gem["${CastName}"]}) { 
      /if (!${CastTimer}) { 
         /varset SpellNeedToRemem 1 
         /if (${CastType.Arg[2,-].Length}) { 
            /memspell ${CastType.Arg[2,-]} "${CastName}" 
            /call ChatOut 6 "Memorizing spell: ${CastName} in slot ${CastType.Arg[2,-]}." 
         } else { 
            /memspell ${SpellGem} "${CastName}" 
            /call ChatOut 6 "Memorizing spell: ${CastName} in default slot ${SpellGem}." 
         } 
         /varset CastTimer 5s 
      } 
      /return 
   } 
   /varset CastStep 1 
   /varset CastTimer 0 
   /return 
   | Wait for spell to finish 
:gCast-4 
   /if (${Me.Casting.ID}) { 
      /if (!${Me.Mount.ID} && !${Spawn[${CastTarget} radius ${MaxTargetRange}].ID} && ${CastTarget.NotEqual[0]}) { 
         /stopcast 
         /varset CastStep 6 
         /call ChatOut 3 "Interrupted ${CastType.Arg[1,-]}: ${CastName}.  Target ${NearestSpawn[${CastTarget}].CleanName} died, poofed, or came back to life!" 
         /varset CastLastResult SPELL_IntentionalInterruption 
         /return 
      } 
      /if (${Toggle-stopifhealed} && ${CastInfo.Left[1].Equal[heal]} && ${CastTarget.NotEqual[0]}) { 
        
        
         /if (${Spawn[${CastTarget}].Type.Equal[pet]}) { 
            /if (${Spawn[${CastTarget}].PctHPs}>${PetPctHeal}+5) { 
               /varset CastStep 6 
            } 
         } else /if (${TankList.Find[${Spawn[${CastTarget}].Class}]}) { 
            /if (${Spawn[${CastTarget}].PctHPs}>${TankPctHeal}+5) { 
               /varset CastStep 6 
            } 
         } else /if (${CasterList.Find[${Spawn[${CastTarget}].Class}]}) { 
            /if (${Spawn[${CastTarget}].PctHPs}>${CasterPctHeal}+5) { 
               /varset CastStep 6 
            } 
         } 
         /if (${CastStep}==6) { 
            /stopcast 
            /call ChatOut 3 "Interrupted ${CastType.Arg[1,-]}: ${CastName}.  ${NearestSpawn[${CastTarget}].CleanName} was healed while I was casting!" 
            /varset CastLastResult SPELL_IntentionalInterruption 
         } 
      } 
      /return 
   } 
   /varcalc CastStep ${CastStep}+1 
   /return 
   | Wait for cast result 
:gCast-5 
   /if (${CastTimer.OriginalValue}<>2) { 
      /varset CastTimer 2 
      /return 
   } 
   /if (${CastTimer}==0) { 
      /varset CastTimer 0 
      /varcalc CastStep ${CastStep}+1 
   } 
   /return 
   | Delete old spell as cast and update status to successful unless otherwise. 
:gCast-6 
   /if (${CastLastResult.Equal[CAST_StillCasting]}) /varset CastLastResult CAST_Successful 
   /if (${CastInfo.Arg[1,-].Equal[b]} && ${CastInfo.Arg[2,-].NotEqual[s]}) { 
      /call BuffResult ${CastType} "${CastName}" "${CastTarget}" ${CastInfo.Arg[2,-]} 
   } 
   /if (${CastOldTargetID}) /squelch /target id ${CastOldTargetID} radius ${MaxTargetRange} 
   /if (${DebugList.Find[spell]}) /echo CastLastResult ${CastLastResult} 
   /if (${Toggle-remem} && ${SpellNeedToRemem}) { 
      /memspellset ${DefaultSpellSet} 
      /call ChatOut 6 "Re-memorizing original spells." 
      /varcalc CastStep ${CastStep}+1 
      /return 
   } 
   /call ListDelbyName CastQueue "${CastType};${CastName};${CastTarget};${CastInfo}" | 
   /varset CastStep 0 
   /if (${Toggle-sitaftercast}) /varset SitTimer ${DelayBeforeSit} 
   /return 
   | Wait until spells are rememmed to continue 
:gCast-7 
   /if (${Window[SpellBookWnd].Open}) /return 
   /call ChatOut 6 "Done memorizing original spells." 
   /varset SpellNeedToRemem 0 
   /if (${Toggle-sitaftercast}) /varset SitTimer ${DelayBeforeSit} 
   /call ListDelbyName CastQueue "${CastType};${CastName};${CastTarget};${CastInfo}" | 
   /varset CastStep 0 
/return 

Sub AssignCastTarget(string ACTarget) 
   /if (!${Defined[ACTarget]} || !${ACTarget.Length} || ${ACTarget.Equal[0]}) { 
      /if (${CastStep}==1 || ${Me.Casting.ID}) { 
         /return assist- 
      } else { 
         /call Assist ${MasterName} 
         /if (${Target.ID}) { 
            /return id ${Target.ID} 
         } else { 
            /call ChatOut 4 "Unable to /assist you to find a target to cast on." 
            /return 0 
         } 
      } 
   } else /if (${ACTarget.Equal[yourself]} || ${ACTarget.Equal[${Me.CleanName}]}) { 
      /return pc ${Me.CleanName} 
   } else /if (${ACTarget.Equal[me]} || ${ACTarget.Equal[${MasterName}]}) { 
      /return pc ${MasterName} 
   } 
/return ${ACTarget} 

Sub CheckCann 
   /if (!${Me.Moving}) { 
      /if (${Me.CurrentMana}<${Me.MaxMana}-1066 && ${Me.CurrentHPs}>${Me.MaxHPs}\5+1924 && ${CannAATimer}<=0) { 
         /alt activate 47 
         /varset CannAATimer 3m 
      } 
      /if (${Me.PctMana}<95 && ${Me.PctHPs}>=${CanniLimit} && ${CannTimer}<=0 && !${CastQueue.Length}) { 
         /call AddCast "${CanniSpell}" ${Me.Name} buff 
         /varset CannTimer 1 
      } 
   } 
/return 

Sub CheckMana 
   /if (${LomTimer}<=0) { 
      /if (${Me.PctMana}<${LomPct}) { 
         /call ChatOut 5 "${LomMsg}" 
         /varset LomTimer 2m 
      } 
   } 
/return 

Sub CheckYaulp 
   /if (!${Me.Moving}) { 
      /if ((${Me.PctMana}<95 || ${CombatTargetID}) && !${Me.Buff["${YaulpSpell}"].ID}) { 
         /if (${DebugList.Find[spell]}) /echo CheckYaulp "${YaulpSpell}" "${Me.Name}" 
         /call AddCast "${YaulpSpell}" ${Me.Name} buff 
      } 
   } 
/return 

Sub NextStun 
   /if (!${Target.ID}) /return 
   :JumpStunSpell 
      /if (${Me.Gem[${ChainStun.Arg[${ChainStunNum},|]}]}) { 
         /cast "${ChainStun.Arg[${ChainStunNum},|]}" 
         /varset ChainStunTime 50 
      } else { 
         /varcalc ChainStunNum ${ChainStunNum}+1 
         /goto :JumpStunSpell 
      } 
   /varcalc ChainStunNum ${ChainStunNum}+1 
   /if (!${ChainStun.Arg[${ChainStunNum},|].Length}) /varset ChainStunNum 1 
/return 

Sub RefineCast(string RCText) 
   /declare RCType string local ${RCText.Arg[1]} 
   /declare RCName string local ${RCText.Right[-${RCType.Length}]} 
/declare myvar string local
/varset myvar " gem1 gem2 gem3 gem4 gem5 gem6 gem7 gem8 gem9 "
   /if (${myvar.Find[ ${RCType.Lower} ]}) { 
      /varset RCType spell-${RCType.Right[1]} 
      /varset RCName ${RCName.Right[-${RCName.Arg[1].Length}]} 
   } 
   /if (${RCType.Arg[1,-].Equal[spell]}) { 
      /if (!${Int[${Me.Book[${RCName}]}]}) { 
         /call ChatOut 3 "Spell: ${RCName} not found in your book." 
         /return 0 
      } 
      /return ${RCType};${Spell[${RCName}]} 
   } 
   /if (${RCType.Equal[slot]}) { 
      /varset RCType item-${RCName.Arg[1]} 
      /varset RCName ${RCName.Right[-${RCName.Arg[1].Length}]} 
   } 
   /if (${RCType.Arg[1,-].Equal[item]}) { 
      /if (!${FindItem[${RCName}].InvSlot}) { 
         /call ChatOut 3 "Cannot find item: ${RCText} " 
         /return 0 
      } 
      /return ${RCType};${FindItem[${RCName}]} 
   } 
   /if (${RCType.Equal[alt]}) { 
      /if (!${AltAbility[${RCName}].ID}) { 
         /call ChatOut 3 "Do not understand Alt Ability: ${RCText} " 
         /return 0 
      } 
      /return ${RCType};${AltAbility[${RCName}]} 
   } 
   /if (!${Me.Book[${RCText}]}) { 
      /if (${DebugList.Find[spell]}) /echo Name |${RCText}| 
      /call ChatOut 3 "Spell: ${RCText} not found in your book." 
      /return 0 
   } 
/return spell;${Spell[${RCText}]} 

Sub RefineTarget(string RFTarget) 
   /if (${RFTarget.Equal[assist-]}) /return assist- 
   /if (${NearestSpawn[pc ${RFTarget} radius ${MaxTargetRange}].ID}) { 
      /varset RFTarget pc ${NearestSpawn[pc ${RFTarget}].Name} 
   } else { 
      /varset RFTarget ${NearestSpawn[${RFTarget}].Type} id ${NearestSpawn[${RFTarget}].ID} 
   } 
/return ${RFTarget} 

|||| Events 
Sub Event_CastFizzle 
   /if (${CastStep}) { 
      /varset CastStep 0 
      /varset CastLastResult CAST_Fizzled 
   } 
/return 

Sub Event_CastInterrupt 
   /if (${CastStep} && !${CastLastResult.Equal[SPELL_IntentionalInterruption]}) { 
      /varset CastStep 0 
      /varset CastLastResult CAST_Interrupted 
   } 
/return 

Sub Event_CastNoMana 
   /if (${CastStep}) { 
      /varset CastLastResult CAST_CastNoMana 
      /if (${IsPally}) { 
         /varset CastLastResult CAST_CastNoMana 
         /if (${CastTimer}==0) { 
            /call ChatOut 5 "${MasterName} I am OOM!" 
            /varset CastTimer 10s 
            /return 
         } 
      } 
      /call ChatOut 5 "OOM. Medding 13 seconds and trying again. " 
      /if (!${Me.Sitting} && !${DoMelee}) /sit 
      /varset CastTimer 13s 
   } 
/return 

Sub Event_CastResist 
   /if (${CastStep}) { 
      /varset CastStep 6 
      /if (${CastLastResult.Equal[CAST_StillCasting]}) { 
         /varset CastLastResult CAST_Resisted 
         /call ChatOut 3 "${Target.CleanName} resisted ${CastType} ${CastName}." 
      } 
   } 
/return 

Sub Event_CastTooFar 
   /if (${CastStep}) { 
      /call ChatOut 3 "${NearestSpawn[${CastTarget}]} is out of range" 
      /varset CastStep 6 
      /varset CastLastResult CAST_CastTooFar 
   } 
/return 

Sub Event_Collapse 
   /if (${CastStep}) { 
      /varset CastStep 0 
   } 
/return 

Sub Event_Distracted 
   /if (${CastStep}) { 
      /call ChatOut 5 "I can't cast. I'm too distracted. " 
      /varset CastStep 6 
      /varset CastLastResult CAST_Distracted 
   } 
/return 

Sub Event_ImmuneRoot 
   /if (${CastStep}) { 
      /call ChatOut 3 "Cannot Root or Snare this Target!" 
      /varset CastStep 6 
      /varset CastLastResult CAST_ImmuneRoot 
   } 
/return 

Sub Event_ImmuneSlow 
   /if (${CastStep}) { 
      /call ChatOut 3 "Cannot Slow this Target (Immune)!" 
      /varset CastStep 6 
      /varset CastLastResult CAST_ImmuneSlow 
   } 
/return 

Sub Event_MissedNote 
   /if (${CastStep}) { 
      /varset CastStep 0 
   } 
/return 

Sub Event_NoLOS 
   /if (${CastStep} && ${CastStep}!=6) { 
      /call ChatOut 3 "I can't see my target. " 
      /varset CastStep 6 
      /varset CastLastResult CAST_NoLOS 
   } 
/return 

Sub Event_NoMem 
   /if (${CastStep}) { 
      /call ChatOut 5 "That spell is not memed. " 
      /varset CastStep 0 
      /varset CastLastResult CAST_NoMem 
   } 
/return 

Sub Event_NoOverWrite 
   /if (${CastStep}) { 
      /call ChatOut 3 "The spell won't take hold on the target." 
      /varset CastStep 6 
      /varset CastLastResult CAST_NoOverWrite 
   } 
/return 

Sub Event_NoTarget 
   /if (${CastStep}) { 
      /call ChatOut 3 "I don't know what target to cast on. " 
      /varset CastStep 6 
      /varset CastLastResult CAST_NoTarget 
   } 
/return 

Sub Event_Recovered 
      /varset CastStep 0 
   /if (${CastStep}) { 
      /varset CastLastResult CAST_Recovered 
   } 
/return 

Sub Event_RootOff 
   /call ChatOut 5 "Root has worn off. " 
/return 

Sub Event_Sitting 
   /if (${CastStep}) { 
      /varset CastStep 0 
      /varset CastLastResult CAST_NotStanding 
   } 
/return 

Sub Event_Stunned 
   /if (${CastStep}) { 
      /call ChatOut 5 "I'm STUNNED. Waiting a second to try again." 
      /varset CastStep 0 
      /varset CastTimer 1s 
      /varset CastLastResult CAST_Stunned 
   } 
/return

Sub Event_Slowed
   /if (${CastStep}) { 
      /varset CastStep 6 
      /if (${CastLastResult.Equal[CAST_StillCasting]}) { 
         /varset CastLastResult CAST_Successful 
         /call ChatOut 3 "${Target.CleanName} has been SLOWED." 
      } 
   } 
/return 

Code: Select all

|bothealer.inc 
|Bot healer module. 
|Version 13.4.0 
|Date:07/08/2005 
| 
||** 
[bothealer] 
version=13.4.0 
**|| 

Sub Init-Healer 
/declare cmds-HEALER string outer Healer: 

|For each command 
|/call AddCommand "Command Section" "Command Phrase" "Called Sub" 
|Command Section - where the command will be listed in response to the cmd phrase 
|Command Phrase to trigger bot - End User can change to suit prefferences 
|Called Sub - Routine to execute in response to Command Phrase 
/call AddCommands heal resetwatch setcasterheal setcasterhealpct 
/call AddCommands setdefaultheal setpatchheal setpetheal setpethealpct 
/call AddCommands settankheal settankhealpct watchtarget 

|declare Vars 
/declare CasterList string outer 
/declare HealTargets[21] int outer 0 
/declare LowHealthCheck int outer 0 
/declare TankList string outer 
/declare WatchTargetCount int outer 0 
/declare WatchTargetIDs[15] int outer 0 
/declare WatchTargets[15] string outer 
/declare WatchWaitCount int outer 0 

|Timers 
/declare CastMsgTimer1 timer outer 
/declare CastMsgTimer2 timer outer 

|Load Settings 
/call AddToggle doheal on return "I will not heal anyone unless commanded." "I will watch and cast heal spells as necessary." 
/call LoadSetting CasterSpell string CasterSpell "Name of heal spell autoheal uses on Non Tanks" 
/call LoadSetting CasterPctHeal int CasterPctHeal 70 
/call LoadSetting DefaultHealSpell string DefaultHealSpell "Name of Default Heal Spell" 
/call LoadSetting HealCasterMsg string HealCasterMsg "Healing %t" 
/call LoadSetting HealPetMsg string HealPetMsg "Healing %t" 
/call AddToggle healpets off return "I will not heal the pets." "I will heal the pets." 
/call LoadSetting HealTankMsg string HealTankMsg "Big Heal on %t" 
/call LoadSetting IsPally bool IsPally 0 
/call LoadSetting PalGrpPct int PalGrpPct 81 
/call LoadSetting PalHealPct int PalHealPct 81 
/call LoadSetting PallyGroupSpell string PallyGroupSpell "Name of Pally Group Heal Spell" 
/call LoadSetting PallyHealSpell string PallyHealSpell "Name of Pally Heal Spell" 
/call LoadSetting PalHealMsg string PalHealMsg "Healing %t" 
/call AddToggle patchheal on return "I'm not a patch Healer." "I'm a patch Healer." 
/call LoadSetting PatchHealMsg string PatchHealMsg "Patch Healing %t" 
/call LoadSetting PatchSpell string PatchSpell "Name of Patch Heal Spell" 
/call LoadSetting PetPctHeal int PetPctHeal 51 
/call LoadSetting PetSpell string PetSpell "Name of Pet Heal Spell" 
/call LoadSetting ReportAutoHeal bool ReportAutoHeal 1 
/call LoadSetting TankSpell string TankSpell "Name of heal spell autoheal uses on Tanks" 
/call LoadSetting TankPctHeal int TankPctHeal 51 
/call AddToggle stopifhealed on return "I will not interrupt heal spells even if target is healed by someone else." "I will interrupt heal spells if target is already above the heal %." 
/call AddToggle stopforheals off return "I will not interrupt other spells for heal spells." "I will interrupt other spells for heal spells." 



/varset TankList ${Ini[${IniFile},Healer,TankList,NotFound]} 
/varset CasterList ${Ini[${IniFile},Healer,CasterList,NotFound]} 
/if (${TankList.Equal[NotFound]} && ${CasterList.Equal[NotFound]}) { 
/ini ${IniFile} Healer TankList "Warrior|Shadow Knight|Paladin|Monk|Beastlord|Ranger|Shaman|Berserker" 
/ini ${IniFile} Healer CasterList "Necromancer|Wizard|Enchanter|Magician|Rogue|Druid|Cleric|Bard" 
/varset TankList Warrior|Shadow Knight|Paladin|Monk|Beastlord|Ranger|Shaman|Berserker 
/varset CasterList Necromancer|Wizard|Enchanter|Magician|Rogue|Druid|Cleric|Bard 
} 
/return 

Sub HealerMain 
/call CheckGrpHealth 
/call PalGrpHealChk 
/call PalHealChk 
/return 

||||| Do Subs 
Sub Command-setcasterheal 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "I heal non tanks with ${CasterSpell}." 
/return 
} 
/varset CasterSpell ${CommandParam} 
/call ChatOut 3 "I'll start using ${CasterSpell} on non tanks." 
/return 

Sub Command-setcasterhealpct 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "I heal non tanks at ${CasterPctHeal} %." 
/return 
} 
/varset CasterPctHeal ${Param0} 
/call ChatOut 3 "I heal non tanks at ${CasterPctHeal} %." 
/return 

Sub Command-setdefaultheal 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "I usualy heal with ${DefaultHealSpell}." 
/return 
} 
/varset DefaultHealSpell ${CommandParam} 
/call ChatOut 3 "I'll start using ${DefaultHealSpell}." 
/return 

Sub Command-heal 
/if (${DefaultHealSpell.Equal[${DefaultHealSpell-DefaultValue}]}) /return 
/call AssignCastTarget "${CommandParam}" 
/declare HealTarget string local ${Macro.Return} 
|/call ChatOut 3 "Casting ${DefaultHealSpell} on ${NearestSpawn[${HealTarget}]}." 
/call AddCast "${DefaultHealSpell}" "${HealTarget}" h-com 
/return 

Sub Command-setpatchheal 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "I use ${PatchSpell} for patch heals." 
/return 
} 
/varset PatchSpell ${CommandParam} 
/call ChatOut 3 "I'll use ${PatchSpell} for patch heals now." 
/return 

Sub Command-setpetheal 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "My pet heal is ${PetSpell}." 
/return 
} 
/varset PetSpell ${CommandParam} 
/call ChatOut 3 "I'll use ${PetSpell} to heal pets." 
/return 

Sub Command-setpethealpct 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "I heal pets at ${PetPctHeal} %." 
/return 
} 
/varset PetPctHeal ${Param0} 
/call ChatOut 3 "I heal pets at ${PetPctHeal} %." 
/return 

Sub Command-settankheal 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "My tank heal is ${TankSpell}" 
/return 
} 
/varset TankSpell ${CommandParam} 
/call ChatOut 3 "I'll use ${TankSpell} to heal tanks." 
/return 

Sub Command-settankhealpct 
/if (!${Defined[Param0]}) { 
/call ChatOut 3 "I heal tanks at ${TankPctHeal} %." 
/return 
} 
/varset TankPctHeal ${Param0} 
/call ChatOut 3 "I heal tanks at ${TankPctHeal} %." 
/return 

Sub Command-watchtarget 
/declare myvar string local ${Param0}
/if (${myvar.Equal[off]}) { 
/varset WatchTargetCount 0 
/return 
} 
/squelch /target clear 
/call delay 5 
/call StandardTarget "${CommandParam}" 
/if (${Target.ID}) { 
/varcalc WatchTargetCount ${WatchTargetCount}+1 
/varset WatchTargets[${WatchTargetCount}] ${Target.CleanName} 
/varset WatchTargetIDs[${WatchTargetCount}] ${Target.ID} 
/call ChatOut 3 "Now watching the health of ${Target.CleanName}." 
} else { 
/call ChatOut 3 "Who did you want me to watch?" 
} 
/return 

||||| Called Subs 

Sub CastHeal(int TarID,string HealSpell,string castMsg) 
/if (!${CastMsgTimer1}) { 
|/if (${ReportAutoHeal}) /g ${castMsg} 
/varset CastMsgTimer1 50 
} 
/call AddCast "${HealSpell}" "id ${TarID}" "heal" 
/return 

Sub CheckGrpHealth 
/declare HealCount int local 0 
/declare BadIDs int local 0 
/declare SaveCombatStat int local 0 
/declare SaveCombatID int local 0 
/declare QuickID int local 0 
/declare tempvar int local 0 
/if (!${Toggle-doheal}) /return 
/if (${IsPally}) /return 
/varset HealCount ${Group.Members} 
/for tempvar 1 to ${Group.Members} 
/varset HealTargets[${tempvar}] ${Group.Member[${tempvar}].ID} 
/next tempvar 
/varcalc HealCount ${HealCount}+1 
/varset HealTargets[${HealCount}] ${Me.ID} 
/if (${WatchWaitCount}>10 && ${WatchTargetCount}>0) { 
/for tempvar 1 to ${WatchTargetCount} 
/varcalc HealCount ${HealCount}+1 
/varset HealTargets[${HealCount}] ${WatchTargetIDs[${tempvar}]} 
/next tempvar 
/varset WatchWaitCount 0 
} 
/varcalc WatchWaitCount ${WatchWaitCount}+1 
/for tempvar 1 to ${HealCount} 
/if (${tempvar}>${Group.Members} && ${Target.ID}!=${HealTargets[${tempvar}]} && ${HealTargets[${tempvar}]}!=${Me.ID}) { 
/squelch /target id ${HealTargets[${tempvar}]} 
/delay 5 
/if (${Target.ID}!=${HealTargets[${tempvar}]}) { 
/varcalc BadIDs ${BadIDs}+1 
} 
} 
/varset QuickID ${HealTargets[${tempvar}]} 
/if (${Spawn[${QuickID}].PctHPs}<${TankPctHeal} && ${Spawn[${QuickID}].State.NotEqual[DEAD]}) { 
/if (${TankList.Find[${Spawn[${QuickID}].Class}]}) { 
/if (${Spawn[${QuickID}].PctHPs}<${Math.Calc[${TankPctHeal}/2]} && ${Toggle-patchhealer}) /call PatchHeal ${QuickID} 
/call CastHeal ${QuickID} "${TankSpell}" "${HealTankMsg}" 
} 
} 
/if ((${Spawn[${QuickID}].PctHPs}<${CasterPctHeal})&&(${Spawn[${QuickID}].State.NotEqual[DEAD]})) { 
/if (${CasterList.Find[${Spawn[${QuickID}].Class}]}) { 
/if ((${Spawn[${QuickID}].PctHPs}<${Math.Calc[${CasterPctHeal}/2]})&&(${Toggle-patchhealer})) /call PatchHeal ${QuickID} 
/call CastHeal ${QuickID} "${CasterSpell}" "${HealCasterMsg}" 
} 
} 
/if (${Toggle-healpets} && ${Spawn[${QuickID}].Class.PetClass} && ${Spawn[${QuickID}].Pet.ID}) { 
/if (${Spawn[${QuickID}].Pet.PctHPs}<${PetPctHeal}) { 
/call CastHeal ${Spawn[${QuickID}].Pet.ID} "${PetSpell}" "${HealPetMsg}" 
} 
} 
/next tempvar 
/if (${CombatTargetID}) /call Target "id ${CombatTargetID}" 
/if (${BadIDs}>0) /call ResetWatchTargets 
/return 

Sub PalHealChk 
/declare tempvar int local 0 
/if (!${IsPally}) /return 
/if (!${Toggle-doheal}) /return 
/for tempvar 0 to ${Group.Members} 
/if ((${Group.Member[${tempvar}].PctHPs}<${PalHealPct})&&(${Group.Member[${tempvar}].State.NotEqual[DEAD]})) /call PallyHeal ${Group.Member[${tempvar}].ID} 
/next tempvar 
/return 

Sub PalGroupheal 
/if (${Me.Sitting}) /stand 
/if (${ReportAutoHeal}) /g ${PalHealGrpMsg} 
/call AddCast "${PallyGroupSpell}" 0 heal 
/return 

Sub PalGrpHealChk 
/declare tempvar int local 1 
/if (!${IsPally}) /return 
/if (!${Toggle-doheal}) /return 
/if (${Me.PctHPs}>${PalHealPct}) { 
/varset LowHealthCheck 0 
} else { 
/varset LowHealthCheck 1 
} 
/for tempvar 1 to ${Group.Members} 
/if ((${Group.Member[${tempvar}].PctHPs}<${PalHealPct})&&(${Group.Member[${tempvar}].State.NotEqual[DEAD]})) /varcalc LowHealthCheck ${LowHealthCheck}+1 
/if (${LowHealthCheck}>=3) { 
/call PalGroupheal 
/return 
} 
/next tempvar 
/return 

Sub PallyHeal(int TarID) 
/if (${CombatTargetID}) /return 
/if (${TarID}==${Me.ID}) /target myself 
/if (${TarID}!=${Me.ID}) /squelch /target id ${TarID} 
/g ${PalHealMsg} 
/call AddCast "${PallyHealSpell}" 0 heal 
/return 

Sub Patchheal(int TarID) 
/if (${CastMsgTimer1}<=0) { 
|/if (${ReportAutoHeal}) /g ${PatchHealMsg} 
/varset CastMsgTimer1 50 
} 
/if (${Me.Gem[${PatchSpell}]}) /call AddCast "${PatchSpell}" "id ${TarID}" "heal" 
/return 

Sub ResetWatchTargets 
/declare counter int local 
/for counter 1 to ${WatchTargetCount} 
/squelch /target PC ${WatchTargets[${counter}]} 
/call Delay 25 
/if (${Target.CleanName.Equal[${WatchTargets[${counter}]}]}) { 
/varset WatchTargetIDs[${counter}] ${Target.ID} 
} else { 
/call ChatOut 5 "I failed to find ${WatchTargets[${counter}]} in the zone." 
} 
/next counter 
/return

Code: Select all

|botcore.inc 
|Bot core module. 
|Version 13.4.0 
|Date:07/08/2005 
| 
||** 
[botcore] 
version=13.4.0 
**|| 

#chat chat 
#chat group 
#chat tell 

#event Appear       "You appear." 
#event Appearing    "You feel yourself starting to appear." 
#event CorpseTooFar "You are too far away to loot that corpse." 
#event EscKey       "You no longer have a target." 
#event ExpGained    "#*#You gain#*#experience#*#" 
#event FollowOff    "You are no longer auto-following#*#" 
#event ImDead       "You have been slain by#*#" 
#event Invite       "#1# invites you to join a group." 
#event IRCSAY       "<#1#> #2#" 
#event IRCMSG       "<#1#/#*#> #2#" 
#event LosingLev    "You feel as if you are about to fall" 
#event SelfEcho     "[MQ2] Genbot #*#" 
#event Zoned        "LOADING, PLEASE WAIT..." 
#Event AltTell      "#1# told you, '#2#" 
#Event AltTell      "#1# tells you,#*#, '#2#" 

Sub Init-Core 
   |For each command 
   |/call AddCommand "Command Section" "Command Phrase" "Called Sub" 
   |Command Section - where the command will be listed in response to the cmd phrase 
   |Command Phrase to trigger bot - End User can change to suit prefferences 
   |Called Sub - Routine to execute in response to Command Phrase 
   /call AddCommands accept afk autoinv anchor anchorradius assist
   /call AddCommands autoinv camp chatin cmds consent dismount door duck 
   /call AddCommands exp equip face follow followmode group invite 
   /call AddCommands lootall lootup mount moveto movetomode notarget 
   /call AddCommands pause petattack petback petguard random reject 
   /call AddCommands reload rmod rptvar run say saytarget setvar shortcuts sit stand 
   /call AddCommands stay stop tell target trade verbosity yesres 
   /call AddCommands buff chainnuke chainstun evac loadlist 
   /call AddCommands mana selfbuff bufflist setlompct sn snt spellgem 
   /call AddCommands heal resetwatch setcasterheal setcasterhealpct 
   /call AddCommands setdefaultheal setpatchheal setpetheal setpethealpct 
   /call AddCommands settankheal settankhealpct watchtarget 

|Declare Vars 
   /declare advpath bool outer 
   /declare Afollow int outer 0 
   /declare AnchorLoc string outer 0 
   /declare BreakOut bool outer FALSE 
   /declare CombatTargetID int outer 0 
   /declare CommandParam string outer 
   /declare CorpseList string outer 
   /declare CurrCommand string outer 
   /declare FollowTarget string outer 
   /declare IsAnchored bool outer FALSE 
   /declare LootTooFar int outer 0 
   /declare MasterName string outer ${MasterList.Arg[1, ]} 
   /declare MoveToDest string outer 
   /declare MoveToRange string outer 0 

   /declare ObstacleCheck int outer 0 
   /declare SubCallName string outer 
   /declare TalkToSelf bool outer 

|Timers 
   /declare SitTimer timer outer 0 
   /declare ChatOutTimer timer outer 0 
   /declare CheckObstacleTimer timer outer 0 

   /call LoadSetting AnchorRadius int AnchorRadius 6 
   /call LoadSetting ChatIn string ChatIn Tell 
   /call LoadSetting ChatInChannel string ChatInChannel "Channel Name" 
   /call AddToggle checkname off return "I will respond to all commands." "I will only respond to commands that are addressed to me." 
   /call LoadSetting CorpseRadius int MaxLootRadius 50 
   /call LoadSetting followmode int followmode 1 
   /call LoadSetting IgnGroupList string IgnGroupList duck|say|tell|group|cmds|trade|run|backstab|taunt|evade|slam|bash|kick|flyingkick|disarm|traps|puller|| 
   /call LoadSetting ListenChan string ListenChan Name_of_channel 
   /call AddToggle listenchat on return "I will ignore Chat" "I will listen in Chat." 
   /call AddToggle listengroup on return "I will ignore Group Chat." "I will listen in Group Chat." 
   /call LoadSetting MountItem string MountItem "Name of Bridle or Drum" 
   /call LoadSetting MaxTargetRange int MaxTargetRange 250 
   /call LoadSetting movetomode int movetomode 1 
   /call AddToggle relaytells on return "I will not relay tells to my master." "I will relay tells to my master." 
   /call AddToggle trap off return "I will not detect for traps." "I will detect for traps." 
   /call LoadSetting Verbosity int Verbosity 9 
   /call LoadSetting DebugList string DebugList "None" 

   /varset SectionName advpath 

   /call LoadSetting FaceFastini int FaceFast 1 
   /call LoadSetting SilentFlagini int SilentFlag 1 
   /call LoadSetting SpeedSenseini int SpeedSense 15 
   /call LoadSetting FollowDistanceini int FollowDistance 20 

   /call LoadSetting EventExpGained event EventExpGained "None" 
   /call LoadSetting EventImDead event EventImDead "None" 
   /call LoadSetting EventLoosingLevitate event EventLoosingLevitate "/botsay I'm loosing Levitate." 
   /call LoadSetting EventLoosingInvis event EventLoosingInvis "/botsay I'm loosing invis." 
   /call LoadSetting EventLostInvis event EventLostInvis "/botsay I'm no longer invis." 
   /call LoadSetting EventZoned event EventZoned "None" 

   /assist off 

   /squelch /alias /gb /echo genbot 
   /squelch /alias /botsay /call ChatOut 1 
   /squelch /alias /then /multiline ; /varset DidThenClause 1 ; /call ExecCommand 
    
   /declare advpathv float local 
   /varset advpathv ${Ini[advpath.inc,advpath,version,99999]} 
   /if (${advpathv}==99999) { 
      /echo Advanced pathing NOT available. 
      /varset advpath 0 
   } else { 
      /if (${advpathv}>=1.24) { 
         /varset advpath 1 
         /call InitAPFVars ${FaceFastini} ${SpeedSenseini} ${FollowDistanceini} 
         /varset SilentFlag ${SilentFlagini} 
      } else { 
         /echo Minimum advpath.inc v(1.24) required - you have v(${advpathv}) 
         /echo Advanced pathing found, but too old. Update it! 
         /varset advpath 0 
      } 
   } 
/return 

Sub CoreMain 
   |Check Protect 
   /if (${Toggle-protect}) { 
      /declare MobID int local ${Spawn[pc ${MasterName}].NearestSpawn[npc radius ${MeleeRadius} zradius 10].ID} 
      /if (!${MobID}) { 
         /varset MobID ${Spawn[pc ${MasterName}].NearestSpawn[pet radius ${MeleeRadius} zradius 10].ID 
         /if (!${Spawn[id ${MobID}].Master.Type.Equal[npc]}) /varset MobID 0 
      } 
      /if (${MobID} && ${CombatTargetID}!=${MobID}) { 
         /call CheckIsLookingAt ${MobID} ${Spawn[${MasterName}].ID} 
         /if (${Macro.Return}) { 
            /call CheckNeverKill ${MobID} 
            /if (${Macro.Return}) { 
               /call Target "id ${MobID}" 
               /varset CombatTargetID ${MobID} 
               /call ExecCommand EventProtect ${Spawn[id ${CombatTargetID}].CleanName} 
            } 
         } 
      } 
   } 
   /if (${MoveToDest.Length}) /call MoveTo 
   /if (${Me.Combat} && (${Target.Type.Equal[NPC]} || ${Target.Master.Type.Equal[npc]}) && ${Toggle-autoengage} && ${Target.Distance}<${MeleeMaxRadius}) { 
      /varset CombatTargetID ${Target.ID} 
   } else /if (${CombatTargetID}) { 
      /return 
   } else /if (${Me.Combat}) /attack off 
   /if (${Toggle-trap} && ${Me.AbilityReady[Sense Traps]}) /doability "Sense Traps" 
   /if (${IsAnchored}) { 
      /if (${Math.Distance[${AnchorLoc}]}>${AnchorRadius}) { 
         /if (!${MoveToDest.Length} && !${CombatTargetID}) /call MoveTo "${AnchorLoc}" 
      } else { 
         /if (${Toggle-sitaftercast} && ${Me.Standing} && !${SitTimer}) /varset SitTimer ${DelayBeforeSit} 
         |Check Guard 
         /if (${Toggle-guard} && ${Spawn[npc radius ${GuardRadius}].ID}) { 
            /call CheckNeverKill ${NearestSpawn[npc radius ${GuardRadius}].ID} 
            /if (${Macro.Return}) { 
               /call Target "id ${NearestSpawn[npc radius ${GuardRadius}].ID}" 
               /varset CombatTargetID ${NearestSpawn[npc radius ${GuardRadius}].ID} 
               /call ExecCommand EventGuard ${NearestSpawn[npc radius ${GuardRadius}].CleanName} 
            } 
         } 
      } 
      /return 
   } 
   /if (${Toggle-guard}) /call ExecCommand guard off 
   /if (${advpath}) /call AdvPathPoll 
   /if (${Afollow} && !${NearestSpawn[${FollowTarget} radius FollowDistanceini].ID}) { 
      /call MoveTo "${FollowTarget}" 
   } 
/return 

||||||||||||Command-subs 

Sub Command-accept 
   /squelch /target clear 
   /invite 
/return 

Sub Command-reject 
   /squelch /target clear 
   /disband 
/return 

Sub Command-afk 
   /if (!${Defined[Param0]}) { 
      /afk 
   } else { 
      /afk ${CommandParam} 
   } 
   /call ChatOut 3 "Going afk." 
/return 

Sub Command-anchor 
   /if (!${IsAnchored}) { 
      /varset IsAnchored 1 
      /varset AnchorLoc ${Me.Y},${Me.X} 
      /varset Afollow 0 
      /varset FollowTarget NULL 
      /if (${advpath} && ${FollowFlag}) /call StopFunction 
      /keypress left 
      /keypress right 
      /call ChatOut 5 "Created anchor at Loc: ${AnchorLoc}." 
      /return 
   } 
   /if (${IsAnchored}) { 
     /varset IsAnchored 0 
     /call ChatOut 5 "Removed Anchor." 
   } 
/return 

Sub Command-anchorradius(int NewRadius) 
   /if (!${Defined[NewRadius]}) { 
      /call ChatOut 3 "My anchor radius is ${AnchorRadius}." 
   } 
   /if (${NewRadius}<3) /return 
   /varset AnchorRadius ${NewRadius} 
   /call ChatOut 3 "My new anchor radius is ${AnchorRadius}." 
/return 

Sub Command-assist(string AssistName) 
   /if (!${Defined[AssistName]}) { 
      /call Assist "${MasterName}" 
   } else /if (${AssistName.Equal[me]}) { 
      /call Assist "${MasterName}" 
   } else /if (${AssistName.Equal[yourself]}) { 
      /return 
   } else /if (${AssistName.Equal[${Me.CleanName}]}) { 
      /return 
   } else { 
      /call Assist "${CommandParam}" 
   } 
   /if (!${Target.ID}) { 
      /call ChatOut 5 "I failed to get a target." 
   } else { 
      /call ChatOut 5 "My target is now ${Target.CleanName}." 
      /varset CombatTargetID ${Target.ID} 
      /if (${Toggle-petona}) { 
         /if (${Me.Sitting}) /Stand 
         /call Delay 5 
         /pet attack 
         /call Delay 5 
         /if (${Toggle-sitaftercast} && ${Me.Standing}) /varset SitTimer ${DelayBeforeSit} 
      } 
   } 
   /call ExecCommand assistcall 
/return 

Sub Command-autoinv 
   /autoinventory 
/return 

Sub Command-camp 
   /dismount 
   /varset Afollow 0 
   /if ((${advpath})&&(${FollowFlag})) /call StopFunction 
   /varset FollowTarget NULL 
   /keypress left 
   /keypress right 
   /call ChatOut 3 "Camping out." 
   /if (${Me.Standing}) /Sit 
   /camp desktop 
/return 

Sub Command-chatin 
   /if (!${Defined[Param0]}) { 
      /call ChatOut 1 "My chat goes to ${ChatIn}." 
      /return 
   } 
   /varset ChatIn ${Param0} 
   /call ChatOut 1 "My chat goes to ${ChatIn}." 
/return 

Sub Command-cmds 
  /if (${Defined[Param0]} && ${SectionsList.Find[${Param0}]}) { 
      /call ChatOut 2 "${cmds-${Param0.Left[1].Upper}${Param0.Right[-1].Lower}}" 
      /return 
  } else { 
      /call ChatOut 3 "Must specify one of ${SectionsList}" 
  } 
/return 

Sub Command-consent(string TargetName) 
   /if (!${Defined[TargetName]}) { 
      /call Assist "${MasterName}" 
      /varset CommandParam ${Target.CleanName} 
      /consent ${Target.CleanName} 
   } else /if (${TargetName.Equal[me]}) { 
      /call ChatOut 3 "I'm giving you consent." 
      /consent ${MasterName} 
      /varset CommandParam ${MasterName} 
      /return 
   } else /if (${TargetName.Equal[yourself]}) { 
      /return 
   } else /if (${TargetName.Equal[${Me.CleanName}]}) { 
      /return 
   } else { 
      /consent ${CommandParam} 
   } 
   /call ChatOut 3 "I gave consent to ${CommandParam}" 
/return 

Sub Command-dismount 
   /dismount 
   /call ChatOut 5 "I got off my mount." 
/return 

Sub Command-Door 
   /doort 
   /face door 
   /keypress u 
/return 

Sub Command-duck 
   /keypress DUCK 
   /varset SpellFail 1 
   /varset CTimer 0 
/return 

Sub Command-exp 
   /call ChatOut 5 "I am at ${Me.PctExp} percent exp. 
/return 

Sub Command-equip 
      /if (${Macro.Params}>1) { 
         /for counter 1 to ${Math.Calc[${Macro.Params}-1]} 
            /varset CommandText ${CommandText} ${Param${counter}} 
         /next counter 
         /if {Debug-Core} /echo Command-equip CommandText ${CommandText} 
      } 
      /declare SlotName string local ${CommandText.Arg[${Math.Calc[${CommandText.Count[ ]}+1]}]} 
      /if (${InvSlot[SlotName]} && ${InvSlot[SlotName]}<22) { 
         /varset slotName ${SlotName} 
         /varset CommandText ${CommandText.Right[-${CommandText.Arg[${Math.Calc[${CommandText.Count[ ]}+1]}].Length}]} 

      /if ( !${FindItem[${spellName}].InvSlot} ) { 
         /echo Cannot find item: ${spellName} 
         /return CAST_UNKNOWNSPELL 
      } 
      /if ( ${FindItem[${spellName}].InvSlot}>30 ) { 
         /varset swapItemback true 
         /if ( ${FindItem[${spellName}].WornSlot[1]} ) { 
            /varset slotName ${FindItem[${spellName}].WornSlot[1]} 
         } else { 
            /varset slotName pack8 
         } 
         /varset slotID ${InvSlot[${slotName}].ID} 
         /varset oldSlotID ${FindItem[${spellName}].InvSlot.ID} 
         /autoinventory 
         /if ( ${InvSlot[${oldSlotID}].Pack} ) { 
      :open_pack 
            /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup 
            /if ( !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /goto :open_pack 
         } 
      :pick_up_item 
         /if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup 
         /nomodkey /itemnotify ${InvSlot[${oldSlotID}]} leftmouseup 
         /if ( !${Cursor.Name.Equal[${spellName}]} ) /goto :pick_up_item 
      :exchange_items 
         /nomodkey /itemnotify ${slotID} leftmouseup 
         /if ( !${Me.Inventory[${slotID}].Name.Equal[${spellName}]} ) /goto :exchange_items 
      } 

/return 

Sub Command-face 
   /call StandardTarget "${CommandParam}" 
   /call ChatOut 5 "Facing ${Target.CleanName}." 
   /if (${Me.Sitting}) /Stand 
   /call Delay 5 
   /face 
/return 

Sub Command-follow 
   /if (${Me.Sitting}) /Stand 
   /varset IsAnchored 0 
   /if (!${Defined[Param0]}) { 
         /varset FollowTarget ${MasterName} 
   } else /if (${CommandParam.Equal[me]}) { 
         /varset FollowTarget ${MasterName} 
   } else /if (${CommandParam.Equal[yourself]}) { 
         /return 
   } else /if (${CommandParam.Equal[${Me.CleanName}]}) { 
         /return 
   } else { 
         /varset FollowTarget ${CommandParam} 
   } 
   /if (${Spawn[${FollowTarget}].ID}) { 
      /call ChatOut 5 "I am now following ${Spawn[${FollowTarget}].CleanName}." 
   } else { 
      /call ChatOut 5 "Unable to follow ${FollowTarget}." 
      /call StopFunction 
      /varset Afollow 0 
      /return 
   } 
   /if (${followmode}==1) { 
      /varset Afollow 1 
   } 
   /if (${followmode}==2) { 
      /call FollowFunction "${Spawn[${FollowTarget}].CleanName}" 
   } 
   /if (${followmode}==3) { 
      /follow 
   } 
/return 

Sub Command-followmode 
   /if (!${Defined[Param0]}) /return 
   /varset followmode ${Param0} 
/return 

Sub Command-group 
   /if (!${Defined[Param0]}) { 
      /return 
   } else { 
      /g ${CommandParam} 
   } 
/return 

Sub Command-invite(string TargetName) 
   /if (!${Defined[TargetName]}) { 
      /call Assist "${MasterName}" 
   } else /if (${TargetName.Equal[me]}) { 
      /call Target "pc ${MasterName}" 
   } else /if (${TargetName.Equal[yourself]}) { 
      /return 
   } else /if (${TargetName.Equal[${Me.CleanName}]}) { 
      /return 
   } else { 
      /call Target "pc ${CommandParam}" 
   } 
   /call ChatOut 3 "Inviting ${Target.CleanName}." 
   /invite 
/return 

Sub Command-lootall 
   /declare DeadCount int local 
   /declare si int local 
   /varset CorpseList 
   /if (${Me.Combat}) { 
      /call ChatOut 5 "I'm busy fighting right now.  Ask me to loot again later!" 
      /return 
   } 
   /varset DeadCount ${SpawnCount[corpse radius ${CorpseRadius}]} 
   /if (!${DeadCount}) { 
      /call ChatOut 5 "No corpses within range to loot." 
      /return 
   } 
   /for si 1 to ${DeadCount} 
      /call ListAppendElement CorpseList ${NearestSpawn[${si},corpse radius ${CorpseRadius}].ID} " " 
   /next si 
   /for si 1 to ${DeadCount} 
      /call Target "id ${CorpseList.Arg[${si}]}" 
      /if (${Target.Type.Equal[corpse]}) /call Loot 
   /next si 
/return 

Sub Command-lootup 
   /if (${Me.Combat}) { 
      /call ChatOut 6 "I'm busy fighting right now.  Ask me to loot again later!" 
      /return 
   } 
   /if (${Defined[Param0]}) { 
      /call Target "corpse ${CommandParam}" 
   } 
   /call Loot 
/return 

Sub Command-mount 
/declare myvar string local
/varset myvar " item alt spell slot "
   /if (${Me.Sitting}) /stand 
   /if (!${myvar.Find[ ${MountItem.Arg[1].Arg[1,-]} ]}) /varset MountItem item ${MountItem} 
   /call AddCast "${MountItem}" "0" buff 
   /call ChatOut 5 "Summoning my mount." 
/return 

Sub Command-moveto 
   /if (!${CommandParam.Find[,]}) { 
      /if (${movetomode}==1) { 
         /call MoveTo "${CommandParam}" 
      } 
      /if (${movetomode}==2) { 
         /call GotoFunction "${CommandParam.Arg[1,]}" "${CommandParam.Arg[2,]}" 
      } 
      /return 
   } 
   /if (!${Defined[TargetName]}) { 
      /call Assist "${MasterName}" 
      /varset CommandParam ${Target.CleanName} 
   } else /if (${TargetName.Equal[me]}) { 
      /call Target "${MasterName}" 
      /varset CommandParam ${Target.CleanName} 
   } else /if (${TargetName.Equal[yourself]} || ${TargetName.Equal[${Me.CleanName}]}) { 
      /return 
   } else { 
      /if (${Spawn[${CommandParam}].ID}) /call ChatOut 3 "Destination for moveto not recognized.  Try a pc or npc name, or a loc in the form: y,x, such as -100,300" 
      /return 
   } 
   /if (${movetomode}==1) { 
      /call MoveTo "${CommandParam}" 
   } 
   /if (${movetomode}==2) { 
      /call GotoFunction "${Spawn[${CommandParam}].Y}" "${Spawn[${CommandParam}].X}" "${Spawn[${CommandParam}].Z}" 
   } 
/return 

Sub Command-movetomode 
   /if (!${Defined[Param0]}) /return 
   /varset movetomode ${Param0} 
/return 

Sub Command-notarget 
   /squelch /target clear 
/return 

Sub Command-pause 
      /if (${advpath}) { 
         /if (!${PauseFlag}) { 
            /call ChatOut 5 "Pausing." 
         } else { 
            /call ChatOut 5 "Unpausing." 
         } 
         /call PauseFunction 
      } 
/return 

Sub Command-petattack 
   /call Assist "${MasterName}" 
   /if (!${Target.ID}) /call ChatOut 5 "I failed to get a target." 
   /pet attack 
/return 

Sub Command-petback 
   /pet back off 
/return 

Sub Command-petguard 
   /pet guard here 
/return 

Sub Command-random 
   /if (!${Defined[Param0]}) /return 
   /if (!${Defined[Param1]}) { 
      /random ${Param0} 
   } else { 
      /random ${Param0} ${Param1} 
   } 
/return 

Sub Command-reload 
   /call ChatOut 5 "Reload initiated." 
   /mac genbot 
/return 

Sub Command-rmod(int RangeMod) 
   /if (!${Defined[RangeMod]}) /return 
   /varcalc MeleeRange ${MeleeRange}+${RangeMod} 
   /call ChatOut 3 "New melee range is ${MeleeRange}" 
/return 

Sub Command-rptvar 
   /if (!${Defined[Param0]}) /return 
   /call ChatOut 5 "${Param0} is equal to ${${Param0}}" 
/return 

Sub Command-run 
   /keypress ctrl+r 
/return 

Sub Command-say 
   /if (!${Defined[Param0]}) { 
      /return 
   } else { 
      /say ${CommandParam} 
   } 
/return 

Sub Command-saytarget 
   /call ChatOut 5 "my target is ${Target.CleanName}." 
/return 

Sub Command-setvar 
   /if (!${Defined[Param0]}) /return 
   /declare VarLen int local 
   /declare ValueLen int local 
   /declare VarName string Local 
   /varset VarName ${CommandParam.Arg[1]} 
   /varset VarLen ${CommandParam.Length} 
   /varset ValueLen ${CommandParam.Length} 
   /varcalc ValueLen ${ValueLen}-${VarLen} 
   /varset ${VarName} ${CommandParam.Right[${ValueLen}]} 
   /call ChatOut 5 "${Param0} is now equal to ${${Param0}}" 
/return 

Sub Command-sit 
   /varset Afollow 0 
   /varset FollowTarget NULL 
   /if ((${advpath})&&(${FollowFlag})) /call StopFunction 
   /if (${Me.Standing}) /sit 
/return 

Sub Command-stand 
   /if (${Me.Sitting}) /Stand 
/return 

Sub Command-stay 
   /varset Afollow 0 
   /varset MoveToDest 
   /varset FollowTarget NULL 
   /if ((${advpath})&&(${FollowFlag})) /call StopFunction 
   /keypress DOWN 
   /keypress left 
   /keypress right 
/return 

Sub Command-stop 
   /if (${Me.Mount.ID}) /dismount 
   /varset CombatTargetID 0 
   /varset LootTooFar 1 
   /varset Afollow 0 
   /varset MoveToDest 
   /varset CastQueue 
   /if (${advpath}) /call StopFunction 
   /varset FollowTarget NULL 
   /call ChatOut 5 "Stopping." 
   /keypress left 
   /keypress right 
   /keypress DUCK 
   /keypress DUCK 
   /keypress forward 
   /keypress back 
   /squelch /target clear 
   /keypress right 
/return 

Sub Command-target 
   /call StandardTarget "${CommandParam}" 
   /call ChatOut 5 "My target is now ${Target.CleanName}." 
/return 

Sub Command-tell 
   /if (!${Defined[Param0]}) { 
      /return 
   } else { 
      /tell ${CommandParam} 
   } 
/return 

Sub Command-trade 
   /call ChatOut 5 "Clicking trade." 
   /notify TradeWnd TRDW_Trade_Button LeftMouseUp 
   /call Delay 3 
/return 

Sub Command-verbosity(int NewVerbosity) 
   /if (!${Defined[NewVerbosity]}) { 
      /call ChatOut 1 "My Verbosity is set to ${Verbosity}." 
      /return 
   } 
   /varset Verbosity ${NewVerbosity} 
   /call ChatOut 1 "My Verbosity is set to ${Verbosity}." 
/return 

Sub Command-yesres 
   /call ChatOut 5 "Clicking yes for res." 
   /notify ConfirmationDialogBox Yes_Button leftmouseup 
   /call Delay 3 
/return 


|||||||||||| Called subs 

Sub Assist(string sAssistName) 
   /squelch /target clear 
   /if (${DebugList.Find[core]}) /echo /assist ${sAssistName} 
   /assist ${sAssistName} 
   /delay 2s ${Target.ID} 
   /if (!${Target.ID}) /call ChatOut 3 "Unable to /assist ${sAssistName}." 
/return 

Sub ChatOut(int ChatPriority,string ChatText) 
   /declare GenFor int local 

   /if (${ChatPriority}>${Verbosity}) /return 
   /if (${Macro.Params}>2) { 
      /for GenFor 2 to ${Math.Calc[${Macro.Params}-1]} 
         /varset ChatText ${ChatText} ${Param${GenFor}} 
      /next GenFor 
   } 
   /if (${MasterName.Equal[GROUP]}) { 
      /gsay ${ChatText} 
      /return 
   } 
   /if (${TalkToSelf}) { 
      /echo ${ChatText} 
      /return 
   } 
   /if (${ChatIn.Equal[tell]}) { 
      /if (${ChatOutTimer}) /delay ${ChatOutTimer} 
      /varset ChatOutTimer 20 
      /tell ${MasterName} ${ChatText} 
   } else /if (${ChatIn.Equal[Group]}) { 
      /gsay ${ChatText} 
   } else /if (${ChatIn.Equal[Raid]}) { 
      /rsay ${ChatText} 
   } else /if (${ChatIn.Equal[Say]}) { 
      /if (${ChatOutTimer}) /delay ${ChatOutTimer} 
      /varset ChatOutTimer 20 
      /say ${ChatText} 
   } else /if (${ChatIn.Equal[Channel]}) { 
      /if (${ChatOutTimer}) /delay ${ChatOutTimer} 
      /varset ChatOutTimer 20 
      /chat #${ChatInChannel} ${ChatText} 
   } else /if (${ChatIn.Equal[IRC]}) { 
      /i say ${ChatText} 
   } 
/return 

Sub ExecCommand(string CommandText) 
|/echo in execcommand: ${CommandText}
   /declare GenFor int local 
   /declare DidThenClause bool local 0 
   /declare ElseClause string local 
   /declare myvar string local

   /if (${Macro.Params}>1) { 
      /for GenFor 1 to ${Math.Calc[${Macro.Params}-1]} 
         /varset CommandText ${CommandText} ${Param${GenFor}} 
      /next GenFor 
   } 
   /if (${CommandText.Left[3].Lower.Equal[/if]}) { 
      /if (${CommandText.Find[/else]}) { 
         /varset ElseClause ${CommandText.Right[-${Math.Calc[${CommandText.Find[/else ]}+5]}]} 
         /varset CommandText ${CommandText.Left[${Math.Calc[${CommandText.Find[/else ]}-1]}]} 
|/echo docommand ${CommandText}
         /docommand ${CommandText} 
         /if (!${DidThenClause}) { 
            /call ExecCommand "${ElseClause}" 
         } 
      } else { 
         /docommand ${CommandText} 
      } 
      /return 
   } 
   /if (${CommandText.Left[1].Equal[/]}) { 
      /docommand ${CommandText} 
      /return 
   } 
   /varset CurrCommand ${CommandText.Arg[1]} 
   /if (${CommandText.Arg[2].Length}) { 
      /varset CommandParam ${CommandText.Right[-${CurrCommand.Length}]} 
   } else { 
      /varset CommandParam 
   } 
|/echo CurrCommand = ${CurrCommand}

   /if (${Defined[cmds-Routines]}) { 
|/echo cmds-routines defined
/varset myvar ${cmds-Routines.Lower}
      /if (${myvar.Find[ ${CurrCommand.Lower} ]}) { 
         /echo doing routines ${CommandText} 
         /call Routine "${CommandText}" 
         /return 
      } 
   } 

   /if (${Defined[cmds-Shortcuts]}) { 
|/echo cmds-shortcuts = ${cmds-Shortcuts}
/varset myvar ${cmds-Shortcuts.Lower}
|/echo myvar = ${myvar}
|/echo CurrCommand = ${CurrCommand.Lower}
|/echo myvarfind = ${myvar.Find[ ${CurrCommand.Lower} ]}
      /if (${myvar.Find[ ${CurrCommand.Lower} ]}) { 
         /echo doing ShortCut ${CommandText} 
         /call ShortCut "${CommandText}" 
         /return 
      } 
|/echo command not found in shortcuts
   } 

   /if (${Defined[Toggle-${CurrCommand.Lower}]}) { 
         /echo doing Toggle ${CurrCommand} ${CommandParam} 
      /call SetToggle ${CurrCommand.Lower} ${CommandParam} 
      /return 
   } 
|/declare myvar2 string local ${GenFor}
|/declare myvar3 string local ${SectionList}
/varset myvar ${cmds-${SectionsList.Arg[${GenFor}]}} 
|/echo myvar = ${myvar}
|/varset myvar ${cmds-${myvar3.Arg[${myvar2}]}
   /for GenFor 1 to ${Math.Calc[${SectionsList.Count[ ]}+1]} 
      /if (${SectionsList.Arg[${GenFor}].NotEqual[Shortcuts]} && ${SectionsList.Arg[${GenFor}].NotEqual[Shortcuts]}) { 
         /if (${myvar.Find[ ${CurrCommand} ]}) { 
            /echo doing Command ${CurrCommand} ${CommandParam} 
            /call Command-${CurrCommand} ${CommandParam} 
            /return 
         } 
      } 
   /next GenFor 

/return 

sub Loot 
   /declare GenFor int local 
   /declare LootSlot int local 1 
   /if (${Me.Combat}) /return 
   /if (!${Target.ID}) /squelch /target corpse radius ${CorpseRadius} 
   /if (${Target.Type.NotEqual[corpse]}) /return 
   :MoveToCorpse 
   /call MoveTo "${Target.Y},${Target.X}" 
   /if (${Spawn[${MoveToDest}].Type.Equal[corpse]}) /goto :MoveToCorpse 
   /squelch /face 
   /varset LootTooFar 0 
   /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 
   /call ChatOut 5 "Looting ${Target.CleanName}." 
   :lootloop 
      /if (${LootTooFar}) /goto :donelooting 
      /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 MoveTo 
   /if (${Defined[Param0]}) { 
      /varset MoveToDest ${Param0} 
      /if (${MoveToDest.Equal[me]}) /varset MoveToDest ${Spawn[pc ${MasterName}].ID} 
      /if (${Defined[Param1]}) { 
         /varset MoveToRange ${Param1} 
      } else { 
         /varset MoveToRange ${AnchorRadius} 
      } 
   } 
   /if (${CastStep}) /return 
   /if (!${Me.Standing}) /stand 
   /declare MoveDist int local 
   /declare DistGoal int local 
   /declare CheckObstacle int local 0 
   /varset LastLoc ${Me.Y},${Me.X} 
   :MoveLoop 
      /if (${MoveToDest.Find[,]}) { 
         /face nolook loc ${MoveToDest} 
         /varset DistGoal ${AnchorRadius} 
         /varcalc MoveDist ${Math.Distance[${MoveToDest}]} 
      } else /if (!${Spawn[${MoveToDest}].ID} || ${Spawn[${MoveToDest}].ID}==${Me.ID} || ${MoveToDest.Find[Null]}) { 
         /varset MoveToDest 
         /return 
      } else { 
         /squelch /face fast id ${Spawn[${MoveToDest}].ID} 
         /varset DistGoal ${MeleeRange} 
         /varcalc MoveDist ${Math.Distance[${Spawn[${MoveToDest}].Y},${Spawn[${MoveToDest}].X}]} 
      } 
      /if (${MoveDist}>${DistGoal}) { 
         /keypress forward hold 
      } else { 
         /if (${MoveToDest.Equal[${CombatTargetID}]} && ${MoveDist}<${MeleeRange}-5) { 
            /keypress back hold 
            /delay 5 (${Math.Distance[${Spawn[${MoveToDest}].Y},${Spawn[${MoveToDest}].X}]}>${MeleeRange}-2) 
            /keypress back 
         } 
         /keypress forward 
         /if (${MoveToDest.Equal[${AnchorLoc}]}) { 
            /face nolook away loc ${AnchorLoc} 
            /keypress Home 
         } 
         /varset MoveToDest 
         /return 
      } 
      |/if (!${CheckObstacle.OriginalValue}) /varset CheckObstacle 3 
      /varcalc CheckObstacle ${CheckObstacle}+1 
      /if (${CheckObstacle}>5) { 
         /varset CheckObstacle 0 
         /if (${Math.Distance[${LastLoc}:${Me.Y},${Me.X}]}<0.1) { 
            /call Hitobst 5 
            /return 
         } 
         /if (${MoveDist}-${Math.Distance[${LastLoc}:${Me.Y},${Me.X}]}>${DistGoal}+100) { 
            /return 
         } 
         /varset LastLoc ${Me.Y},${Me.X} 
      } 
   /goto :MoveLoop 
/return 

Sub Hitobst(int HoldTime) 
   /if (!${Me.Speed}) { 
      /keypress forward 
      /return 
   } 
   /keypress forward 
   /keypress back hold 
   /delay 2s 
   /keypress back 
   /if (${Math.Rand[2]}) { 
      /keypress right hold 
      /delay ${HoldTime} 
      /keypress right 
   } else { 
      /keypress left hold 
      /delay ${HoldTime} 
      /keypress left 
   } 
   /keypress forward hold 
   /delay 2s 
   /keypress forward 
   /keypress left 
   /keypress right 
/return 

Sub StandardTarget(string TargetName) 
   /if (!${Defined[TargetName]}) { 
      /return 
   } else /if (!${TargetName.Length}) { 
      /call Assist "${MasterName}" 
   } else /if (${TargetName.Equal[me]}) { 
      /call Target "${MasterName}" 
   } else /if (${TargetName.Equal[yourself]} || ${TargetName.Equal[${Me.CleanName}]}) { 
      /call Target myself 
   } else { 
      /call Target "${TargetName}" 
   } 
/return 

Sub Target(string sTargetName) 

   | Check if intended target already targetted. 
   /if (${Target.ID} && ${Spawn[${sTargetName}].ID}==${Target.ID} && (!${Spawn[pc ${sTargetName}].ID} || ${Target.Type.Equal[pc]})) /return 
   /squelch /target clear 
   /if (${Spawn[pc ${sTargetName} radius ${MaxTargetRange}].ID}) { 
      /squelch /target pc ${sTargetName} radius ${MaxTargetRange} 
   } else { 
      /squelch /target ${sTargetName} radius ${MaxTargetRange} 
   } 
   /delay 2s ${Target.ID} 
   /if (!${Target.ID}) /echo Unable to locate target ${sTargetName}. 
/return 

Sub ListDelbyArg(string sList,int sArg,string sDiv) 
/declare Tempvar string local 
/varset Tempvar ${sDiv}${${sList}}${sDiv}${sDiv} 
/declare myVar string local 
   /if (!${Defined[sDiv]}) /declare sDiv string local | 
   /declare sright int local 
   /declare sleft int local 
   /declare splaceholder string local 
   /vardata ${sList} TempVar
/echo in ListDelbyArg
/varset myVar ${${sList}} 
   /varset splaceholder ${myVar.Arg[${sArg},${sDiv}]} 
   /varcalc sleft  ${${sList}.Find[${sDiv}${splaceholder}${sDiv}]} 
/varset myVar ${splaceholder}${sDiv} 
   /varcalc sright ${sleft}+${myVar.Length} 
   /vardata ${sList} TempVar.Right[-${sright}]}] 
   /varset ${sList} ${${sList}.Left[-2].Right[-1]} 
   /if (${DebugList.Find[core]}) /echo List ${${sList}} deleted arg ${sArg} 
/return



Sub ListReplacebyArg(string sList,string sElement,string sArg,string sDiv) 
/declare Tempvar string local 
/varset Tempvar ${sDiv}${${sList}}${sDiv}${sDiv} 
/declare myVar string local 
   /if (!${Defined[sDiv]}) /declare sDiv string local | 
   /vardata ${sList} TempVar
   /declare sright int local 
   /declare sleft int local 
   /declare splaceholder string local 
/echo in ListReplacebyArg
/varset myVar ${${sList}}
   /varset splaceholder ${myVar.Arg[${sArg},${sDiv}]} 
   /varcalc sleft  ${${sList}.Find[${sDiv}${splaceholder}${sDiv}]} 
   /varcalc sright ${sleft}+${myVar.Length} 
   /vardata ${sList} myVar.Left[${sleft}]}${sElement}${sDiv}${${sList}.Right[-${sright}]}] 
   /varset ${sList} ${${sList}.Left[-2].Right[-1]} 
   /if (${DebugList.Find[core]}) /echo List ${${sList}} sElement ${sElement} repladed arg ${sArg} 
/return 

Sub StringReplaceAll(string sList,string oldElement,string newElement) 
   /declare GenFor int local 
   /declare sright int local 
   /declare sleft int local 
/declare myVar string local 
/varset myVar ${oldElement}
   /for GenFor 1 to ${${sList}.Length} 
      /if (${${sList}.Find[${oldElement}]}) { 
         /varset ${sList} |${${sList}}|| 
         /varcalc sleft  ${${sList}.Find[${oldElement}]}-1 
         /varcalc sright ${sleft}+${myVar.Length} 
         /varset ${sList} ${${sList}.Left[${sleft}]}${newElement}${${sList}.Right[-${sright}]} 
         /varset ${sList} ${${sList}.Left[-2].Right[-1]} 
      } else { 
         /if (${DebugList.Find[core]}) /echo List ${${sList}} oldElement ${oldElement} replaced newElement ${newElement} 
         /return 
      } 
   /next GenFor 
   /echo Error in StringReplaceAll 
/return 

Sub ListDelbyName(string sList,string sName,string sDiv) 
/declare myvar string local
/declare tempvar string local
/varset tempvar ${sDiv}${${sList}}${sDiv}${sDiv}
   /if (${DebugList.Find[core]}) /echo List ${${sList}}  TO Delete: ${sName} 
   /if (!${Defined[sDiv]}) /declare sDiv string local | 
   /vardata ${sList} tempvar
   /declare sright int local 
   /declare sleft int local 
/varset myvar ${sDiv}${${sList}}${sDiv}
   /varcalc sleft  ${myvar.Find[${sDiv}${sName}${sDiv}]}-1 
/varset myvar ${sName}${sDiv}
   /varcalc sright ${sleft}+${myvar.Length} 
/varset tempvar ${${sList}.Left[${sleft}]}${${sList}.Right[-${sright}]}
   /vardata ${sList} tempvar 
   /varset ${sList} ${${sList}.Left[-2].Right[-1]} 
   /if (${DebugList.Find[core]}) /echo List ${${sList}}  Deleted: ${sName} 
/return 

Sub ListAppendElement(string sList,string sElement,string sDiv) 
|/echo listappendelement = ${sElement}
   /if (!${Defined[sDiv]}) /declare sDiv string local | 
   /if (${${sList}.Length}) { 
      /varset ${sList} ${${sList}}${sDiv}${sElement} 
   } else { 
      /varset ${sList} ${sElement} 
   } 
   /if (${DebugList.Find[core]}) /echo List ${${sList}}  Added: ${sElement} 
/return 


Sub ListPrependElement(string sList,string sElement,string sDiv) 
   /if (!${Defined[sDiv]}) /declare sDiv string local | 
   /if (${${sList}.Length}) { 
      /varset ${sList} ${sElement}${sDiv}${${sList}} 
   } else { 
      /varset ${sList} ${sElement} 
   } 
   /if (${DebugList.Find[core]}) /echo List ${${sList}}  Added: ${sElement} 
/return 

Sub ListFindStringArg(string sList,string sString,string sDiv) 
   /if (!${Defined[sDiv]}) /declare sDiv string local | 
   /declare sReturn int local 
   /varcalc sReturn ${${sList}.Left[${${sList}.Find[${sString}]}].Count[${sDiv}]}+1 
   /if (${DebugList.Find[core]}) /echo List ${${sList}}  Arg: ${sReturn} 
/return ${sReturn} 


|||||||||||| Events 

Sub Event_Appear 
   /call ExecCommand EventLostInvis 
/return 

Sub Event_Appearing 
   /call ExecCommand EventLoosingInvis 

/return 

Sub Event_Chat(string ChatType,string ChatSender,string ChatText) 
|/echo event_chat
/declare myvar string local
/echo master = ${MasterList.Lower}
|/echo chattype = ${ChatType}
|/echo chatsender = ${ChatSender}
|/echo chattext = ${ChatText}

   /if (!${ChatType.Equal[GROUP]} && !${ChatType.Equal[${ListenChan}]}&& !${ChatType.Equal[TELL]}) { 
      /return 
   } 
   /if (${ChatType.Equal[GROUP]} && !${Toggle-listengroup}) /return 
   /if (${ChatType.Equal[${ListenChan}]} && !${Toggle-listenchat}) /return 
   /if (${ChatType.Equal[${ListenChan}]} || ${ChatType.Equal[GROUP]}) { 
      /if (${ChatText.Arg[1].Equal[${Me.CleanName}]}) { 
         /declare NameLength int local ${Me.CleanName.Length} 
         /varcalc NameLength ${NameLength}+1 
         /varset ChatText ${ChatText.Right[-${NameLength}]} 
      } else { 
         /if (${Toggle-checkname}) /return 
/varset myvar |${IgnGroupList}|
         /if (${myvar.Find[|${ChatText.Arg[1]}|]}) /echo command not found /return 
      } 
   } 
/varset myvar ${MasterList.Lower}
|/echo masterlist.lower = ${myvar}
|   /if (${myvar.Find[ ${ChatSender.Lower} ]}) { 
|/echo found master in chat
      /varset MasterName ${ChatSender} 
      /varset TalkToSelf 0 
      /call ExecCommand "${ChatText}" 
      /return 
   } 
/echo didn't find master in chat
   /if (${Toggle-relaytells} && ${ChatType.Equal[TELL]}) { 
      /if (${Spawn[npc ${ChatSender} radius 100].ID} || ${Spawn[${ChatSender}].Master.ID}==${Me.ID}) /return 
      /call ChatOut 1 "${ChatSender} told me: ${ChatText}" 
   } 
/return 

Sub Event_CorpseTooFar 
   /call ChatOut 5 "I'm not close enough to loot ${Target.CleanName}." 
   /varset LootTooFar 1 
/return 

Sub Event_EscKey 
   /call Command-stop 
/return 

Sub Event_ExpGained 
   /call ExecCommand EventExpGained 
/return 

Sub Event_FollowOff 
   /squelch /target clear 
   /call ChatOut 5 "Auto follow Off." 
/return 

Sub Event_FoundBoxTrap 
   /if (${Me.AbilityReady[Disarm Traps]}) { 
      /call ChatOut 5 "Trying to disarm a ${Target.CleanName} trap." 
      /doability "Disarm Traps" 
      /return 
   } 
/return 

Sub Event_FoundFloorTrap 
   /if (${Me.AbilityReady[Disarm Traps]}) { 
      /call ChatOut 5 "Trying to disarm a floor trap." 
      /doability "Disarm Traps" 
      /return 
   } 
/return 

Sub Event_ImDead 
   /call ExecCommand EventImDead 
/return 

Sub Event_Invite 
/declare myvar string local ${MasterList.Lower}
   /if (${myvar.Find[ ${Param1.Lower} ]}) { 
      /call Command-accept 
   } else { 
      /call ChatOut 6 "${Param1} has invited me to join his group." 
      /call ChatOut 9 "Let me know if I should 'accept' or 'reject' his invitation." 
   } 
/return 

Sub Event_IRCSAY(string IRCText,string IRCSender) 
/declare myvar string local ${MasterList.Lower}
   /if (${myvar.Find[ ${IRCSender.Lower} ]}) { 
      /declare NameLength int local ${IRCSender.Length} 
      /varcalc NameLength ${NameLength}+2 
      /varset IRCText ${IRCText.Right[-${NameLength}]} 
      /if (${IRCText.Arg[1].Equal[${Me.CleanName}]}) { 
         /varset NameLength ${Me.CleanName.Length} 
         /varcalc NameLength ${NameLength}+1 
         /varset IRCText ${IRCText.Right[-${NameLength}]} 
      } 
      /varset MasterName ${IRCSender} 
      /call ExecCommand "${IRCText}" 
      /return 
   } 
/return 

Sub Event_IRCMSG(string IRCText,string IRCSender,string Command) 
/declare myvar string local ${MasterList.Lower}
   /if (${myvar.Find[ ${IRCSender.Lower} ]}) { 
      /varset MasterName ${IRCSender} 
      /call ExecCommand "${Command}" 
   } 
/return 

Sub Event_LosingLev 
   /call ExecCommand EventLoosingLevitate 
/return 

Sub Event_SelfEcho(string EchoText) 
   /varset TalkToSelf 1 
   /varset EchoText ${EchoText.Right[-13]} 
   /call ExecCommand "${EchoText}" 
/return 

Sub Event_timer(string TimerName,string OldValue) 
   /if (${TimerName.Arg[1,-].Equal[ST]}) { 
      /if (${DebugList.Find[core]}) /echo ${Me.Name} Calling subroutine ${TimerName.Right[-3]} 
      /vardata SubCallName TimerName.Right[-3] 
      /if (${SubCallName.Find[-]}) /call StringReplaceAll SubCallName "-" " " 
      |/if (${DebugList.Find[core]}) /echo ${Me.Name} Calling subroutine ${SubCallName} 
      /call ${SubCallName} 
   } 
   /if (${TimerName.Equal[SitTimer]}) { 
      /if (${Me.Standing} && !${CastStep} && !${Me.Speed}) { 
         /sit 
      } else { 
         /varset SitTimer 2s 
      } 
   } 
   /if (${TimerName.Equal[ChainStunTime]}) { 
      /call NextStun 
   } 
/return 

Sub Event_Zoned 
   /varset IsAnchored 0 
   /keypress forward 
   /call ExecCommand EventZoned 
/return 

Sub Event_AltTell(string line, string sender, string text) 
   /call Event_Chat TELL "${sender}" "${text.Left[-1]}" 
/return

Code: Select all

|botcommon.inc 
|Common commands module example. 
|Version 13.4.0 
|Date:07/08/2005 
| 
||** 
[common] 
version=13.4.0 
**|| 

|   Use this file for your own routines and commands that you want all of 
|   your bots to be able to use. 

|   Use the base genbot.mac to add in character or task specific routines 
|   or commands that will not apply to all of your characters. 

|Define your personal Events Here 
|#Event EExample "Explain it to me again" 

Sub Init-Common 

   |/call AddCommands Command_Phrase1 <Command_Phrase2> <Command_Phrase3> . . . 
   | Command_Phrase - what the master will type to invoke the command 
   | Put in as many command phrases as you like on the same line. 
   |  The subroutine called will be Command-Command_Phrase1, etc. 
   | example: /call AddCommands sit stand moveto 
   | with subroutines called Command-sit, Command-stand, and Command-moveto 
    
   |/call AddToggle Command ToggleDefaultValue|noini return|toggle "PhraseOff" "PhraseOn" <callsub> 
   | 
   | example: /call AddToggle sitaftercast off return "I will no longer sit after casting." "I will now sit after casting." callsub 
   | 
   | Command switch a Toggle - End User change change to suit prefferences 
   |   The actual name of the toggle variable will be ${Toggle-ToggleName}. 
   |   In our example, this would be ${Toggle-sitaftercast} 
   | ToggleDefaultValue should be whatever you want the default value to be. 
   |   This value will be entered into the ini file, under the Command name. 
   |   If noini is used, then no .ini entry will be created, and the default 
   |     will be set to FALSE. 
   | return will return the toggle setting when no param is given 
   | toggle will toggle the toggle setting when no param is given 
   | PhraseOff returned by the bot when value is FALSE 
   | PhraseOn returned by the bot when value is TRUE 
   | callsub - optional - if entered, SetToggle will call ToggleCommand subroutine 
   |   (ex. Sub Toggle-sitaftercast) after setting the toggle and before outputting 
   |   the result 
    
   |/declare PersonalValue string outer 
   |/declare AnotherValue int outer default 
    
   |INI Values 
   |/call LoadSetting PersonalVar VarType Personalkey "Default Value" 
   | Declares and initializes variable PersonalVar by reading from the .ini key 
   |  called PersonalKey 
   | If no PersonalKey entry in .ini file, or entry is blank, "Default Value" 
   |  is entered in .ini file. 
   | Valid VarTypes are string, int, bool, and event. 
    
/return 

|Things that you want to happen every loop through the macro go in this sub. 
Sub CommonMain 

   |/Call MyExampleSub 
   |/if (${AnotherValue}) /call ConditionalExample 
    
/return 

|Add your own Event and and other subroutines here 

|Sub Event_EExample 
|   Some Event Code 
|/return 

|Sub MyExampleSub 
| Some Code activate every loop of the code 
|/return 

|Sub CommandFunction 
|   Some Code that will run every time CommandName is activated 
|/return 

|sub ConditionalExample 
|   Some Code that will run everytime "AnotherValue" is true 
|/return

Code: Select all

|botcombat.inc 
|Bot combat module. 
|Version 13.4.0 
|Date:07/08/2005 
| 
||** 
[botcombat] 
version=13.4.0
**|| 

#event Attacking       "You pierce #*#" 
#event Attacking       "You slash #*#" 
#event Attacking       "You Hit #*#" 
#event Attacking       "You Bash #*#" 
#event ArcheryTooFar   "Your target is too far away, get closer" 
#event DisarmTrap      "You have disarmed #*#" 
#event Enraged         "#*#|${Spawn[id ${CombatTargetID}].CleanName.Right[${Math.Calc[${Spawn[id ${CombatTargetID}].CleanName.Length}-1]}]}| has become ENRAGED#*#" 
#event FoundFloorTrap  "You sense a trap in this direction." 
#event FoundBoxTrap    "You are certain that #*#" 
#event UnderAttack     "#1#YOU for #*#" 
#event UnderAttack     "#1#to#*#YOU, but #*#" 
#event MobGate         "#*#|${Spawn[${CombatTargetID}].CleanName}| Gates.#*#" 
#event Offrage         "#*#|${Spawn[id ${CombatTargetID}].CleanName.Right[${Math.Calc[${Spawn[id ${CombatTargetID}].CleanName.Length}-1]}]}| is no longer enraged#*#" 


Sub Init-Combat 

   /call AddCommands attack behind disc getbehind hide noattack shield sneak 

|Declare Variables 
   /declare EnrageVar bool outer FALSE 

|Timers 
   /declare TauntDiscTimer timer outer 

|Load settings 

   /call AddToggle archery    off   return "Archery is set to off." "Archery is set to on." 
   /call AddToggle autobehind off   return "I won't position myself behind the mob." "I will position myself behind the mob." 
   /call AddToggle autoengage on    return "I will not engage when attack is on." "I will engage when attack is on." 
   /call AddToggle bash       off    return "Auto Bash is now off." "Auto Bash is now on." 
   /call AddToggle backstab   off    return "Auto Backstab is now off." "Auto Backstab is now on." 
   /call AddToggle disarm     off    return "Auto Disarm is now off." "Auto Disarm is now on." 
   /call AddToggle evade      off    return "Auto Evade is now off." "Auto Evade is now on." 
   /call AddToggle flyingkick off    return "Auto FlyingKick is now off." "Auto FlyingKick is now on." 
   /call AddToggle frenzy     off    return "Auto Frenzy is now off." "Auto Frenzy is now on." 
   /call AddToggle kick       off    return "Auto Kick is now off." "Auto Kick is now on." 
   /call AddToggle slam       off    return "Auto Slam is now off." "Auto Slam is now on." 
   /call AddToggle taunt      off    return "Auto Taunt is now off." "Auto Taunt is now on." 
   /call AddToggle puller     noini return "I'm not the puller." "I'm the puller." 
   /call AddToggle petona off return "I won't send pet in on assist." "I will send pet in on assist." 
   /call AddToggle tauntdisc     off    return "I won't use the @{WarTauntDisc} discipline when in combat." "I will use the @{WarTauntDisc} discipline when in combat." 
   /call LoadSetting WarTauntDisc string WarTauntDisc incite 
   /call AddToggle guard     noini    return "I will not defend this area from intruders." "I will defend this area from intruders." callsub 
   /call LoadSetting GuardRadius int GuardRadius 50 
   /call AddToggle defend     off   return "I will not defend myself if atttacked." "I will defend myself if atttacked." 
   /call AddToggle protect   off    return "I will not protect @{MasterName}." "I will protect @{MasterName} ." 
   /call LoadSetting ProtectList string ProtectList ${MasterList} 
   /call LoadSetting NeverKill string NeverKill "things you never want to attack separated by |" 
   /call LoadSetting MeleeRadius int ProtectOrDefendCheckRadius 50 
   /call AddToggle melee     off    return "I will not close to do melee when in combat." "I will close and do melee when in combat." 
   /call LoadSetting MeleeRange int MeleeRange 12 
   /call LoadSetting MeleeMaxRadius int MeleeMaxRadius 100 

| Shortcuts    
   /call LoadSetting EventDefend event EventDefend "/botsay I've been attacked by NameS!  Attacking right back!" 
   /call LoadSetting EventGuard event EventGuard "/botsay Intruder alert!  Attacking the trespassing NameS!" 
   /call LoadSetting EventAttacked event EventAttacked "None" 
   /call LoadSetting EventProtect event EventProtect "/botsay How dare NameS attack my master?!  I must punish this insolence!" 

/return 

Sub CombatMain 
   /call Combatcheck 
   /if (!${CombatTargetID}) /return 
   /if (${Toggle-melee}) { 
      /if (!${Me.Combat} && ${Target.Distance}<${Spawn[${CombatTargetID}].MaxRangeTo}) /attack on 
      /if (!${MoveTo.Length}) /call MoveTo ${CombatTargetID} ${MeleeRange} 
      /call MeleeAbility 
   } 
   /if (${Toggle-archery}) { 
      /squelch /face fast 
      /range 
   } 
/return 

||||Do Subs 
Sub Command-attack 
   /call StandardTarget "${CommandParam}" 
   /if (!${Target.Type.Equal[NPC]} && !${Target.Master.Type.Equal[NPC]}) { 
      /varset CombatTargetID 0 
      /return 
   } 
   /varset CombatTargetID ${Target.ID} 
   /if (!${Me.Standing}) /stand 
   /call ChatOut 5 "Attacking ${Target.CleanName}." 
/return 

Sub Command-behind 
   /if (!${Target.ID}) { 
      /call Assist "${MasterName}" 
      } 
   :behind 
   /if (!${Target.ID}) /return 
   /call MoveTo ${CombatTargetID} 
  | ----- Clockwise Rotate Check ----- 
   /if (!${Target.ID}) /return 
   /if (${Target.Heading.Degrees}>=180 && ${Math.Calc[${Target.Heading.Degrees}-180]}<=${Me.Heading.Degrees} && ${Me.Heading.Degrees}<${Math.Calc[${Target.Heading.Degrees}-22.5]}) /call bsclock 
   /if (!${Target.ID}) /return 
   /if (${Target.Heading.Degrees}>=180 && ${Me.Heading.Degrees}<=180 && ${Math.Calc[${Me.Heading.Degrees}-22.5]}>${Math.Calc[${Target.Heading.Degrees}-360]}) /call bscounter 
   /if (!${Target.ID}) /return 
   /if (${Target.Heading.Degrees}<=180 && ${Me.Heading.Degrees}<${Math.Calc[${Target.Heading.Degrees}-22.5]}) /call bsclock 
  | ----- Counter Clockwise Rotate Check ----- 
   /if (!${Target.ID}) /return 
   /if (${Me.Heading.Degrees}>=180 && ${Math.Calc[${Me.Heading.Degrees}-180]}<=${Target.Heading.Degrees} && ${Me.Heading.Degrees}>${Math.Calc[${Target.Heading.Degrees}+22.5]}) /call bscounter 
   /if (!${Target.ID}) /return 
   /if (${Me.Heading.Degrees}>=180 && ${Target.Heading.Degrees}<=180 && ${Math.Calc[${Me.Heading.Degrees}-157.5]}<${Math.Calc[${Target.Heading.Degrees}+180]}) /call bsclock 
   /if (!${Target.ID}) /return 
   /if (${Me.Heading.Degrees}<=180 && ${Target.Heading.Degrees}<=180 && ${Me.Heading.Degrees}>${Math.Calc[${Target.Heading.Degrees}+25]}) /call bscounter 
   /if (!${Target.ID}) /return 
   /if (${Math.Abs[${Math.Calc[${Target.Heading.Degrees}-${Me.Heading.Degrees}]}]}>30) /goto :behind 
/return 

Sub Command-disc 
   /if (!${Defined[Param0]}) /return 
     /disc ${Param0} 
/return 

Sub Command-getbehind 
   /varset ObstacleCheck 0 
   /varset GenLastXLoc ${Me.Y} 
   /varset GenLastYLoc ${Me.X} 
   /if (!${Target.ID}) { 
      /call Assist "${MasterName}" 
   } 
   /if (${Math.Distance[${Math.Calc[${Target.Y}-${Math.Cos[${Target.Heading.Degrees}]}*10]},${Math.Calc[${Target.X}+${Math.Sin[${Target.Heading.Degrees}]}*10]}]}<3) /goto :noneed 
   /if (!${Target.ID}) /return 
   /keypress FORWARD hold 
   :gobehindloop 
   /if (${Me.State.NotEqual[STAND]}) /stand 
   /if (!${Target.ID}) { 
      /keypress FORWARD 
      /return 
   } 
   /if (${ObstacleCheck}>=60) { 
      /if (${GenLastXLoc}==${Me.Y} && ${GenLastYLoc}==${Me.X}) { 
         /keypress FORWARD 
         /return 
      } 
      /varset GenLastXLoc ${Me.Y} 
      /varset GenLastYLoc ${Me.X} 
      /varset ObstacleCheck 0 
   } 
   /varcalc ObstacleCheck ${ObstacleCheck}+1 
   /doevents 
   /face nolook fast loc ${Math.Calc[${Target.Y}-${Math.Cos[${Target.Heading.Degrees}]}*10]},${Math.Calc[${Target.X}+${Math.Sin[${Target.Heading.Degrees}]}*10]} 
   /if (${Math.Distance[${Math.Calc[${Target.Y}-${Math.Cos[${Target.Heading.Degrees}]}*10]},${Math.Calc[${Target.X}+${Math.Sin[${Target.Heading.Degrees}]}*10]}]}>1) /goto :gobehindloop 
   /keypress FORWARD 
   /squelch /face fast 
:noneed 
/keypress FORWARD 
/return 

Sub Toggle-guard 
   /if (${CommandParam.Equal[${Int[${CommandParam}]}]}) { 
      /varset DoGuard 1 
      /varset GuardRadius ${CommandParam} 
   } 
   /if (${DoGuard}) { 
      /if (!${IsAnchored}) /call ExecCommand anchor 
   } 
/return 

Sub Command-hide 
   /doability Hide 
   /call Delay 2s 
   /if (${Me.AbilityReady[Hide]}) { 
      /call ChatOut 5 "I'm not hiding" 
   } else { 
      /call ChatOut 5 "I am hiding." 
   } 
/return 

|Sub ProtectToggle 
|   /if (${CommandParam.Equal[none]}) { 
|      /varset DoGuard 1 
|      /varset GuardRadius ${CommandParam} 
|   } 
|   /if (${DoGuard}) { 
|      /if (!${IsAnchored}) /call Command-anchor 
|   } 
|/return 

Sub Command-noattack 
   /varset CombatTargetID 0 
/return 

Sub Command-shield 
   /if ( !${Defined[Param0]} || ${Param0.Equal[me]}) { 
      /shield ${MasterName} 
   } else { 
      /shield ${CommandParam} 
   } 
/return 

Sub Command-sneak 
   /doability Sneak 
   /call Delay 2s 
   /if (${Me.AbilityReady[Sneak]}) { 
      /call ChatOut 5 "I'm not sneaking atm" 
   } else { 
      /call ChatOut 5 "I'm sneaking" 
   } 
/return 

||||| Called Subs 

Sub bsclock 
   /if (!${Target.ID}) /return 
   /if (!${Me.Standing}) { 
      /stand 
      /delay 3 
   } 
   /keypress strafe_left hold 
   :MoreClock 
   /if (${Toggle-backstab} && ${Math.Distance[${Math.Calc[${Target.Y}-${Math.Cos[${Target.Heading.Degrees}]}*10]},${Math.Calc[${Target.X}+${Math.Sin[${Target.Heading.Degrees}]}*10]}]}<15) { 
      /squelch /face fast 
      /doability "Backstab" 
   } 
   /if (!${Target.ID}) { 
      /keypress strafe_left 
      /return 
   } 
   /if (${Target.Distance}>20) { 
      /keypress strafe_left 
      /call MoveTo ${CombatTargetID} 
      /return 
   } 
   /if (${Target.Distance}<4) { 
      /keypress strafe_left 
      /call MoveTo ${CombatTargetID} 
      /return 
   } 
   /squelch /face fast 
   /if (${Target.Heading.Degrees}>=180 && ${Math.Calc[${Target.Heading.Degrees}-180]}<=${Me.Heading.Degrees} && ${Me.Heading.Degrees}<${Math.Calc[${Target.Heading.Degrees}-22.5]}) /goto :MoreClock 
   /if (${Target.Heading.Degrees}<=180 && ${Me.Heading.Degrees}<${Math.Calc[${Target.Heading.Degrees}-22.5]}) /goto :MoreClock 
   /if (${Target.Heading.Degrees}>=180 && ${Me.Heading.Degrees}<=180 && ${Math.Calc[${Me.Heading.Degrees}-22.5]}>${Math.Calc[${Target.Heading.Degrees}-360]}) /goto :MoreClock 
   /keypress strafe_left 
   /squelch /face fast 
/return 

Sub bscounter 
   /if (!${Target.ID}) /return 
   /if (!${Me.Standing}) { 
      /stand 
      /delay 3 
   } 
   /keypress strafe_right hold 
   :MoreCounter 
   /if (${Toggle-backstab} && ${Math.Distance[${Math.Calc[${Target.Y}-${Math.Cos[${Target.Heading.Degrees}]}*10]},${Math.Calc[${Target.X}+${Math.Sin[${Target.Heading.Degrees}]}*10]}]}<15) { 
      /squelch /face fast 
      /doability "Backstab" 
   } 
   /if (!${Target.ID}) { 
      /keypress strafe_right 
      /return 
   } 
   /if (${Target.Distance}>20) { 
      /keypress strafe_right 
      /call MoveTo ${CombatTargetID} 
      /return 
   } 
   /if (${Target.Distance}<4) { 
      /keypress strafe_right 
      /call MoveTo ${CombatTargetID} 
      /return 
   } 
   /squelch /face fast 
   /if (${Me.Heading.Degrees}>=180 && ${Math.Calc[${Me.Heading.Degrees}-180]}<=${Target.Heading.Degrees} && ${Me.Heading.Degrees}>${Math.Calc[${Target.Heading.Degrees}+22.5]}) /goto :MoreCounter 
   /if (${Me.Heading.Degrees}<=180 && ${Target.Heading.Degrees}<=180 && ${Me.Heading.Degrees}>${Math.Calc[${Target.Heading.Degrees}+25]}) /goto :MoreCounter 
   /if (${Me.Heading.Degrees}>=180 && ${Target.Heading.Degrees}<=180 && ${Math.Calc[${Me.Heading.Degrees}-157.5]}<${Math.Calc[${Target.Heading.Degrees}+180]}) /goto :MoreCounter 
   /keypress strafe_right 
   /squelch /face fast 
/return 

Sub CheckPuller 
   /declare AggTemp bool local 
   /if (!${Toggle-puller}) /return 
   /if (${Math.Distance[${AnchorLoc}]}<=${AnchorRadius}) /return 
   /declare mobface local 
   /varset mobface ${Math.Calc[(${Me.Heading.Degrees}+180)]} 
   /varcalc mobface ${mobface}%360 
   /if (${Target.Heading.Degrees}<=${Math.Calc[${mobface}+10]} && ${Target.Heading.Degrees}>=${Math.Calc[${mobface}-10]}) { 
      /varset CombatTargetID 0 
      /varset AggTemp ${Toggle-defend} 
      /varset Toggle-defend 0 
      /call MoveTo "${AnchorLoc}" 
      /varset Toggle-defend ${AggTemp} 
    } 
/return 

|Combatcheck 
|Used to check if attack is on and should not be. 
|Usage /call Combatcheck. 
Sub Combatcheck 
   /call CheckNeverKill 
   /if (!${Spawn[id ${CombatTargetID}].Type.Equal[npc]} && !${Spawn[id ${CombatTargetID}].Master.Type.Equal[npc]}) { 
      /varset CombatTargetID 0 
      /attack off 
      /return 
   } 
   /if (${Spawn[id ${CombatTargetID}].Distance}>${MeleeMaxRadius}) { 
      /call ChatOut 5 "Combat Target is out of range!" 
      /varset CombatTargetID 0 
      /attack off 
      /return 
   } 
   /if (${CastStep}) /return 
   /if (${Target.ID}!=${CombatTargetID}) /call Target "id ${CombatTargetID}" 
   /if (${EnrageVar}) /return 
   /if (${Toggle-autobehind} && ${Math.Distance[${Math.Calc[${Target.Y}-${Math.Cos[${Target.Heading.Degrees}]}*10]},${Math.Calc[${Target.X}+${Math.Sin[${Target.Heading.Degrees}]}*10]}]}>6) /call Command-behind 
/return 

Sub CheckNeverKill(int CheckID) 
   /declare GenFor int local 
   /if (!${Defined[CheckID]}) /declare CheckID int local ${CombatTargetID} 
   /if (${NeverKill.Equal[${NeverKill-DefaultValue}]}) /return 1 
   /for GenFor 1 to ${Math.Calc[${NeverKill.Count[|]}+1]} 
      /if (${Spawn[${CheckID}].CleanName.Find[${NeverKill.Arg[${GenFor},|]}]}) { 
         /if (${CombatTargetID}==${CheckID}) /varset CombatTargetID 0 
         /return 0 
      } 
   /next GenFor 
/return 1 

| IsAggroed 
| Used for checking if an NPC is attacking.someone.  Default PC is master 
|Usage /call CheckIsLookingAt "id of mob to check" "id of PC to check" 
Sub CheckIsLookingAt(int MobID,int PCID) 
   /declare MobHeading int local 0 
   /declare HeadingToPC int local 
   /declare DeltaX local float 
   /declare DeltaY local float 
   /declare HeadingDelta local float 
   /if (!${Defined[PCID]}) /varset PCID ${Spawn[${MasterName}].ID} 
   /if (${Spawn[id ${MobID}].ID}) { 
      /varcalc MobHeading ${Spawn[id ${MobID}].Heading.Degrees} 
      /varcalc DeltaX ${Spawn[id ${PCID}].X}-${Spawn[id ${MobID}].X} 
      /varcalc DeltaY ${Spawn[id ${PCID}].Y}-${Spawn[id ${MobID}].Y} 
      /if (${DeltaX}>0) { 
         /varcalc HeadingToPC ${Math.Atan[${DeltaY}/${DeltaX}]}+270 
      } else /if (${DeltaX}<0) { 
         /varcalc HeadingToPC ${Math.Atan[${DeltaY}/${DeltaX}]}+90 
      } else { 
         /if (${DeltaY}>0) { 
            /varcalc HeadingToPC 90 
         } else { 
            /varcalc HeadingToPC 270 
         } 
      } 
      /varcalc HeadingDelta ${Math.Abs[${HeadingToPC}-${MobHeading}]} 
      |/echo DeltaY ${DeltaY} DeltaX ${DeltaX}  Atan ${Math.Atan[${DeltaY}/${DeltaX}]} 
      /echo Mob ${Spawn[id ${MobID}].Name} MobHeading ${MobHeading} HeadingToPC ${HeadingToPC} HeadingDelta ${HeadingDelta} 
      /if (${HeadingDelta}<4 || ${HeadingDelta}>356) { 
         /return 1 
      } 
   } 
/return 0 


|MeleeAbility 
|Used to do melee abilities if vars are set to. 
|Usage /call MeleeAbility 
Sub MeleeAbility 
   /if (${Me.Casting.ID} || !${Me.Standing} || !${Target.ID}) /return 
   /if (${Me.AltTimerReady}) { 
      /if (${Toggle-slam}) { 
         /squelch /face fast 
         /doability "Slam" 
      } 
      /if (${Toggle-bash}) { 
         /squelch /face fast 
         /doability "Bash" 
      } 
      /if (${Toggle-backstab} && ${Math.Distance[${Math.Calc[${Target.Y}-${Math.Cos[${Target.Heading.Degrees}]}*10]},${Math.Calc[${Target.X}+${Math.Sin[${Target.Heading.Degrees}]}*10]}]}<15) { 
         /squelch /face fast 
         /doability "Backstab" 
      } 
      /if (${Toggle-frenzy}) { 
         /squelch /face fast 
         /doability "Frenzy" 
      } 
      /if (${Toggle-kick}) { 
         /squelch /face fast 
         /doability "Kick" 
      } 
   } 
   /if (${Toggle-evade} && ${Me.AbilityReady[Hide]}) { 
      /attack off 
      /delay 1 
      /doability "Hide" 
      /attack on 
   } 
   /if (${Toggle-taunt} && ${Me.AbilityReady[Taunt]}) { 
      /doability "Taunt" 
   } 
   /if (${Toggle-flyingkick} && ${Me.AbilityReady[Flying Kick]}) { 
      /squelch /face fast 
      /doability "Flying Kick" 
   } 
   /if (${Toggle-disarm} && ${Me.AbilityReady[Disarm]}) { 
      /squelch /face fast 
      /doability "Disarm" 
   } 
   /if (${Toggle-tauntdisc} && !${TauntDiscTimer}) { 
      /squelch /face fast 
      /disc ${WarTauntDisc} 
      /varset TauntDiscTimer 30s 
   } 
/return 

||||| Events 


Sub Event_ArcheryTooFar 
/return 

Sub Event_Attacking 
   /call CheckPuller 
/return 

Sub Event_DisarmTrap 
   /call Delay 2s 
   /call ChatOut 5 "Trap disarmed." 
/return 

Sub Event_Enraged 
   /if (${Target.ID}) { 
      /if (${CombatTargetID}) /varset EnrageVar ${Target.ID} 
      /attack off 
      /varset CombatTargetID 0 
      /if (${Toggle-petona}) /pet backoff 
   } 
/return 

Sub Event_MobGate 
   /if (${CombatTargetID}) { 
      /varset CombatTargetID 0 
      /if (${Toggle-petona}) /pet backoff 
   } 
/return 

Sub Event_Offrage 
   /if (${Target.ID}) { 
      /if (${EnrageVar}) { 
         /varset CombatTargetID ${EnrageVar} 
         /varset EnrageVar 0 
      } 
      /varset EnrageVar 0 
   } 
/return 

Sub Event_UnderAttack(string Line,string Attacker) 
   /if (${Attacker.Find[say]} || ${Attacker.Find[group]} || ${Attacker.Find[out of character]} || ${Attacker.Find[shout]} || ${Attacker.Find[guild]} || ${Attacker.Find[MQ2]} || ${Attacker.Find[ healed ]}) /return 
   /call CheckPuller 
   /declare MobName string local ${Attacker.Left[${Math.Calc[-${Attacker.Arg[${Math.Calc[${Attacker.Count[ ]}]}].Length}-1]}]} 
   /if (!${CombatTargetID} && ${Toggle-defend} && ${NearestSpawn[${MobName}].Distance}<${MeleeRadius}) { 
      /call CheckNeverKill ${NearestSpawn[MobName].ID} 
      /if (${Macro.Return}) { 
         /call Target "${MobName}" 
         /if (${Target.Type.Equal[NPC]} || ${Target.Master.Type.Equal[npc]}) { 
            /varset CombatTargetID ${Target.ID} 
            /call ExecCommand EventDefend ${Target.CleanName} 
         } 
      } 
   } else { 
      /call ExecCommand EventAttacked ${MobName} 
      /if (${SitAfterCast}) /varset SitTimer ${DelayBeforeSit} 
   } 
/return

Code: Select all

|genbot.mac 
|Personal commands module example. 
|Version 13.4.0 
|Date:07/08/2005 
| 
||** 
[individual] 
version=13.4.0 
**|| 

|   Use this file to add in character or task specific routines or commands 
|   That will not apply to all of your characters.  Use botcommon.inc for 
|   your own routines and commands that you want all of your bots to be able 
|   to use. 

|   Since this mac calls all of the other .inc files, feel free to change the 
|   name to botname1.mac or time.mac or tradeskill.mac or whatever according 
|   to how you customize it. 


| Change "bot_" below to specify a different .ini file. 
| Useful if you want to make separate files for different activities for the 
| same character. 

#define INI_FILE_PREFIX bot_ 

#include botmain.inc 

|Define your personal Events Here 
|#Event EExample "Explain it to me again" 

Sub Init-Individual 
  
   |/call AddCommands Command_Phrase1 <Command_Phrase2> <Command_Phrase3> . . . 
   | Command_Phrase - what the master will type to invoke the command 
   | Put in as many command phrases as you like on the same line. 
   |  The subroutine called will be Command-Command_Phrase1, etc. 
   | example: /call AddCommands sit stand moveto 
   | with subroutines called Command-sit, Command-stand, and Command-moveto 
    
   |/call AddToggle Command ToggleDefaultValue|noini return|toggle "PhraseOff" "PhraseOn" <callsub> 
   | 
   | example: /call AddToggle sitaftercast off return "I will no longer sit after casting." "I will now sit after casting." callsub 
   | 
   | Command switch a Toggle - End User change change to suit prefferences 
   |   The actual name of the toggle variable will be ${Toggle-ToggleName}. 
   |   In our example, this would be ${Toggle-sitaftercast} 
   | ToggleDefaultValue should be whatever you want the default value to be. 
   |   This value will be entered into the ini file, under the Command name. 
   |   If noini is used, then no .ini entry will be created, and the default 
   |     will be set to FALSE. 
   | return will return the toggle setting when no param is given 
   | toggle will toggle the toggle setting when no param is given 
   | PhraseOff returned by the bot when value is FALSE 
   | PhraseOn returned by the bot when value is TRUE 
   | callsub - optional - if entered, SetToggle will call ToggleCommand subroutine 
   |   (ex. Sub Toggle-sitaftercast) after setting the toggle and before outputting 
   |   the result 
    
   |/declare PersonalValue string outer 
   |/declare AnotherValue int outer default 
    
   |INI Values 
   |/call LoadSetting PersonalVar VarType Personalkey "Default Value" 
   | Declares and initializes variable PersonalVar by reading from the .ini key 
   |  called PersonalKey 
   | If no PersonalKey entry in .ini file, or entry is blank, "Default Value" 
   |  is entered in .ini file. 
   | Valid VarTypes are string, int, bool, and event. 
    
/return 

|Things that you want to happen every loop through the macro go in this sub. 
Sub IndividualMain 

   |/Call MyExampleSub 
   |/if (${AnotherValue}) /call ConditionalExample 
    
/return 

|Add your own Event and and other subroutines here 

|Sub Event_EExample 
|   Some Event Code 
|/return 

|Sub MyExampleSub 
| Some Code activate every loop of the code 
|/return 

|Sub CommandFunction 
|   Some Code that will run every time CommandName is activated 
|/return 

|sub ConditionalExample 
|   Some Code that will run everytime "AnotherValue" is true 
|/return