Leif:
Whoops. That'll only affect persistence of your settings; I'll fix that.
Cr4azy:
Sure. You're right; however, the fact is it still affects many people who use RH and don't understand the problem. There are many ways to deal with it, and I could be cavalier about it and say it's "not my problem" that people don't understand about saving their configuration settings. Truth be told, I'd rather RH be complete and friendly and deal with everything possible, my fault or not.
Rogue Helper v6.0 [Complete Rogue Macro] (Updated: 10-26-04)
Moderator: MacroQuest Developers
When the bot encounters a leash tug, it turns off autoassist for good and will not continue autoassiting untill given the command again. Any way to fix this so that it turns off atttack and runs back to leash only if the mob is out of range of leash and autoassist still functions if in range of leash?
Rhev:
Well, no, becuase that will never happen. Here's why:
1) You get a leash tug (this means mob is out of leash range that you set), so you stop fighting and move back a bit.
2) Assume we don't turn off autoattack, RH iterrates and finds that your tank is fighting and you're not, so you need to attack! So it does...
3) Go back to 1.
You get stuck in an infinite tug situation and this looks incredibly stupid (and no human would do this), so the thing to do is either 1) lengthen the leash automatically (this is dangerous and probably undesirable) or 2) stop autoassisting alltogether. I chose the latter, and it used to be the former. If you want, you can edit the leash code in the combat loop and remove the /attack off statements in there.
I'd advise against it. Better that you make sure your leash length is actually correct, or bind the leash to the tank with a high /leashflex (say 70+), with a range of like 200. You'll never have a problem then, even if your group "drifts" away from the original spot. The only suck part about that is if your tank is also the puller, you'll be following him/her around while they pull
I find it best to /leash to the group healer.
Well, no, becuase that will never happen. Here's why:
1) You get a leash tug (this means mob is out of leash range that you set), so you stop fighting and move back a bit.
2) Assume we don't turn off autoattack, RH iterrates and finds that your tank is fighting and you're not, so you need to attack! So it does...
3) Go back to 1.
You get stuck in an infinite tug situation and this looks incredibly stupid (and no human would do this), so the thing to do is either 1) lengthen the leash automatically (this is dangerous and probably undesirable) or 2) stop autoassisting alltogether. I chose the latter, and it used to be the former. If you want, you can edit the leash code in the combat loop and remove the /attack off statements in there.
I'd advise against it. Better that you make sure your leash length is actually correct, or bind the leash to the tank with a high /leashflex (say 70+), with a range of like 200. You'll never have a problem then, even if your group "drifts" away from the original spot. The only suck part about that is if your tank is also the puller, you'll be following him/her around while they pull
I find it best to /leash to the group healer.--Jerle
-
loadingpleasewait
- a snow griffon
- Posts: 332
- Joined: Sat Sep 14, 2002 8:46 am
You should change the /assist checks to include pet checks and corpse checks.. al laI kept trying to kill group members pets..
Code: Select all
|- Lets try all the assists in priority order until we get an NPC to whack on
/if (!${Me.Casting.ID}) /assist ${firstassist}
/delay 1
/if (${Target.ID} && !${Target.Type.Equal[PC]} && !${Target.Type.Equal[Corpse]} && !${Target.Type.Equal[PET]}) /goto :EngageCheck
/if (!${Me.Casting.ID}) /assist ${secondassist}
/delay 1
/if (${Target.ID} && !${Target.Type.Equal[PC]} && !${Target.Type.Equal[Corpse]} && !${Target.Type.Equal[PET]}) /goto :EngageCheck
/if (!${Me.Casting.ID}) /assist ${thirdassist}
/delay 1
/if (${Target.ID} && !${Target.Type.Equal[PC]} && !${Target.Type.Equal[Corpse]} && !${Target.Type.Equal[PET]}) /goto :EngageCheck
|- If we got here and don't have a target, tanks are invalid or no fighting is going on
/goto :EndAutoassist
LOADING PLEASE WAIT...
Changes made against current posted version (6.0)
Cleaned up some redundant code, especially in the initial varsets. Fixed all the variable names to match the IniFile keys to make this possible.
edit: blah, file too larget to post...
Cleaned up some redundant code, especially in the initial varsets. Fixed all the variable names to match the IniFile keys to make this possible.
edit: blah, file too larget to post...
Code: Select all
|---------------------------------------------------------------------------------
|
| Rogue Helper (RH) Macro
| - v6.0 by Jerle (10/26/04)
|
| Documentation for RH is now separated from the macro proper. Please look for
| RHDocs.html for syntax and use, or RHChangeLog.txt for the implementation
| change log.
|
|---------------------------------------------------------------------------------
|
| RH Syntax:
|
| Usage: /mac rh
|
| Default settings can be changed by their respective controlling /command
|
| Type /rhhelp for help or /status to see current settings!
|
|---------------------------------------------------------------------------------
#Chat tell
#Event StrikeVic "#*#Seeking a Victim#*#"
#Event AttackOn "#*#Auto attack is on#*#"
#Event AttackOff "#*#Auto attack is off#*#"
#Event Enraged "#*#|${Target.CleanName}| has become ENRAGED#*#"
#Event NLEnraged "#*#|${Target.CleanName}| is no longer enraged#*#"
#Event TooFarAway "#*#Your target is too far away, get closer#*#"
#Event Exp "#*#You gain#*#experience#*#"
#Event Slain "#*# slain#*#"
#Event Zoned "#*#You have entered#*#"
#Event GotHit "#1#YOU for#*#points of damage."
#Event GotMissed "#1#to#*#YOU, but #*#"
#Event SpellBounced "#*#Your spell did not take hold#*#"
#Event SwitchWeapon "#*#|${SwitchText}|#*#"
#Event FTrap "#*#You sense a trap in this direction."
#Event BTrap "#*#You are certain that #*#"
#Event TogEvade "[MQ2] Autoevade#*#"
#Event TogPick "[MQ2] Autopick#*#"
#Event TogStick "[MQ2] Autostick#*#"
#Event TogHS "[MQ2] Auto Hide & Sneak#*#"
#Event TogLeash "[MQ2] Leash#*#"
#Event TogAuto "[MQ2] Autoassist#*#"
#Event TogDynamicAggro "[MQ2] DynamicAggro#*#"
#Event TogPause "[MQ2] Pause#*#"
#Event TogTSwitch "[MQ2] AutoTargetSwitch#*#"
#Event TogTraps "[MQ2] AutoTraps#*#"
#Event TogDynamicCloseness "[MQ2] DynamicCloseness#*#"
#Event LinkParse "[MQ2] LinkParse#*#"
#Event SetStopFighting "[MQ2] SetStopFighting#*#"
#Event SetEndFloor "[MQ2] SetEndFloor#*#"
#Event SetStrikeDisc "[MQ2] SetStrikeDisc#*#"
#Event SetCloseness "[MQ2] SetCloseness#*#"
#Event SetFirstAssist "[MQ2] SetMainAssist#*#"
#Event SetSecondAssist "[MQ2] SetSecondAssist#*#"
#Event SetThirdAssist "[MQ2] SetThirdAssist#*#"
#Event SetAutoNinja "[MQ2] SetAutoNinja#*#"
#Event SetWeaponSwitch "[MQ2] SetWeaponSwitch#*#"
#Event SetStickDist "[MQ2] SetStickDist#*#"
#Event SetChicken "[MQ2] SetChicken#*#"
#Event SetDisc1 "[MQ2] SetDisc1#*#"
#Event SetDisc2 "[MQ2] SetDisc2#*#"
#Event SetLeashFlex "[MQ2] SetLeashFlex#*#"
#Event SetVerbosity "[MQ2] SetVerbosity#*#"
#Event SetChannel "[MQ2] SetChannel#*#"
#Event DragBodies "[MQ2] DragBodies#*#"
#Event LootMyCorpse "[MQ2] LootMyCorpse#*#"
#Event AutoFollow "[MQ2] AutoFollow#*#"
#Event AddMaster "[MQ2] AddMaster#*#"
#Event RemMaster "[MQ2] RemoveMaster#*#"
#Event ItemSet "[MQ2] ItemSet#*#"
#Event ItemBounce "[MQ2] ItemBounce#*#"
#Event ItemCast "[MQ2] ItemCast#*#"
#Event HelpInfo "[MQ2] RH Help#*#"
#Event StatInfo "[MQ2] RH Status#*#"
Sub Main
/echo Loading Rogue Helper... Please Wait!
/declare AutoEvade bool outer TRUE
/declare StopFightingHealth int outer 30
/declare StrikeSkill string outer Assassin
/declare MinEndurance int outer 80
/declare isEnraged bool outer FALSE
/declare strikeReady bool outer FALSE
/declare strikeTimer timer outer 0
/declare LDExp float outer ${Me.PctGroupLeaderExp}
/declare AAExp float outer ${Me.PctAAExp}
/declare Exp float outer ${Me.PctExp}
/declare AutoStick bool outer TRUE
/declare X float outer
/declare Y float outer
/declare behindTarget bool outer FALSE
/declare i int outer
/declare dir int outer
/declare delta int outer
/declare strafedir string outer
/declare Closeness int outer 70
/declare AutoHideSneak bool outer TRUE
/declare Leashing bool outer FALSE
/declare LeashLength int outer 0
/declare stakeX int outer ${Me.X}
/declare stakeY int outer ${Me.Y}
/declare LeashHolder string outer Nobody
/declare AutoAssist bool outer FALSE
/declare MainAssist string outer Nobody
/declare FirstAssist string outer Nobody
/declare SecondAssist string outer Nobody
/declare ThirdAssist string outer Nobody
/declare AssistPercentage int outer 98
/declare oldtargetID int outer ${Target.ID}
/declare assisttimer timer outer 0
/declare doDynamicAggro bool outer FALSE
/declare gotHit bool outer FALSE
/declare aggrotimer timer outer 0
/declare ialias string outer None
/declare doIclick bool outer FALSE
/declare bouncenum int outer 1
/declare ibounce string outer None
/declare itemspellname string outer None
/declare clicktimer timer outer 0
/declare isPaused bool outer FALSE
/declare AutoNinjaMode string outer OFF
/declare AutoNinjaDistance int outer 50
/declare AutoPickPocket bool outer FALSE
/declare WeaponSwitching bool outer FALSE
/declare SwitchText string outer +Undefined+
/declare Weapon1 string outer None
/declare Weapon2 string outer None
/declare wstype string outer Detrimental
/declare TargetSwitching bool outer TRUE
/declare lastevent string outer None
/declare StickRangeToTarget int outer 200
/declare StickRangeToTank int outer 100
/declare useMU bool outer FALSE
/declare TrapNegotiation bool outer FALSE
/declare oldheading string outer Default
/declare AutoChicken bool outer FALSE
/declare NimbleHealth int outer 20
/declare ContingencyEscape bool outer FALSE
/declare nimbletimer timer outer 0
/declare nimbleactive timer outer 0
/declare chickentimer timer outer 0
/declare AutoDisc1 bool outer FALSE
/declare Disc1 string outer Deadly Precision
/declare Disc1Endurance int outer 60
/declare Disc1Reuse int outer 5
/declare Disc1Reusetimer timer outer 0
/declare AutoDisc2 bool outer FALSE
/declare Disc2 string outer Kinesthetics
/declare Disc2Endurance int outer 60
/declare Disc2Reuse int outer 5
/declare Disc2Reusetimer timer outer 0
/declare discactive timer outer 0
/declare LeashFlex int outer 10
/declare doDynamicCloseness bool outer TRUE
/declare Closenessdesired int outer 70
/declare acquiretimer timer outer 0
/declare snuggleup bool outer FALSE
/declare isTanking bool outer FALSE
/declare Verbosity int outer 2
/declare Channel string outer echo
/declare rhversion string outer 6.0
/declare INIFileName string outer RHSettings.ini
/goto :BypassVCheck
|- Check versions and load aliases if necessary
/if (${Ini[${INIFileName},General,Version].Equal[${rhversion}]}) /goto :EndAlias
:BypassVCheck
/if (${Verbosity}>=0) /${Channel} Setting Aliases...
/squelch /alias /status /echo RH Status
/squelch /alias /rhhelp /echo RH Help
/squelch /alias /autoevade /echo Autoevade
/squelch /alias /autopick /echo Autopick
/squelch /alias /stopfight /echo SetStopFighting
/squelch /alias /strikedisc /echo SetStrikeDisc
/squelch /alias /endfloor /echo SetEndFloor
/squelch /alias /autostick /echo Autostick
/squelch /alias /autohs /echo Auto Hide & Sneak
/squelch /alias /leash /echo Leash
/squelch /alias /autoassist /echo Autoassist
/squelch /alias /DynamicAggro /echo DynamicAggro
/squelch /alias /Closeness /echo SetCloseness
/squelch /alias /MainAssist /echo SetMainAssist
/squelch /alias /SecondAssist /echo SetSecondAssist
/squelch /alias /ThirdAssist /echo SetThirdAssist
/squelch /alias /drag /echo DragBodies
/squelch /alias /lootmycorpse /echo LootMyCorpse
/squelch /alias /autofollow /echo AutoFollow
/squelch /alias /iset /echo ItemSet
/squelch /alias /ibounce /echo ItemBounce
/squelch /alias /iclick /echo ItemCast
/squelch /alias /pause /echo Pause
/squelch /alias /autoninja /echo SetAutoNinja
/squelch /alias /addmaster /echo AddMaster
/squelch /alias /remmaster /echo RemoveMaster
/squelch /alias /weaponswitch /echo SetWeaponSwitch
/squelch /alias /targetswitch /echo AutoTargetSwitch
/squelch /alias /stickdist /echo SetStickDist
/squelch /alias /autotraps /echo AutoTraps
/squelch /alias /autochicken /echo SetChicken
/squelch /alias /autoDisc1 /echo SetDisc1
/squelch /alias /autoDisc2 /echo SetDisc2
/squelch /alias /LeashFlex /echo SetLeashFlex
/squelch /alias /Verbosity /echo SetVerbosity
/squelch /alias /Channel /echo SetChannel
/squelch /alias /DynamicCloseness /echo DynamicCloseness
/squelch /alias /lp /echo LinkParse
:EndAlias
|-- Update the Version information
/ini "${INIFileName}" "General" "Version" "${rhversion}"
|-- Read in INI settings, if defined... Leashing is only stored TRUE if there is a Leash-holding Master!
/declare IniValues string local AutoEvade StopFightingHealth StrikeSkill MinEndurance AutoStick Closeness AutoHideSneak Leashing LeashHolder LeashLength
/varset IniValues ${IniValues} LeashFlex AutoAssist AssistPercentage MainAssist SecondAssist ThirdAssist DynamicAggro AutoAutoNinjaMode AutoAutoNinjaDistanceance
/varset IniValues ${IniValues} AutoPickPocket WeaponSwitching TargetSwitching StickRangeToTarget StickRangeToTank TrapNegotiation AutoChicken NimbleHealth
/varset IniValues ${IniValues} ContingencyEscape AutoDisc1 Disc1 Disc1Endurance Disc1Reuse AutoDisc2 Disc2 Disc2Endurance Disc2Reuse DynamicCloseness Verbosity Channel
/for i 1 to ${Math.Calc[${IniValues.Count[" "]}+1]}
/if (${Ini[ ${INIFileName},General,${IniValues.Arg[${i}]}].NotEqual[NULL]}) /varset ${IniValues.Arg[${i}]} ${Ini[${INIFileName},General,${IniValues.Arg[${i}]}]}
/next i
/deletevar IniValues
| FirstAssist, the ugly duckling...
/if (${Ini[${INIFileName},General,MainAssist].NotEqual[NULL]}) /varset FirstAssist ${Ini[${INIFileName},General,MainAssist]}
/if (${Ini[${INIFileName},Weapons,Weapon1].NotEqual[NULL]}) /varset Weapon1 ${Ini[${INIFileName},Weapons,Weapon1]}
/if (${Ini[${INIFileName},Weapons,Weapon2].NotEqual[NULL]}) /varset Weapon2 ${Ini[${INIFileName},Weapons,Weapon2]}
/if (${Ini[${INIFileName},Weapons,SwitchText].NotEqual[NULL]}) /varset SwitchText ${Ini[${INIFileName},Weapons,SwitchText]}
/varset Closenessdesired ${Closeness}
/varset wstype ${FindItem[${Weapon1}].Spell.SpellType}
|- Build Empty master list in ${INIFileName} file if it doesn't exist
/if (!${Ini[${INIFileName},Masters,Controller1].Length}) {
|- It's not in there yet
/for i 1 to 20
/ini "${INIFileName}" "Masters" "Controller${i}" "Nobody"
/next i
}
/echo =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
/echo Jerle's Rogue Helper Macro (v${rhversion}) Starting...
/echo =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
/echo Use "/rhhelp" to display help information
/echo RH Status
:ForeverLoop
|- Service any events
/doevents
|- If we're stunned or RH is paused, just service events
/if (${Me.State.Equal[STUN]} || ${isPaused}) {
/delay 2
/goto :ForeverLoop
}
|- While fighting or not fighting...
|- Turn attacking back on if enraged target, and no longer facing it
/if (${isEnraged} && ${Target.ID} && ${AutoAssist} && !${Me.Combat}) {
/call Check_Behind
/varset behindTarget ${Macro.Return}
/if (${Target.ID} && ${behindTarget}) {
/attack on
/if (${Verbosity}>=1) /${Channel} ** Attack re-started (No Enrage Risk): ${Target.CleanName}
}
}
|- Check if we should chicken out
/if (${AutoChicken} && (${Me.PctHPs}<=${NimbleHealth}) && !${chickentimer}) {
/if (${Verbosity}>=1) /${Channel} Autochicken to the rescue!
/if (!${nimbletimer}) {
/disc nimble
/if (${Verbosity}>=1) /${Channel} Nimble mode activated!
/varset nimbletimer 21m
/varset nimbleactive 12s
} else /if (${Me.AltAbilityReady[Escape]} && !${nimbleactive}) {
/if (${Verbosity}>=1) /${Channel} Contingency Escape activated! (Nimble expired/unavailable)
/attack off
/alt activate 102
/varset chickentimer 30s
} else {
/if (${Verbosity}>=1) /${Channel} ... or not! Can't escape, can't nimble... Farewell!
/varset chickentimer 2m
}
}
|- Stop fighting if we lose our target
/if (${Me.Combat} && !${Target.ID}) /attack off
|- Are we suposed to stick to a target?
/if ((${Me.Combat} || ${strikeReady}) && ${Target.ID} && ${AutoStick} && (${Target.Distance}<${StickRangeToTarget}) && ${Target.Type.Equal[NPC]}) {
|- Check to see if we're too far from our tank (if applicable)
/if (${AutoAssist} && (${Spawn[${MainAssist}].Distance}>${StickRangeToTank})) {
/if (${useMU} && ${Stick.Status.Equal[ON]}) /squelch /stick off
/goto :DoneSticking
}
|- Check to see if we're mounted and dismount if so
/if (${Me.Buff[Summon Drogmor].ID} || ${Me.Buff[Summon Horse].ID}) /dismount
|- Use MQ2MoveUtils ? If so, start sticking and bypass RH movement tools
/if (${useMU}) {
/varset isTanking FALSE
/if (${aggrotimer.Value} || ${Me.TargetOfTarget.Name.Equal[${Me}]}) /varset isTanking TRUE
/if (!${Stick.Status.Equal[ON]} || ${snuggleup}) {
/if (${isTanking}) {
/squelch /stick ${Closeness}% mpause ${If[${Me.Swimming},uw,]}
} else {
/squelch /stick ${Closeness}% behind mpause ${If[${Me.Swimming},uw,]}
}
/varset snuggleup FALSE
} else {
/if (${Stick.MoveBehind}) {
/if (${isTanking}) {
/squelch /stick off
/if (${Verbosity}>=2) /${Channel} Switched to frontal sticking...
}
} else {
/if (!${isTanking}) {
/squelch /stick off
/if (${Verbosity}>=2) /${Channel} Maneuvering behind target again...
}
}
}
/goto :DoneSticking
}
/if (${Target.ID}) /face ${If[${Me.Swimming},,nolook]}
|- If we're too far away to hit it, get 1 second closer, unless we can hit it in less time
/if (${Target.Distance}>${Math.Calc[${Target.MaxRangeTo}*${Closeness}/100]}) {
|- Set current position first before potentially moving (in case we get stuck)
/varset X ${Me.X}
/varset Y ${Me.Y}
/if (!${Target.ID}) /goto :Foreverloop
|- Move
/keypress forward hold
/delay 1s ${Target.Distance}<${Math.Calc[${Target.MaxRangeTo}*${Closeness}/100]}
/keypress forward
|- Check to see if we got stuck trying that
/if ((${Me.X}==${X}) && (${Me.Y}==${Y})) {
|- We're stuck, back off a second, move left or right (randomly) for .5 seconds
/if (${Verbosity}>=2) /${Channel} We're STUCK on something, backing up...
/keypress back hold
/delay 1s
/keypress back
/if (${Math.Rand[2]}) {
/varset strafedir STRAFE_LEFT
} else {
/varset strafedir STRAFE_RIGHT
}
/if (${Verbosity}>=2) /${Channel} Unsticking: Strafing ${strafedir} a half-second...
/keypress ${strafedir} hold
/delay 5
/keypress ${strafedir}
}
}
/if (!${Target.ID}) /goto :Foreverloop
|- If we are close enough to hit it (and don't have aggro), lets try to get behind it a little bit at a time
/if ((${Target.Distance}<=${Target.MaxRangeTo}) && !${aggrotimer.Value} && !${Me.TargetOfTarget.Name.Equal[${Me}]}) {
/call Check_Behind
/varset behindTarget ${Macro.Return}
|- If we're not behind it, strafe around it a little
/if (!${behindTarget}) {
|- Which way do we strafe?
/varcalc delta ${Me.Heading.Clock}-${Target.Heading.Clock}
/if (${delta}>6) /varcalc delta ${delta}-12
/if (${delta}<-6) /varcalc delta ${delta}+12
/if (${delta}<0) {
/varset strafedir STRAFE_LEFT
} else {
/varset strafedir STRAFE_RIGHT
}
|- Set current position first before moving (in case we get stuck)
/varset X ${Me.X}
/varset Y ${Me.Y}
/if (!${Target.ID}) /goto :Foreverloop
|- Execute a strafe in the correct direction
/keypress ${strafedir} hold
/delay 2
/keypress ${strafedir}
/if (${Target.ID}) /face fast ${If[${Me.Swimming},,nolook]}
|- Check if we're stuck and warn if so (go through target to fix it)
/if ((${Me.X}==${X}) && (${Me.Y}==${Y})) {
/if (${Verbosity}>=2) /${Channel} We're STUCK trying to get behind target!
/delay 1s
}
}
}
} else {
/if (${useMU} && ${Stick.Status.Equal[ON]}) /squelch /stick off
}
:DoneSticking
|- Check on switching weapons (assuming it's a buff-weapon and buff is down)
/if (${WeaponSwitching} && ${wstype.Equal[Beneficial]}) {
/varset itemspellname ${FindItem[${Weapon1}].Spell}
/if (${itemspellname.NotEqual[${Me.Buff[${itemspellname}]}]} && !${FindItem[${Weapon1}].InvSlot.Name.Equal[mainhand]} && !${FindItem[${Weapon1}].InvSlot.Name.Equal[offhand]}) {
/if (${Verbosity}>=1) /${Channel} ** Beneficial proc-weapon swapping...
/call Weapon_Swap "${Weapon1}" "${Weapon2}"
}
}
|- Are we fighting?
/if (${Me.Combat}) {
|- ** We are fighting **
|- Respond to enraged targets
/if (${isEnraged} && ${Target.ID}) {
/call Check_Behind
/varset behindTarget ${Macro.Return}
/if (${Target.ID} && !${behindTarget}) {
/attack off
/if (${Verbosity}>=1) /${Channel} ** Attack ceased (Enrage Risk): ${Target.CleanName}
}
}
|- If we're sneaking, stop... since it serves no purpose and affects strafing
/if (${Me.Sneaking}) /doability "Sneak"
|- Check up on our autoassist targets if applicable, and switch if MA switches (1 second checks)
/if (${TargetSwitching} && ${AutoAssist} && ${Target.ID} && !${assisttimer}) {
/varset oldtargetID ${Target.ID}
/assist ${MainAssist}
/varset assisttimer 1s
}
|- Did we just switch targets? If so, turn off attack and start the loop over!
/if (${AutoAssist} && ${Target.ID}!=${oldtargetID}) {
/if (${Verbosity}>=1) /${Channel} --> *SWITCH* target to: ${Target.CleanName}
/varset oldtargetID ${Target.ID}
/attack off
/delay 2
/varset assisttimer 1s
/goto :ForeverLoop
}
|- Check for leash tugging and move back to stake some if so
/if (${Leashing}) {
/if (${LeashHolder.Equal[Nobody]} && (${Math.Distance[${Me.Y},${Me.X}:${stakeY},${stakeX}]}>${LeashLength})) {
/if (${Verbosity}>=2) /${Channel} CHOKE! We're at the leash's length! (${LeashLength} ft.)
/if (${Verbosity}>=1) /${Channel} ** Autoassist is now OFF!
/varset AutoAssist FALSE
/attack off
/if (${useMU}) /squelch /stick off
/face ${If[${Me.Swimming},,nolook]} loc ${stakeY},${stakeX}
/keypress forward hold
/delay 1s ${Math.Distance[${Me.Y},${Me.X}:${stakeY},${stakeX}]}<${Math.Calc[${LeashLength}*${LeashFlex}/100]}
/keypress forward
|- Slow 180degree turns take time, and we may have turned off attack, so...
/goto :ForeverLoop
}
/if (!${LeashHolder.Equal[Nobody]} && ${Spawn[${LeashHolder}].ID} && (${Spawn[${LeashHolder}].Distance}>${LeashLength})) {
/if (${Verbosity}>=2) /${Channel} CHOKE! Tugging on ${LeashHolder}'s leash! (${LeashLength} ft.)
/if (${Verbosity}>=1) /${Channel} ** Autoassist is now OFF!
/varset AutoAssist FALSE
/attack off
/if (${useMU}) /squelch /stick off
/squelch /face ${If[${Me.Swimming},,nolook]} id ${Spawn[${LeashHolder}].ID}
/keypress forward hold
/delay 1s ${Spawn[${LeashHolder}].Distance}<${Math.Calc[${LeashLength}*${LeashFlex}/100]}
/keypress forward
|- Slow 180degree turns take time, and we may have turned off attack, so...
/goto :ForeverLoop
}
|- Broken leash check
/if (!${LeashHolder.Equal[Nobody]} && !${Spawn[${LeashHolder}].ID}) {
/if (${Verbosity}>=1) /${Channel} ** Master DEAD or ZONED! Leash is BROKEN!
/varset Leashing FALSE
/varset LeashHolder Nobody
/ini "${INIFileName}" "General" "Leashing" "${Leashing}"
/ini "${INIFileName}" "General" "LeashHolder" "${LeashHolder}"
/goto :ForeverLoop
}
}
|- Are we standing, have a target, have backstab ready and can we stick it in the back?
/call Check_Behind
/varset behindTarget ${Macro.Return}
/if (${Target.ID} && ${Me.Standing} && !${Me.Casting.ID} && ${behindTarget} && (${Target.Distance}<${Math.Calc[${Target.MaxRangeTo}*${Closeness}/100]})) {
/if (${Me.AbilityReady["Backstab"]}) {
/doability "Backstab"
/if (${Verbosity}>=2) /${Channel} Backstabbing: ${Target.CleanName}
}
}
|- Are we tanking? If so, just stab it in the face if we can!
/if (${Target.ID} && ${Me.Standing} && !${Me.Casting.ID} && (${aggrotimer.Value} || ${Me.TargetOfTarget.Name.Equal[${Me}]})) {
/if (${Me.AbilityReady["Backstab"]} && ${InvSlot[mainhand].Item.Type.Equal[Piercing]}) {
/doability "Backstab"
/if (${Verbosity}>=1) /${Channel} Tanking -> Facestabbing: ${Target.CleanName}
}
}
|- Can we evade? Should we?
/if (${AutoEvade} && ${Target.ID} && !${Me.Casting.ID} && ${Me.AbilityReady["Hide"]} && (!${Me.Moving} || ${Me.AltAbilityReady[Nimble Evasion]})) {
/if (${Verbosity}>=2) /${Channel} Evading ${Target.CleanName}
/attack off
/delay 1
/doability "Hide"
/attack on
}
|- What's it got in it's pocketses?
/if (${AutoPickPocket} && ${Target.ID} && !${Me.Casting.ID} && (${Target.Distance}<15) && ${Me.AbilityReady["Pick Pockets"]}) {
/if (${Verbosity}>=2) /${Channel} Pick-pocketing ${Target.CleanName}
/attack off
/delay 1
/doability "Pick Pockets"
/attack on
/delay 1
/if (${Cursor.ID}) /autoinv
}
|- Are we so hurt we should stop fighting for a bit?
/if (${Me.PctHPs}<=${StopFightingHealth}) {
/attack off
/if (${Verbosity}>=1) /${Channel} Getting my ass kicked, ceasing combat!
}
|- Shall we do our optional discs?
/if (${AutoDisc1} && !${Disc1Reusetimer} && !${discactive} && !${strikeTimer} && ${Target.ID} && ${Target.PctHPs}>=50 && ${Me.PctEndurance}>=${Disc1Endurance}) {
/disc ${Disc1}
/if (${Verbosity}>=1) /${Channel} Disc #1: ${Disc1} activated
/delay 1s
/varset discactive 1m
/varset Disc1Reusetimer ${Disc1Reuse}m
}
/if (${AutoDisc2} && !${Disc2Reusetimer} && !${discactive} && !${strikeTimer} && ${Target.ID} && ${Target.PctHPs}>=50 && ${Me.PctEndurance}>=${Disc2Endurance}) {
/disc ${Disc2}
/if (${Verbosity}>=1) /${Channel} Disc #2: ${Disc2} activated
/delay 1s
/varset discactive 1m
/varset Disc2Reusetimer ${Disc2Reuse}m
}
} else {
|- ** We are not fighting
|- If we're not hiding or moving, check clicky maintained spells
/if (${Me.Invis} || ${Me.Moving} || ${clicktimer} || ${Me.State.Equal[BIND]}) /goto :DoneItemChecks
/varset i 1
:ItemCheckLoop
/varset ialias ${Ini[RHItems.ini].Arg[${i},|]}
/if (${ialias.NotEqual[NULL]}) {
|- Obtained an itemalias from the RHItems.ini file
|- We supposed to keep this spell up?
/if (${Ini[RHItems.ini,${ialias},KeepUp].Equal[FALSE]}) /goto :NextItem
|- Scan the item's bounce list for the active bouncers
/varset bouncenum 1
/varset doIclick TRUE
:BounceCheckLoop
/varset ibounce ${Ini[RHItems.ini,${ialias},BounceOff${bouncenum}]}
/if (${ibounce.NotEqual[NULL]}) {
/if (${ibounce.Equal[${Me.Buff[${ibounce}]}]}) /varset doIclick FALSE
} else /goto :DoneBounceChecks
/varcalc bouncenum ${bouncenum}+1
/goto :BounceCheckLoop
:DoneBounceChecks
|- By now we won't click the item if a bouncer spell is on us
|- Just have to check to see if the existing buff is on too
/varset itemspellname ${FindItem[${Ini[RHItems.ini,${ialias},FullName]}].Spell}
/if (${itemspellname.Equal[${Me.Buff[${itemspellname}]}]}) /varset doIclick FALSE
|- Finally, do it if we should
/if (${doIclick}) /docommand /iclick ${ialias}
|- Did we fail to find that previous item? (i.e. Dead and naked at bind point!)
/if (${clicktimer}) /goto :DoneItemChecks
:NextItem
/varcalc i ${i}+1
} else /goto :DoneItemChecks
/goto :ItemCheckLoop
:DoneItemChecks
|- Put the Closeness value back to the user's desired setting...
/varset Closeness ${Closenessdesired}
|- Lets hide and sneak if not already and we're set to do so **
/if (${AutoHideSneak} && ${Me.AbilityReady["Sneak"]} && !${Me.Casting.ID} && ${Me.State.NotEqual[BIND]} && !${Window[TradeWnd].Open} && !${Window[MerchantWnd].Open} && !${Window[BigBankWnd].Open}) /doability "Sneak"
/if (${AutoHideSneak} && ${Me.AbilityReady["Hide"]} && !${Me.Casting.ID} && ${Me.Sneaking} && (!${Me.Moving} || ${Me.AltAbilityReady[Nimble Evasion]}) && ${Me.State.NotEqual[BIND]} && !${Window[TradeWnd].Open} && !${Window[MerchantWnd].Open} && !${Window[BigBankWnd].Open}) /doability "Hide"
|- It's possible we're poised for a Strike, check and fight if so
/call Check_Behind
/varset behindTarget ${Macro.Return}
/if (${Target.ID} && ${Target.Type.Equal[NPC]} && ${Me.Standing} && ${Me.State.NotEqual[BIND]} && !${Me.Casting.ID} && ${behindTarget}) {
/if (${strikeReady} && ${Me.AbilityReady["Backstab"]}) {
/doability "Backstab"
/if (${Verbosity}>=1) /${Channel} Executing a strike: ${Target.CleanName}
/varset strikeReady FALSE
/attack on
}
}
|- It's also possible we never got behind a target and strike expired!
/if (${strikeReady} && ${Target.ID} && !${strikeTimer.Value} && ${Target.Type.Equal[NPC]}) {
/if (${Verbosity}>=2) /${Channel} Didn't find the back of a target in 30 seconds!
/varset strikeReady FALSE
/attack on
}
|- If we're set to autoassist, lets find a target
/if (${AutoAssist} && !${isEnraged} && !${Me.Casting.ID} && ${Me.State.NotEqual[BIND]}) {
|- Is main assist alive/in-zone?
/if (!${assisttimer} && !${strikeReady}) {
|- Lets try all the assists in priority order until we get an NPC to whack on
/if (!${Me.Casting.ID}) /assist ${FirstAssist}
/delay 1
/if (${Target.ID} && ${Target.Type.Equal[NPC]}) /goto :EngageCheck
/if (!${Me.Casting.ID}) /assist ${SecondAssist}
/delay 1
/if (${Target.ID} && ${Target.Type.Equal[NPC]}) /goto :EngageCheck
/if (!${Me.Casting.ID}) /assist ${ThirdAssist}
/delay 1
/if (${Target.ID} && ${Target.Type.Equal[NPC]}) /goto :EngageCheck
|- If we got here and don't have a target, tanks are invalid or no fighting is going on
/goto :EndAutoassist
:EngageCheck
/varset oldtargetID ${Target.ID}
/varset assisttimer ${Math.Calc[10+${Math.Rand[5]}].Int}
|- Who is the valid tank?
/if (${FirstAssist.Equal[Main]} || (${Math.Distance[${Target.Y},${Target.X}:${Spawn[pc ${FirstAssist}].Y},${Spawn[pc ${FirstAssist}].X}]}<${Target.MaxRangeTo})) {
/varset MainAssist ${FirstAssist}
/goto :LastAttackCheck
}
/if (${SecondAssist.Equal[Main]} || (${Math.Distance[${Target.Y},${Target.X}:${Spawn[pc ${SecondAssist}].Y},${Spawn[pc ${SecondAssist}].X}]}<${Target.MaxRangeTo})) {
/varset MainAssist ${SecondAssist}
/goto :LastAttackCheck
}
/if (${ThirdAssist.Equal[Main]} || (${Math.Distance[${Target.Y},${Target.X}:${Spawn[pc ${ThirdAssist}].Y},${Spawn[pc ${ThirdAssist}].X}]}<${Target.MaxRangeTo})) {
/varset MainAssist ${ThirdAssist}
/goto :LastAttackCheck
}
/goto :EndAutoassist
:LastAttackCheck
|- Do we have an NPC targeted and is it hurt enough to attack?
/if (${Target.PctHPs}<=${AssistPercentage} && ${Target.Animation}!=32 && ${Target.Animation}!=110) {
/if (${Verbosity}>=1) /${Channel} --> Assisting ${MainAssist} on ${Target.CleanName} @ (${Target.PctHPs}%) HPs
/echo Seeking a Victim...
/goto :Foreverloop
}
}
}
:EndAutoassist
|- Are we supposed to look for traps?
/if (${TrapNegotiation}) {
/varset oldheading ${Me.Heading.DegreesCCW}
/if (${Me.AbilityReady["Sense Traps"]}) {
/doability "Sense Traps"
/if (${Verbosity}>=2) /${Channel} Looking for traps...
}
}
|- We could be on a leash, if so move 1s closer to our stake point (or master)\\
/if (${Leashing} && !${strikeReady}) {
/varset lastevent Event_Leashing
:LeashStart
|- Look for new events
/doevents
/if (!${lastevent.Equal[Event_Leashing]}) /goto :ForeverLoop
/if (${Me.Combat}) /goto :ForeverLoop
/if (${LeashHolder.Equal[Nobody]} && (${Math.Distance[${Me.Y},${Me.X}:${stakeY},${stakeX}]}>${Math.Calc[${LeashLength}*${LeashFlex}/100]})) {
/if (${Verbosity}>=2) /${Channel} Moving closer to the Stake... ${Math.Distance[${Me.Y},${Me.X}:${stakeY},${stakeX}]} ft. away
/face ${If[${Me.Swimming},,nolook]} loc ${stakeY},${stakeX}
/keypress forward hold
/delay 1s ${Math.Distance[${Me.Y},${Me.X}:${stakeY},${stakeX}]}<${Math.Calc[${LeashLength}*${LeashFlex}/100]}
/keypress forward
/if (${Math.Distance[${Me.Y},${Me.X}:${stakeY},${stakeX}]}<${Math.Calc[${LeashLength}*${LeashFlex}/100]}) {
/if (${Verbosity}>=2) /${Channel} Arrived near enough to the Stake.
/face fast ${If[${Me.Swimming},,nolook]} away loc ${stakeY},${stakeX}
/goto :LeashEnd
}
/goto :LeashStart
}
/if (!${LeashHolder.Equal[Nobody]} && ${Spawn[${LeashHolder}].ID} && (${Spawn[${LeashHolder}].Distance}>${Math.Calc[${LeashLength}*${LeashFlex}/100]})) {
/if (${Verbosity}>=2) /${Channel} Moving closer to ${LeashHolder}... ${Spawn[${LeashHolder}].Distance} ft. away
/if (${Target.ID}!=${Spawn[${LeashHolder}].ID}) /target id ${Spawn[${LeashHolder}].ID}
/if (${Me.Combat}) /attack off
/face ${If[${Me.Swimming},,nolook]}
/keypress forward hold
/delay 1s ${Spawn[${LeashHolder}].Distance}<${Math.Calc[${LeashLength}*${LeashFlex}/100]}
/keypress forward
/if (${Spawn[${LeashHolder}].Distance}<${Math.Calc[${LeashLength}*${LeashFlex}/100]}) {
/if (${Verbosity}>=2) /${Channel} Arrived near enough to Master (${LeashHolder}).
/goto :LeashEnd
}
/goto :LeashStart
}
|- Broken leash check
/if (!${LeashHolder.Equal[Nobody]} && !${Spawn[${LeashHolder}].ID}) {
/if (${Verbosity}>=1) /${Channel} ** Master DEAD or ZONED! Leash is BROKEN!
/varset Leashing FALSE
/varset LeashHolder Nobody
/ini "${INIFileName}" "General" "Leashing" "${Leashing}"
/ini "${INIFileName}" "General" "LeashHolder" "${LeashHolder}"
/goto :LeashEnd
}
:LeashEnd
}
}
/goto :ForeverLoop
/return
Last edited by Cr4zyb4rd on Thu Oct 28, 2004 10:32 am, edited 1 time in total.
possibly something wrong with
Keeps trying to hide while moving around.
Code: Select all
/if (${AutoHideSneak} && ${Me.AbilityReady["Hide"]} && !${Me.Casting.ID} && ${Me.Sneaking} && (!${Me.Moving} || ${Me.AltAbilityReady[Nimble Evasion]}) && ${Me.State.NotEqual[BIND]} && !${Window[TradeWnd].Open} && !${Window[MerchantWnd].Open} && !${Window[BigBankWnd].Open}) /doability "Hide" ahem!
Code: Select all
|---- SUBROUTINES
Sub Check_Behind
/declare behindIt FALSE
|- Are we behind our target?
/for i -1 to 1
/varcalc dir (${Target.Heading.Clock}+${i})%12
/if (${dir}<1) /varcalc dir ${dir}+12
/if (${dir}>12) /varcalc dir ${dir}-12
/if (${dir} == ${Me.Heading.Clock}) /varset behindIt TRUE
/next i
/return ${behindIt}
Sub Weapon_Swap(string weapon, string wieldedweapon)
|- Is it in a Bag?
/declare camefrom ${FindItem[${weapon}].InvSlot}
/declare goingto ${FindItem[${wieldedweapon}].InvSlot}
/if (${Verbosity}>=2) /${Channel} ** Looking for weapon: ${weapon}
/if (${FindItem[${weapon}].InvSlot.Pack}) {
:OpenPack
/if (!${Window[${FindItem[${weapon}].InvSlot.Pack.Name}].Open}) {
/itemnotify ${FindItem[${weapon}].InvSlot.Pack.Name} rightmouseup
/delay 2
/goto :OpenPack
}
:GrabItem
/if (!${Cursor.ID}) {
/itemnotify ${InvSlot[${camefrom}]} leftmouseup
/delay 2
/goto :GrabItem
}
/declare weaponID int local ${Cursor.ID}
:SwapIt
/if (${Cursor.ID}==${weaponID}) {
/itemnotify ${InvSlot[${goingto}]} leftmouseup
/delay 2
/goto :SwapIt
}
/delay 2
/if (${Verbosity}>=2) /${Channel} ** Swapping out: ${weapon}
/itemnotify ${InvSlot[${camefrom}]} leftmouseup
/delay 2
/if (${Cursor.ID}) {
/if (${Verbosity}>=1) /${Channel} ** Failed to use existing slot, dropping to inventory!
/autoinv
}
:ClosePack
/if (${Window[${InvSlot[${camefrom}].Pack.Name}].Open}) {
/itemnotify ${InvSlot[${camefrom}].Pack.Name} rightmouseup
/delay 2
/goto :ClosePack
}
} else {
|- It's in the main inventory
/if (${FindItem[${weapon}].InvSlot}) {
/itemnotify ${FindItem[${weapon}].InvSlot} leftmouseup
/delay 2
/itemnotify ${InvSlot[${goingto}]} leftmouseup
/delay 2
/if (${Verbosity}>=2) /${Channel} ** Swapping out: ${weapon}
/itemnotify ${InvSlot[${camefrom}]} leftmouseup
/delay 2
/if (${Cursor.ID}) {
/if (${Verbosity}>=1) /${Channel} ** Failed to use existing slot, dropping to inventory!
/autoinv
}
} else {
/if (${Verbosity}>=1) /${Channel} ** "${weapon}" not found!
}
}
/return
Sub NinjaLoot
|- Ninja the corpse's loot, if applicable
/if (${AutoNinjaMode.NotEqual[OFF]}) {
/declare LootTotal int local -1
/declare LootSlot int local
|- Get NPC corpse on target and continue if possible
/squelch /target npc corpse radius ${AutoNinjaDistance}
/if (${Target.Type.NotEqual[CORPSE]} || !${Target.ID}) {
/if (${Verbosity}>=1) /${Channel} ** NPC corpse out of range or already looted!
/return
}
|- Get 5 seconds (max) closer; warning, no detecting being stuck!
/face ${If[${Me.Swimming},,nolook]} fast
/keypress forward hold
/delay 5s ${Target.Distance}<5
/keypress forward
|- Open up the loot window
/loot
/delay 1s
/if (${Me.State.NotEqual[BIND]}) {
/if (${Verbosity}>=1) /${Channel} ** Massive lag or error getting to corpse. Aborting!
/return
}
/if (${Verbosity}>=1) /${Channel} ** Looting ${Target.CleanName}
|- Get item count accurately
:LootLag
/if (${LootTotal}!=${Corpse.Items}) {
/varset LootTotal ${Corpse.Items}
/delay 5
/goto :LootLag
}
/if (!${LootTotal}) {
/if (${Verbosity}>=1) /${Channel} ** Empty corpse!
/goto :DoneLooting
}
|- Loot Loop
/for LootSlot 1 to ${LootTotal}
|- Check for full inventory
/if (!${Me.FreeInventory}) {
/beep
/if (${Verbosity}>=1) /${Channel} ** INVENTORY FULL !
/varset AutoNinjaMode OFF
/if (${Verbosity}>=1) /${Channel} ** AutoNinja is now OFF!
/goto :DoneLooting
}
|- Loot item if we should, skip it if not
/if (${Corpse.Item[${LootSlot}].ID}) {
/if (!${Corpse.Item[${LootSlot}].NoDrop}) /goto :LootItem
/if (${Corpse.Item[${LootSlot}].NoDrop} && ${AutoNinjaMode.Equal[ALL]}) {
/if (${Verbosity}>=1) /${Channel} ** Looting NODROP Item: ${Corpse.Item[${LootSlot}].Name}
/goto :LootItem
}
}
/if (${Verbosity}>=1) /${Channel} ** Skipping Item: ${Corpse.Item[${LootSlot}].Name}
/goto :SkipIt
:LootItem
/itemnotify loot${LootSlot} rightmouseup
/delay 3
/if (${Corpse.Item[${LootSlot}].ID}) {
/delay 2
/goto :LootItem
}
:SkipIt
/next LootSlot
/if (${Verbosity}>=1) /${Channel} ** Done looting ${Target.CleanName}
:DoneLooting
/delay 5
/notify LootWnd DoneButton leftmouseup
/delay 5
}
/return
|---- EVENTS
Sub Event_StrikeVic
/varset lastevent Event_StrikeVic
|- Is strike disc available, are we hiding/sneaking and do we have enough endurance to use it?
/if ((${Me.Invis} && ${Me.PctEndurance}>=${MinEndurance}) && !${strikeTimer.Value}) {
/if (${Verbosity}>=2) /${Channel} Taking careful aim: ${Target.CleanName}
/varset strikeTimer 30s
/disc ${StrikeSkill}
/varset strikeReady TRUE
} else {
|- Guess not, just attack normally then
/attack on
/varset strikeReady FALSE
}
/return
Sub Event_AttackOn
/varset lastevent Event_AttackOn
/if (${Verbosity}>=1) /${Channel} Autoattack activated! Target: ${Target.CleanName}
/varset acquiretimer 2s
/return
Sub Event_AttackOff
/varset lastevent Event_AttackOff
/if (${Verbosity}>=1) /${Channel} Autoattack turned off! Target: ${Target.CleanName}
/return
Sub Event_Enraged
/varset lastevent Event_Enraged
/if (${Verbosity}>=1) /${Channel} Enrage detected! Target: ${Target.CleanName}
/varset isEnraged TRUE
/return
Sub Event_NLEnraged
/varset lastevent Event_NLEnraged
/if (${Verbosity}>=1) /${Channel} Enrage done! Target: ${Target.CleanName}
/varset isEnraged FALSE
/if (${Target.ID} && ${AutoAssist}) /attack on
/return
Sub Event_Exp(string Line)
/varset lastevent Event_Exp
|- Ignore leadership experience event triggers (redundant trigger)
/if (${Line.Find[leadership]}) /return
|- Manage aggro control here optionally
/if (${doDynamicAggro} && ${AutoAssist}) {
/if (${gotHit}) {
|- Got hurt that fight, drop it 1%
/if (${AssistPercentage}>1) /varcalc AssistPercentage ${AssistPercentage}-1
/varset gotHit FALSE
/if (${Verbosity}>=1) /${Channel} ** Had Aggro! Reducing assist% to ${AssistPercentage}%
} else {
|- Did not get hurt that fight, raise it 1%
/if (${AssistPercentage}<99) /varcalc AssistPercentage ${AssistPercentage}+1
/if (${Verbosity}>=1) /${Channel} ** No Aggro! Raising assist% to ${AssistPercentage}%
}
}
|- Experience calculation and reporting
/if (${Verbosity}>=1) /${Channel} ** XP-Delta: REG (${Math.Calc[${Me.PctExp}-${Exp}]}%), AA (${Math.Calc[${Me.PctAAExp}-${AAExp}]}%), LDR (${Math.Calc[${Me.PctGroupLeaderExp}-${LDExp}]}%)
/varset LDExp ${Me.PctGroupLeaderExp}
/varset AAExp ${Me.PctAAExp}
/varset Exp ${Me.PctExp}
|- If target died while enraged, reset it so autoassist isn't broken...
/varset isEnraged FALSE
|- Do weapon swapping (back to Weapon1), if applicable
/if (${WeaponSwitching} && ${wstype.Equal[Detrimental]}) {
/call Weapon_Swap "${Weapon1}" "${Weapon2}"
}
/return
Sub Event_Slain
/varset lastevent Event_Slain
/call NinjaLoot
/return
Sub Event_Zoned
/varset lastevent Event_Zoned
/if (${Verbosity}>=1) /${Channel} ** Zoned... Setting Leash and Autoassist to OFF!
/varset Leashing FALSE
/varset AutoAssist FALSE
/ini "${INIFileName}" "General" "AutoAssist" "${AutoAssist}"
/ini "${INIFileName}" "General" "Leashing" "${Leashing}"
/return
Sub Event_TooFarAway
/varset lastevent Event_TooFarAway
/if (${doDynamicCloseness} && !${acquiretimer}) {
/if (${Verbosity}>=1) /${Channel} ** Too far away - Getting 20% closer now!
/varset Closeness ${Math.Calc[${Closeness}*0.8].Int}
/if (${Closeness}<20) /varset Closeness 20
/varset acquiretimer 2s
/varset snuggleup TRUE
}
/return
Sub Event_FTrap
/varset lastevent Event_FTrap
/if (${Verbosity}>=1) /${Channel} ** Floor Trap discovered...
/if (${Me.AbilityReady[Disarm Traps]}) {
/if (${Verbosity}>=2) /${Channel} ** Disarming...
/doability "Disarm Traps"
} else {
/if (${Verbosity}>=2) /${Channel} ** Can't disarm yet...
}
|- Face our "old" heading, in case we were spun around
/face nolook fast heading ${oldheading}
/return
Sub Event_BTrap
/varset lastevent Event_FTrap
/if (${Verbosity}>=1) /${Channel} ** Box Trap (${Target.CleanName}) discovered...
/if (${Me.AbilityReady[Disarm Traps]}) {
/if (${Verbosity}>=2) /${Channel} ** Disarming...
/doability "Disarm Traps"
} else {
/if (${Verbosity}>=2) /${Channel} ** Can't disarm yet...
}
|- Face our "old" heading, in case we were spun around
/face nolook fast heading ${oldheading}
/return
Sub Event_TogEvade
/varset lastevent Event_TogEvade
/if (${AutoEvade}) {
/varset AutoEvade FALSE
/if (${Verbosity}>=1) /${Channel} ** Auto-Evading target is now OFF!
} else {
/varset AutoEvade TRUE
/if (${Verbosity}>=1) /${Channel} ** Auto-Evading target is now ON!
}
/ini "${INIFileName}" "General" "AutoEvade" "${AutoEvade}"
/return
Sub Event_SetStopFighting(string Line)
/varset lastevent Event_SetStopFighting
/if (${Line.Arg[3].Length}) /varset StopFightingHealth ${Line.Arg[3]}
/if ((${StopFightingHealth}<0) || (${StopFightingHealth}>100)) {
/if (${Verbosity}>=0) /${Channel} Whacko stopfighting percentage input! Defaulting...
}
/if (${Verbosity}>=0) /${Channel} ** Cease Combat when at: ${StopFightingHealth}% HP
/ini "${INIFileName}" "General" "StopFightingHealth" "${StopFightingHealth}"
/return
Sub Event_SetStrikeDisc(string Line)
/varset lastevent Event_SetStrikeDisc
/if (${Line.Arg[3].Length}) /varset StrikeSkill ${Line.Arg[3]}
/if (${Verbosity}>=0) /${Channel} ** Strike Discipline set to: "${StrikeSkill}"
/ini "${INIFileName}" "General" "StrikeSkill" "${StrikeSkill}"
/return
Sub Event_SetEndFloor(string Line)
/varset lastevent Event_SetEndFLoor
/if (${Line.Arg[3].Length}) /varset MinEndurance ${Line.Arg[3]}
/if ((${MinEndurance}<0) || (${MinEndurance}>101)) {
/if (${Verbosity}>=0) /${Channel} Whacko endurance percentage input! Defaulting...
}
/if (${Verbosity}>=0) /${Channel} ** Endurance Floor: ${MinEndurance}%
/ini "${INIFileName}" "General" "MinEndurance" "${MinEndurance}"
/return
Sub Event_TogStick
/varset lastevent Event_TogStick
/if (${AutoStick}) {
/varset AutoStick FALSE
/if (${Verbosity}>=0) /${Channel} ** Auto-Sticking target is now OFF!
} else {
/varset AutoStick TRUE
/if (${Verbosity}>=0) /${Channel} ** Auto-Sticking target is now ON!
}
/ini "${INIFileName}" "General" "AutoStick" "${AutoStick}"
/return
Sub Event_TogHS
/varset lastevent Event_TogHS
/if (${AutoHideSneak}) {
/varset AutoHideSneak FALSE
/if (${Verbosity}>=0) /${Channel} ** Auto-Hiding & Sneaking is now OFF!
} else {
/varset AutoHideSneak TRUE
/if (${Verbosity}>=0) /${Channel} ** Auto-Hiding & Sneaking is now ON!
}
/ini "${INIFileName}" "General" "AutoHideSneak" "${AutoHideSneak}"
/return
Sub Event_TogLeash(string Line)
/varset lastevent Event_TogLeash
/if (${Line.Arg[3].Equal[ON]}) {
/varset Leashing TRUE
/if (${Verbosity}>=0) /${Channel} ** Leashing is now ON!
/ini "${INIFileName}" "General" "Leashing" "${Leashing}"
} else /if (${Line.Arg[3].Equal[OFF]} || (${Int[${Line.Arg[3]}]}<=0)) {
/varset Leashing FALSE
/varset LeashHolder Nobody
/if (${Verbosity}>=0) /${Channel} ** Leashing is now OFF!
/ini "${INIFileName}" "General" "Leashing" "${Leashing}"
} else {
/if (${Line.Arg[4].Length}) {
/varset LeashHolder ${Line.Arg[4]}
/if (${Spawn[${LeashHolder}].ID}) {
/varset Leashing TRUE
/varset LeashLength ${Int[${Line.Arg[3]}]}
/if (${Verbosity}>=0) /${Channel} ** Leashing is now ON! LeashLength: ${LeashLength} ft.
/if (${Verbosity}>=0) /${Channel} ** Leash-holding master is: ${LeashHolder}
/ini "${INIFileName}" "General" "Leashing" "${Leashing}"
} else {
|- This spawn/thing/target doesn't exist
/if (${Verbosity}>=0) /${Channel} ** Can't find "${LeashHolder}" -- Who is that?!
/if (${Verbosity}>=0) /${Channel} ** Leashing is now OFF!
/varset Leashing FALSE
/varset LeashHolder Nobody
}
} else {
/varset Leashing TRUE
/varset LeashHolder Nobody
/varset LeashLength ${Int[${Line.Arg[3]}]}
/varset stakeX ${Me.X}
/varset stakeY ${Me.Y}
/if (${Verbosity}>=0) /${Channel} ** Leashing is now ON! LeashLength: ${LeashLength} ft.
/if (${Verbosity}>=0) /${Channel} ** Stake planted at X:${stakeX}, Y:${stakeY}
}
}
/ini "${INIFileName}" "General" "LeashHolder" "${LeashHolder}"
/ini "${INIFileName}" "General" "LeashLength" "${LeashLength}"
/return
Sub Event_SetLeashFlex(string Line)
/varset lastevent Event_SetLeashFlex
/if (${Line.Arg[3].Length}) /varset LeashFlex ${Line.Arg[3]}
/if ((${LeashFlex}<10) || (${LeashFlex}>101)) {
/if (${Verbosity}>=0) /${Channel} Leash flexibility must be between 10 and 100! Defaulting to 10...
/varset LeashFlex 10
}
/if (${Verbosity}>=0) /${Channel} ** Leash Flexibility: ${LeashFlex}%
/ini "${INIFileName}" "General" "LeashFlex" "${LeashFlex}"
/return
Sub Event_TogAuto(string Line)
/varset lastevent Event_TogAuto
/if (${Line.Arg[3].Equal[OFF]}) {
/varset AutoAssist FALSE
/if (${Verbosity}>=0) /${Channel} ** Autoassist is now OFF!
} else /if (${Line.Arg[3].Equal[ON]}) {
/varset AutoAssist TRUE
/if (${Verbosity}>=0) /${Channel} ** Autoassist is now ON!
} else {
/varset AutoAssist TRUE
/if (${Line.Arg[3].Length}) /varset FirstAssist ${Line.Arg[3]}
/varset MainAssist ${FirstAssist}
/if (${Line.Arg[4]} > 0) /varset AssistPercentage ${Line.Arg[4]}
/if (${Verbosity}>=0) /${Channel} ** Autoassist is now ON!
/if (${Verbosity}>=0) /${Channel} ** Assisting: ${MainAssist} @${AssistPercentage}% target health
/if (${Verbosity}>=0) /${Channel} ** SA is ${SecondAssist} & TA is ${ThirdAssist}
}
/ini "${INIFileName}" "General" "AutoAssist" "${AutoAssist}"
/ini "${INIFileName}" "General" "MainAssist" "${FirstAssist}"
/ini "${INIFileName}" "General" "AssistPercentage" "${AssistPercentage}"
/return
Sub Event_TogPause
/varset lastevent Event_TogPause
/beep
/if (${isPaused}) {
/varset isPaused FALSE
/if (${Verbosity}>=0) /${Channel} ** Rogue Helper is now RESUMING!
} else {
/varset isPaused TRUE
/if (${Verbosity}>=0) /${Channel} ** Rogue Helper is now PAUSED!
}
/return
Sub Event_TogDynamicAggro
/varset lastevent Event_TogDynamicAggro
/if (${doDynamicAggro}) {
/varset doDynamicAggro FALSE
/if (${Verbosity}>=0) /${Channel} ** Dynamic Aggro Control is now OFF!
} else {
/varset doDynamicAggro TRUE
/if (${Verbosity}>=0) /${Channel} ** Dynamic Aggro Control is now ON!
}
/ini "${INIFileName}" "General" "DynamicAggro" "${doDynamicAggro}"
/return
Sub Event_TogDynamicCloseness
/varset lastevent Event_TogDynamicCloseness
/if (${doDynamicCloseness}) {
/varset doDynamicCloseness FALSE
/if (${Verbosity}>=0) /${Channel} ** Dynamic Closeness Control is now OFF!
} else {
/varset doDynamicCloseness TRUE
/if (${Verbosity}>=0) /${Channel} ** Dynamic Closeness Control is now ON!
}
/ini "${INIFileName}" "General" "DynamicCloseness" "${doDynamicCloseness}"
/return
Sub Event_TogPick
/varset lastevent Event_TogPick
/if (${AutoPickPocket}) {
/varset AutoPickPocket FALSE
/if (${Verbosity}>=0) /${Channel} ** Auto-Pickpocketing is now OFF!
} else {
/varset AutoPickPocket TRUE
/if (${Verbosity}>=0) /${Channel} ** Auto-Pickpocketing is now ON!
}
/ini "${INIFileName}" "General" "AutoPickPocket" "${AutoPickPocket}"
/return
Sub Event_TogTSwitch
/varset lastevent Event_TogTSwitch
/if (${TargetSwitching}) {
/varset TargetSwitching FALSE
/if (${Verbosity}>=0) /${Channel} ** Auto-Target Switching is now OFF!
} else {
/varset TargetSwitching TRUE
/if (${Verbosity}>=0) /${Channel} ** Auto-Target Switching is now ON!
}
/ini "${INIFileName}" "General" "TargetSwitching" "${TargetSwitching}"
/return
Sub Event_TogTraps
/varset lastevent Event_TogTraps
/if (${TrapNegotiation}) {
/varset TrapNegotiation FALSE
/if (${Verbosity}>=0) /${Channel} ** Auto-Trap Negotiation is now OFF!
} else {
/varset TrapNegotiation TRUE
/if (${Verbosity}>=0) /${Channel} ** Auto-Trap Negotiation is now ON!
}
/ini "${INIFileName}" "General" "TrapNegotiation" "${TrapNegotiation}"
/return
Sub Event_SetCloseness(string Line)
/varset lastevent Event_SetCloseness
/if (${Line.Arg[3].Length}) /varset Closeness ${Line.Arg[3]}
/if ((${Closeness}<1) || (${Closeness}>100)) {
/if (${Verbosity}>=0) /${Channel} Whacko Closeness percentage input! Defaulting...
/varset Closeness 70
}
/varset Closenessdesired ${Closeness}
/if (${Verbosity}>=0) /${Channel} ** AutoStick: ${AutoStick}, Closeness: ${Closeness}
/ini "${INIFileName}" "General" "Closeness" "${Closeness}"
/return
Sub Event_SetFirstAssist(string Line)
/varset lastevent Event_SetFirstAssist
/if (${Line.Arg[3].Length}) /varset FirstAssist ${Line.Arg[3]}
/varset MainAssist ${FirstAssist}
/if (${Verbosity}>=0) /${Channel} ** Assisting: ${MainAssist} @${AssistPercentage}% target health
/if (${Verbosity}>=0) /${Channel} ** SA is ${SecondAssist} & TA is ${ThirdAssist}
/ini "${INIFileName}" "General" "MainAssist" "${FirstAssist}"
/return
Sub Event_SetSecondAssist(string Line)
/varset lastevent Event_SetSecondAssist
/if (${Line.Arg[3].Length}) /varset SecondAssist ${Line.Arg[3]}
/if (${Verbosity}>=0) /${Channel} ** Assisting: ${MainAssist} @${AssistPercentage}% target health
/if (${Verbosity}>=0) /${Channel} ** SA is ${SecondAssist} & TA is ${ThirdAssist}
/ini "${INIFileName}" "General" "SecondAssist" "${SecondAssist}"
/return
Sub Event_SetThirdAssist(string Line)
/varset lastevent Event_SetThirdAssist
/if (${Line.Arg[3].Length}) /varset ThirdAssist ${Line.Arg[3]}
/if (${Verbosity}>=0) /${Channel} ** Assisting: ${MainAssist} @${AssistPercentage}% target health
/if (${Verbosity}>=0) /${Channel} ** SA is ${SecondAssist} & TA is ${ThirdAssist}
/ini "${INIFileName}" "General" "ThirdAssist" "${ThirdAssist}"
/return
Sub Event_SetAutoNinja(string Line)
/varset lastevent Event_SetAutoNinja
|- Set the new ninja distance, if supplied
/if (${Line.Arg[4].Length}) /varset AutoNinjaDistance ${Line.Arg[4]}
|- Set the mode, toggle off if unknown
/if (${Line.Arg[3].Equal[ALL]}) {
/varset AutoNinjaMode ALL
/if (${Verbosity}>=0) /${Channel} ** AutoNinja ON - Will loot ALL items
/docommand /lootnodrop never
} else /if ((${Line.Arg[3].Equal[DROP]}) || (${Line.Arg[3].Equal[DROPABLE]})) {
/varset AutoNinjaMode DROPABLE
/if (${Verbosity}>=0) /${Channel} ** AutoNinja ON - Will loot only DROPABLE items
/docommand /lootnodrop never
} else {
/varset AutoNinjaMode OFF
/if (${Verbosity}>=0) /${Channel} ** AutoNinja is now OFF!
}
/if (${Verbosity}>=0) /${Channel} ** AutoNinja distance is ${AutoNinjaDistance} ft.
/ini "${INIFileName}" "General" "AutoAutoNinjaMode" "${AutoNinjaMode}"
/ini "${INIFileName}" "General" "AutoAutoNinjaDistanceance" "${AutoNinjaDistance}"
/return
Sub Event_SetWeaponSwitch(string Line)
/varset lastevent Event_SetWeaponSwitch
|- Sanity Check
/if (${Line.Arg[3].Equal[OFF]} || !${Line.Arg[5].Length} || ${Line.Arg[6].Length}) {
/varset WeaponSwitching FALSE
/if (${Verbosity}>=0) /${Channel} ** Auto Weapon Switching is OFF
/goto :SaveSwitchSettings
}
|- Set the weaponswitching information
/if (${Line.Arg[3].Length}) /varset Weapon1 ${Line.Arg[3]}
/if (${Line.Arg[4].Length}) /varset SwitchText ${Line.Arg[4]}
/if (${Line.Arg[5].Length}) /varset Weapon2 ${Line.Arg[5]}
/varset WeaponSwitching TRUE
/if (${Verbosity}>=0) /${Channel} ** Auto Weapon Switching is ON
/if (${Verbosity}>=0) /${Channel} ** ${Weapon1} will be swapped out for ${Weapon2}
/if (${Verbosity}>=0) /${Channel} ** if the text "${SwitchText}" is encountered.
:SaveSwitchSettings
/doevents flush
/ini "${INIFileName}" "General" "WeaponSwitching" "${WeaponSwitching}"
/ini "${INIFileName}" "Weapons" "Weapon1" "${Weapon1}"
/ini "${INIFileName}" "Weapons" "Weapon2" "${Weapon2}"
/ini "${INIFileName}" "Weapons" "SwitchText" "${SwitchText}"
/varset wstype ${FindItem[${Weapon1}].Spell.SpellType}
/return
Sub Event_SetStickDist(string Line)
/varset lastevent Event_SetStickDist
|- Sanity Check
/if (!${Line.Arg[3].Length} || !${Line.Arg[4].Length}) {
/if (${Verbosity}>=0) /${Channel} ** What? Bad Syntax.
/if (${Verbosity}>=0) /${Channel} Syntax:
/if (${Verbosity}>=0) /${Channel} /stickdist <range_to_target> <range_to_tank>
/return
}
|- Set the weaponswitching information
/varset StickRangeToTarget ${Line.Arg[3]}
/varset StickRangeToTank ${Line.Arg[4]}
/if (${Verbosity}>=0) /${Channel} ** Auto Stick: ${AutoStick}, Closeness: ${Closeness}% MaxRange
/if (${Verbosity}>=0) /${Channel} ** -- Range to Target: ${StickRangeToTarget} -- Range to Tank: ${StickRangeToTank}
/ini "${INIFileName}" "General" "StickRangeToTarget" "${StickRangeToTarget}"
/ini "${INIFileName}" "General" "StickRangeToTank" "${StickRangeToTank}"
/return
Sub Event_SetChicken(string Line)
/varset lastevent Event_SetChicken
/if (${Line.Arg[3].Equal[OFF]}) {
/varset AutoChicken FALSE
/if (${Verbosity}>=0) /${Channel} ** Autochicken is now OFF!
} else /if (${Line.Arg[3].Equal[ON]}) {
/varset AutoChicken TRUE
/if (${Verbosity}>=0) /${Channel} ** Autochicken is now ON!
} else {
/varset AutoChicken TRUE
/if (${Line.Arg[3].Length}) /varset NimbleHealth ${Line.Arg[3]}
/if (${Line.Arg[4].Equal[ESCAPE]}) {
/varset ContingencyEscape TRUE
} else {
/varset ContingencyEscape FALSE
}
/if (${Verbosity}>=0) /${Channel} ** Auto Chicken: ${AutoChicken} -- Nimble: ${NimbleHealth}% Escape: ${ContingencyEscape}
}
/ini "${INIFileName}" "General" "AutoChicken" "${AutoChicken}"
/ini "${INIFileName}" "General" "NimbleHealth" "${NimbleHealth}"
/ini "${INIFileName}" "General" "ContingencyEscape" "${ContingencyEscape}"
/return
Sub Event_SetDisc1(string Line)
/varset lastevent Event_SetDisc1
/if (${Line.Arg[3].Equal[OFF]}) {
/varset AutoDisc1 FALSE
/if (${Verbosity}>=0) /${Channel} ** Autodisc #1 is now OFF!
} else /if (${Line.Arg[3].Equal[ON]}) {
/varset AutoDisc1 TRUE
/if (${Verbosity}>=0) /${Channel} ** Autodisc #1 is now ON!
} else {
/varset AutoDisc1 TRUE
/if (${Line.Arg[3].Length}) /varset Disc1 ${Line.Arg[3]}
/if (${Line.Arg[4]} > 0) /varset Disc1Endurance ${Line.Arg[4]}
/if (${Line.Arg[5]} > 0) /varset Disc1Reuse ${Line.Arg[5]}
/if (${Verbosity}>=0) /${Channel} ** Auto Disc #1: ${AutoDisc1} -> ${Disc1}/${Disc1Reuse} mins - End: ${Disc1Endurance}
}
/ini "${INIFileName}" "General" "AutoDisc1" "${AutoDisc1}"
/ini "${INIFileName}" "General" "Disc1" "${Disc1}"
/ini "${INIFileName}" "General" "Disc1Endurance" "${Disc1Endurance}"
/ini "${INIFileName}" "General" "Disc1Reuse" "${Disc1Reuse}"
/return
Sub Event_SetDisc2(string Line)
/varset lastevent Event_SetDisc2
/if (${Line.Arg[3].Equal[OFF]}) {
/varset AutoDisc2 FALSE
/if (${Verbosity}>=0) /${Channel} ** Autodisc #2 is now OFF!
} else /if (${Line.Arg[3].Equal[ON]}) {
/varset AutoDisc2 TRUE
/if (${Verbosity}>=0) /${Channel} ** Autodisc #2 is now ON!
} else {
/varset AutoDisc2 TRUE
/if (${Line.Arg[3].Length}) /varset Disc2 ${Line.Arg[3]}
/if (${Line.Arg[4]} > 0) /varset Disc2Endurance ${Line.Arg[4]}
/if (${Line.Arg[5]} > 0) /varset Disc2Reuse ${Line.Arg[5]}
/if (${Verbosity}>=0) /${Channel} ** Auto Disc #2: ${AutoDisc2} -> ${Disc2}/${Disc2Reuse} mins - End: ${Disc2Endurance}
}
/ini "${INIFileName}" "General" "AutoDisc2" "${AutoDisc2}"
/ini "${INIFileName}" "General" "Disc2" "${Disc2}"
/ini "${INIFileName}" "General" "Disc2Endurance" "${Disc2Endurance}"
/ini "${INIFileName}" "General" "Disc2Reuse" "${Disc2Reuse}"
/return
Sub Event_SetVerbosity(string Line)
/varset lastevent Event_SetVerbosity
/if (${Line.Arg[3].Length}) /varset Verbosity ${Line.Arg[3]}
/if ((${Verbosity}<0) || (${Verbosity}>2)) {
/if (${Verbosity}>=0) /${Channel} Verbosity must be between 0 and 2! Defaulting to 2...
/varset Verbosity 2
}
/if (${Verbosity}>=0) /${Channel} ** Verbosity Level: ${Verbosity}
/ini "${INIFileName}" "General" "Verbosity" "${Verbosity}"
/return
Sub Event_SetChannel(string Line)
/varset lastevent Event_SetChannel
/if (${Line.Arg[3].Length}) /varset Channel ${Line.Arg[3]}
/if (${Verbosity}>=0) /${Channel} ** RH Output Channel: ${Channel}
/ini "${INIFileName}" "General" "Channel" "${Channel}"
/return
Sub Event_SwitchWeapon
/varset lastevent Event_SwitchWeapon
/if (${WeaponSwitching}) {
/call Weapon_Swap "${Weapon2}" "${Weapon1}"
}
/return
Sub Event_GotHit
/varset lastevent Event_GotHit
/if (!${aggrotimer}) /if (${Verbosity}>=1) /${Channel} ** AGGRO Detected (struck) **
/varset gotHit TRUE
/varset aggrotimer 5s
/return
Sub Event_GotMissed
/varset lastevent Event_GotMissed
/if (!${aggrotimer}) /if (${Verbosity}>=1) /${Channel} ** AGGRO Detected (whiff) **
/varset gotHit TRUE
/varset aggrotimer 5s
/return
Sub Event_SpellBounced
/varset lastevent Event_SpellBounced
/varset clicktimer 60s
/beep
/beep
/beep
/if (${Verbosity}>=1) /${Channel} ** Just detected a BOUNCED spell!
/if (${Verbosity}>=1) /${Channel} ** Use /ibounce to update click-item info!
/return
Sub Event_DragBodies(string Line)
/varset lastevent Event_DragBodies
/declare ArgNum int local 3
/declare bodycount int local
:CountCorpses
/if (${Line.Arg[${ArgNum}].Length}) {
|- There's a body name for this argument
/varcalc ArgNum ${ArgNum}+1
/goto :CountCorpses
}
/varcalc ArgNum ${ArgNum}-1
/if (${ArgNum}==2) {
/if (${Verbosity}>=0) /${Channel} ** No corpse names supplied!
/return
} else {
/if (${Verbosity}>=0) /${Channel} ** Target self (F1) to stop dragging!
}
:DragLoop
/for bodycount 3 to ${ArgNum}
/if (${Target.CleanName.Equal[${Me.Name}]}) {
/if (${Verbosity}>=0) /${Channel} ** Body dragging ceased.
/goto :CeaseDragging
}
/target ${Line.Arg[${bodycount}]}'s
/corpse
|- Lower this delay at your own risk; too many /corpse commands too fast = cheater!
/delay 4
/next bodycount
/goto :DragLoop
:CeaseDragging
/return
Sub Event_LootMyCorpse
/varset lastevent Event_LootMyCorpse
|- Logic ripped off from Loot.mac and simplified somewhat
/declare LootTotal int local 0
/declare LootSlot int local
|- Get corpse on target and continue looting if possible
/squelch /target mycorpse
/if (${Target.Type.NotEqual[CORPSE]} || !${Target.ID}) {
/if (${Verbosity}>=0) /${Channel} ** Can't target my corpse.
/return
}
/corpse
/delay 1s
/loot
/delay 1s
/if (${Me.State.NotEqual[BIND]}) {
/if (${Verbosity}>=0) /${Channel} ** Massive lag right now... Aborting looting.
/return
}
|- Get item count accurately
:LootLag
/if (${LootTotal}!=${Corpse.Items}) {
/varset LootTotal ${Corpse.Items}
/delay 5
/goto :LootLag
}
|- Loot Loop
/for LootSlot 1 to ${LootTotal}
:LootItem
/itemnotify loot${LootSlot} rightmouseup
/delay 3
/if (${Corpse.Item[${LootSlot}].ID}) {
/delay 2
/goto :LootItem
}
/next LootSlot
/delay 5
/if (${Verbosity}>=0) /${Channel} ** Done looting my corpse.
/notify LootWnd DoneButton leftmouseup
/return
Sub Event_AutoFollow(string Line)
/varset lastevent Event_AutoFollow
/declare distance int local 30
/if (${Ini[${INIFileName},General,FollowDistance].NotEqual[NULL]}) /varset distance ${Ini[${INIFileName},General,FollowDistance]}
/if (${Line.Arg[3].Length}) /target ${Line.Arg[3]}
/if (${Line.Arg[4].Length}) /varset distance ${Line.Arg[4]}
/if (${distance}<10) /varset distance 10
/ini "${INIFileName}" "General" "FollowDistance" "${distance}"
/if (${Target.ID}) {
/if (${Verbosity}>=0) /${Channel} ** Autofollow on: ${Target.CleanName} (${distance} ft.)
/if (${Verbosity}>=0) /${Channel} ** Change targets to stop autofollowing.
} else {
/if (${Verbosity}>=0) /${Channel} ** Can't activate Autofollow -- no valid target!
/return
}
/declare followID int local ${Target.ID}
:FollowingLoop
|- Look for new events
/doevents
/if (!${lastevent.Equal[Event_AutoFollow]}) {
/if (${Verbosity}>=0) /${Channel} ** Autofollow blocked by: ${lastevent}
/goto :StopFollowing
}
/if (${Target.ID}==${followID}) {
/if (${Target.ID}) /face fast
/if (${Target.Distance}>${distance}) {
/keypress forward hold
/delay 1s ${Target.Distance}<=${distance}
/keypress forward
}
/goto :FollowingLoop
}
:StopFollowing
/if (${Verbosity}>=0) /${Channel} ** Autofollow ended.
/return
Sub Event_ItemSet(string Line)
/varset lastevent Event_ItemSet
|- Sanity check parameters
/if (!${Line.Arg[5].Length} || ${Line.Arg[6].Length}) {
/if (${Verbosity}>=0) /${Channel} ** Improper use of /iset
/if (${Verbosity}>=0) /${Channel} -- /iset <itemalias> keepup|nokeepup <"Item Name">
/if (${Verbosity}>=0) /${Channel} -- For example:
/if (${Verbosity}>=0) /${Channel} -- /iset gobby keepup "Shrunken Goblin Skull Earring"
/return
}
/ini "RHItems.ini" "${Line.Arg[3]}" "FullName" "${Line.Arg[5]}"
/ini "RHItems.ini" "${Line.Arg[3]}" "KeepUp" "${If[${Line.Arg[4].Equal[keepup]},TRUE,FALSE]}"
/if (${Verbosity}>=0) /${Channel} ** ${Line.Arg[5]} (KeepUp=${If[${Line.Arg[4].Equal[keepup]},TRUE,FALSE]}) updated in INI!
/return
Sub Event_ItemBounce(string Line)
/varset lastevent Event_ItemBounce
|- Sanity check parameters
/if (!${Line.Arg[4].Length}) {
/if (${Verbosity}>=0) /${Channel} ** Improper use of /ibounce
/if (${Verbosity}>=0) /${Channel} -- /ibounce <itemalias> "Some Spell Name"
/if (${Verbosity}>=0) /${Channel} -- For example:
/if (${Verbosity}>=0) /${Channel} -- /ibounce gobby "Strength of Tunare"
/return
}
|- Look for that item's section, return if non-existent
/if (!${Ini[RHItems.ini,${Line.Arg[3]}].Length}) {
/if (${Verbosity}>=0) /${Channel} ** [${Line.Arg[3]}] not in INI file!
/return
}
|- Find the next available BounceOff key number and store the spell
/declare bindex int local 1
:CheckNextKey
/if (${Ini[RHItems.ini,${Line.Arg[3]},BounceOff${bindex}].Length}) {
|- This one is in use...
/varcalc bindex ${bindex}+1
/goto :CheckNextKey
} else {
|- This one not defined (yet). Good.
/ini "RHItems.ini" "${Line.Arg[3]}" "BounceOff${bindex}" "${Line.Arg[4]}"
/if (${Verbosity}>=0) /${Channel} ** Added "${Line.Arg[4]}" to [${Line.Arg[3]}]'s bounce list
}
/return
Sub Event_ItemCast(string Line)
/varset lastevent Event_ItemCast
|- Sanity check parameter
/if (!${Line.Arg[3].Length}) {
/if (${Verbosity}>=0) /${Channel} ** Improper use of /icast
/if (${Verbosity}>=0) /${Channel} -- /icast <itemalias>
/if (${Verbosity}>=0) /${Channel} -- For example:
/if (${Verbosity}>=0) /${Channel} -- /icast gobby
/return
}
|- Look for that item's section, return if non-existent
/if (!${Ini[RHItems.ini,${Line.Arg[3]}].Length}) {
/if (${Verbosity}>=0) /${Channel} ** [${Line.Arg[3]}] not in INI file!
/return
}
/declare fullname string local ${Ini[RHItems.ini,${Line.Arg[3]},FullName]}
|- Is it in a Bag?
/if (${Verbosity}>=1) /${Channel} ** Attempting to use: ${fullname}
/if (${FindItem[${fullname}].InvSlot.Pack}) {
:OpenPack
/if (!${Window[${FindItem[${fullname}].InvSlot.Pack.Name}].Open}) {
/itemnotify ${FindItem[${fullname}].InvSlot.Pack.Name} rightmouseup
/delay 2
/goto :OpenPack
}
/declare camefrom ${FindItem[${fullname}].InvSlot}
:GrabItem
/if (!${Cursor.ID}) {
/itemnotify ${InvSlot[${camefrom}]} leftmouseup
/delay 2
/goto :GrabItem
}
/declare clickyID int local ${Cursor.ID}
/declare wornat int local ${Cursor.WornSlot[1]}
:SwapFirst
/if (${Cursor.ID}==${clickyID}) {
/itemnotify ${InvSlot[${wornat}]} leftmouseup
/delay 2
/goto :SwapFirst
}
|- Click it
/delay 2
/if (${Verbosity}>=1) /${Channel} ** Clicking: ${fullname}
/declare previousID ${Cursor.ID}
/itemnotify ${InvSlot[${wornat}]} rightmouseup
:SwapAgain
/if (${Cursor.ID}==${previousID}) {
/itemnotify ${InvSlot[${wornat}]} leftmouseup
/delay 2
/goto :SwapAgain
}
|- Put it back
:PutItBack
/if (${Cursor.ID}==${clickyID}) {
/itemnotify ${InvSlot[${camefrom}]} leftmouseup
/delay 2
/goto :PutItBack
}
:SummonedCheck
/if (${Cursor.ID}) {
|- Something was summoned
/autoinv
/delay 2
/goto :SummonedCheck
}
:ClosePack
/if (${Window[${InvSlot[${camefrom}].Pack.Name}].Open}) {
/itemnotify ${InvSlot[${camefrom}].Pack.Name} rightmouseup
/delay 2
/goto :ClosePack
}
} else {
|- Just click it
/if (${FindItem[${fullname}].InvSlot}) {
/if (${Verbosity}>=1) /${Channel} ** Clicking: ${fullname}
/itemnotify ${FindItem[${fullname}].InvSlot} rightmouseup
/delay 2
} else {
/if (${Verbosity}>=0) /${Channel} ** "${fullname}" not found!
}
}
:CastLoop
/delay 1
/if (${Me.Casting.ID}) /goto :CastLoop
/return
Sub Event_LinkParse(string Line)
/varset lastevent Event_LinkParse
/if (${Line.Arg[3].Length}) {
/declare comtext string ${Line.Right[-16]}
/declare linksub ${comtext.Token[1,*]}0013895-00001-00001-00001-00001-00001A04D01F5${comtext.Token[2,*]}${comtext.Token[3,*]}
/docommand ${linksub}
}
/return
Sub Event_AddMaster(string Line)
/varset lastevent Event_AddMaster
/declare index int local
/if (${Line.Arg[3].Length}) {
/for index 1 to 20
/if (${Ini[${INIFileName},Masters,Controller${index}].Equal[Nobody]}) {
/ini "${INIFileName}" "Masters" "Controller${index}" "${Line.Arg[3]}"
/if (${Verbosity}>=0) /${Channel} ** ${Line.Arg[3]} added as a controller...
/goto :FallOut
}
/next index
/if (${Verbosity}>=0) /${Channel} ** Master controller slots all filled! Get rid of some!
} else {
/if (${Verbosity}>=0) /${Channel} ** Huh?
}
:FallOut
/return
Sub Event_RemMaster(string Line)
/varset lastevent Event_RemMaster
/declare index int local
/if (${Line.Arg[3].Length}) {
/for index 1 to 20
/if (${Ini[${INIFileName},Masters,Controller${index}].Equal[${Line.Arg[3]}]}) {
/ini "${INIFileName}" "Masters" "Controller${index}" "Nobody"
/if (${Verbosity}>=0) /${Channel} ** ${Line.Arg[3]} removed from controller list...
/goto :FallOut
}
/next index
/if (${Verbosity}>=0) /${Channel} ** Can't find ${Line.Arg[3]} in access list!
} else {
/if (${Verbosity}>=0) /${Channel} ** Huh?
}
:FallOut
/return
Sub Event_Chat(ChatType, Sender, ChatText)
/varset lastevent Event_Chat
|- Authenticate if valid controller
/declare authorized bool local FALSE
/for i 1 to 20
/if (${Ini[${INIFileName},Masters,Controller${i}].Equal[${Sender}]}) /varset authorized TRUE
/next i
/if (${authorized} && ${ChatText.Left[1].Equal[/]}) {
/if (${Verbosity}>=1) /${Channel} ** User ${Sender} Authenticated!
/if (${Verbosity}>=0) /${Channel} Action --> "${ChatText}"
/if (${Me.AFK}) /delay 2s
/tell ${Sender} Command received, performing: ${ChatText}
/docommand ${ChatText}
}
/return
Sub Event_HelpInfo
/varset lastevent Event_HelpInfo
/if (${Verbosity}>=0) /${Channel} --------=========(RH Help)=========----------
/if (${Verbosity}>=0) /${Channel} /rhhelp - Display this information!
/if (${Verbosity}>=0) /${Channel} /status - Display status of all RH modes
/if (${Verbosity}>=0) /${Channel} /pause - Suspends the operations of RH
/if (${Verbosity}>=0) /${Channel} /autoevade - Toggle autoevading on or off
/if (${Verbosity}>=0) /${Channel} /stopfight <%> - Set % of your health to stop attacking
/if (${Verbosity}>=0) /${Channel} /strikedisc <StrikeSkill> - Set to your best strike skill
/if (${Verbosity}>=0) /${Channel} /endfloor <%> - Set % of your endurance needed to strike
/if (${Verbosity}>=0) /${Channel} /autostick - Toggle autosticking to NPCs while attacking
/if (${Verbosity}>=0) /${Channel} /stickdist <range_target> <range_tank> - Set stick thresholds
/if (${Verbosity}>=0) /${Channel} /autohs - Toggle automatic hiding/sneaking while not fighting
/if (${Verbosity}>=0) /${Channel} /Closeness <%> - Set % of max hit range while autosticking
/if (${Verbosity}>=0) /${Channel} /DynamicCloseness - Toggle automatic real time Closeness adjustments
/if (${Verbosity}>=0) /${Channel} /autoassist <main_assist> <%health> - Activate autoassist
/if (${Verbosity}>=0) /${Channel} /autoassist off - Disable autoassisting
/if (${Verbosity}>=0) /${Channel} /autoassist on - Turn on autoassist w/existing tank info
/if (${Verbosity}>=0) /${Channel} /MainAssist <player> - Sets main assist to <player>
/if (${Verbosity}>=0) /${Channel} /SecondAssist <player> - Sets secondary assist to <player>
/if (${Verbosity}>=0) /${Channel} /ThirdAssist <player> - Sets third assist to <player>
/if (${Verbosity}>=0) /${Channel} /DynamicAggro - Toggle dynamic management of assist health %
/if (${Verbosity}>=0) /${Channel} /leash <distance> - Activate leash with <distance> ft.
/if (${Verbosity}>=0) /${Channel} /leash <distance> <master> - Activate leash w/a master
/if (${Verbosity}>=0) /${Channel} /leash off - Disable leashing
/if (${Verbosity}>=0) /${Channel} /LeashFlex <%length> - Set leash flexibility
/if (${Verbosity}>=0) /${Channel} /drag <body1> <body2> ... <bodyN> - Drag corpses
/if (${Verbosity}>=0) /${Channel} /lootmycorpse - Loot your own corpse completely
/if (${Verbosity}>=0) /${Channel} /iset <itemalias> keepup|nokeepup <"Item Name"> - Item settings
/if (${Verbosity}>=0) /${Channel} /ibounce <itemalias> <"Spell Name"> - Add bounce-off spell
/if (${Verbosity}>=0) /${Channel} /iclick <itemalias> - Click cast item defined in <itemalias>
/if (${Verbosity}>=0) /${Channel} /autoninja <mode> [<range>] - Automatic NPC corpse looting
/if (${Verbosity}>=0) /${Channel} /autofollow [<name>] [<distance>] - Follow <name> at <distance>
/if (${Verbosity}>=0) /${Channel} /autopick - Toggle pick-pocketing during combat on or off
/if (${Verbosity}>=0) /${Channel} /weaponswitch <Weapon1> <"switch text"> <Weapon2> - weapon swap
/if (${Verbosity}>=0) /${Channel} /targetswitch - Toggle autoswitching of targets in autoassist
/if (${Verbosity}>=0) /${Channel} /autotraps - Toggle autonegotiation of traps
/if (${Verbosity}>=0) /${Channel} /autochicken [ON|OFF|<nimble%>] [ESCAPE] - Preseves your life
/if (${Verbosity}>=0) /${Channel} /autoDisc1 "Discipline Name"|ON|OFF <end%> <reuse> - Auto disc 1
/if (${Verbosity}>=0) /${Channel} /autoDisc2 "Discipline Name"|ON|OFF <end%> <reuse> - Auto disc 2
/if (${Verbosity}>=0) /${Channel} /addmaster <name> - Add a master to remote control users
/if (${Verbosity}>=0) /${Channel} /remmaster <name> - Remove a master from remote control users
/return
Sub Event_StatInfo
/varset lastevent Event_StatInfo
/if (${Verbosity}>=0) /${Channel} -------=======(Current Status)=======--------
|- Check for the presense of MQ2MoveUtils plugin
/if (${Stick.Status.Length}) {
/varset useMU TRUE
/if (${Verbosity}>=0) /${Channel} ** MQ2MoveUtils ENABLED (Enhanced Movement ON)
} else {
/varset useMU FALSE
/if (${Verbosity}>=0) /${Channel} ** MQ2MoveUtils NOT FOUND (Enhanced Movement OFF)
}
/if (${Verbosity}>=0) /${Channel} ** Auto Evade: ${AutoEvade}, Cease Combat: ${StopFightingHealth}% HP
/if (${Verbosity}>=0) /${Channel} ** Auto Stick: ${AutoStick}, Closeness${If[${doDynamicCloseness},[DYN],]}: ${Closeness}% MaxRange
/if (${Verbosity}>=0) /${Channel} ** -- Range to Target: ${StickRangeToTarget} -- Range to Tank: ${StickRangeToTank}
/if (${Verbosity}>=0) /${Channel} ** Auto Hide&Sneak: ${AutoHideSneak}, Auto Pickpocket: ${AutoPickPocket}
/if (${Verbosity}>=0) /${Channel} ** Auto Chicken: ${AutoChicken} -- Nimble: ${NimbleHealth}% Escape: ${ContingencyEscape}
/if (${Verbosity}>=0) /${Channel} ** Auto Ninja: ${AutoNinjaMode}, Distance: ${AutoNinjaDistance} ft.
/if (${Verbosity}>=0) /${Channel} ** Auto TargetSwitching: ${TargetSwitching}, Auto Traps: ${TrapNegotiation}
/if (${Verbosity}>=0) /${Channel} ** Auto Assist: ${AutoAssist}, Assist at ${AssistPercentage}% HP
/if (${Verbosity}>=0) /${Channel} ** MA: ${FirstAssist}, SA: ${SecondAssist}, TA: ${ThirdAssist}
/if (${Verbosity}>=0) /${Channel} ** Leashing: ${Leashing} (${LeashLength} ft.), Master: ${LeashHolder}, Flex: ${LeashFlex}
/if (${Verbosity}>=0) /${Channel} ** Strike Skill: "${StrikeSkill}", End. Floor: ${MinEndurance}%
/if (${Verbosity}>=0) /${Channel} ** Auto Disc #1: ${AutoDisc1} -> ${Disc1} / ${Disc1Reuse} mins - End: ${Disc1Endurance}%
/if (${Verbosity}>=0) /${Channel} ** Auto Disc #2: ${AutoDisc2} -> ${Disc2} / ${Disc2Reuse} mins - End: ${Disc2Endurance}%
/if (${Verbosity}>=0) /${Channel} ** Dynamic Aggro Control: ${doDynamicAggro}
/if (${Verbosity}>=0) /${Channel} ** WeaponSwitching: ${WeaponSwitching}, ${Weapon1}->${Weapon2} (${SwitchText})
/if (${Verbosity}>=0) /${Channel} ** Authorized remote controllers:
/for i 1 to 20
/if (${Ini[${INIFileName},Masters,Controller${i}].NotEqual[Nobody]}) /if (${Verbosity}>=0) /${Channel} ---- ${Ini[${INIFileName},Masters,Controller${i}]} allowed...
/next i
/doevents flush
/return Iclick "Must equip" items...
Anyway to make it so it wil temp auto-equip an iclick item then remove it after the effect has been gained? (ie, Shrunken Goblin Skull Earring)