Wolf5 is the original developer and deserves full credit.. im just moving the post.
Code: Select all
#event SelfSlain "#*#You have been slain by#*# "
#event SlainTarget "#*#You have slain#*# "
#event NoOverWrite "Your spell would not have taken hold on your target."
#event LostTarget "#*#You no longer have a target#*#"
#event Encumbered "#*#You are encumbered!#*# "
#turbo 30
#include spellcast.inc
#define THE_SLACK_DEGREE 25
#define SEARCH_RADIUS 499
|If the PCT of your pet and yourself differs from this number, you will back off
#define LET_PET_TANK_IF_DIFFERENCE 20
#define LOOT_ABOVE_LEVEL 20
#define LOOT_ITEMS False
#define INITIALIZE_ATTACK_RANGE 150
#define ARE_WE_RESTLESS True
#define RESTLESS_RANGE 200
#define FORCE_ATTACK_WHEN_MOB_BELOW 30
#define MAX_RANGE_FROM_HOMEPOINT 1000
#define ALLWAYS_HAVE_PET True
#define MAX_PET_RANGE_BEFORE_SUMMON 250
#define PET_SPELL "Spirit of Zehkes"
#define PET_GEM 7
#define DO_SLOW_ON_PULL True
#define SEND_PET_BEFORE_SLOW True
#define SLOW_GREENS False
#define SLOW_ABOVE_LEVEL 30
#define SLOW_SPELL "Sha's Lethargy"
#define SLOW_GEM 2
#define DO_NUKE_ON_PULL True
#define NUKE_ABOVE_MANA_PCT 80
#define NUKE_ABOVE_LEVEL 30
#define NUKE_SPELL "Ice Shard"
#define NUKE_GEM 1
#define HEAL_BELOW_PCT 65
#define HEAL_SPELL "Healing"
#define HEAL_GEM 4
#define ALARM_HEALTH_BELOW_PCT 40
#define HEAL_PET_BELOW_PCT 50
#define HEAL_PET_SPELL "Sha's Restoration"
#define HEAL_PET_GEM 5
#define MIN_MANA_BEFORE_MEDITATE 30
|Buffs to be kept up on self
#define SELF_SPELL1 "Spirit of Wolf"
#define SELF_GEM1 8
#define SELF_SPELL2 "Chloroplast"
#define SELF_GEM2 6
#define SELF_SPELL3 "Deftness"
#define SELF_GEM3 3
#define SELF_SPELL4 "Furious Strength"
#define SELF_GEM4 3
#define SELF_SPELL5 "Spiritual Radiance"
#define SELF_GEM5 3
#define SELF_SPELL6 "Frenzy"
#define SELF_GEM6 6
|Buffs to be kept up on pet
#define PET_SPELL1 "Spirit of Wolf"
#define PET_GEM1 8
#define PET_SPELL2 "Spirit of the Storm"
#define PET_GEM2 6
#define PET_SPELL3 "Bond of the Wild"
#define PET_GEM3 3
#define PET_SPELL4 "Deftness"
#define PET_GEM4 4
|--------------------------------------------------------------------------------
|SUB: Main
|--------------------------------------------------------------------------------
Sub Main
/echo Starting macro
/declare rand int outer |random var
/declare rand2 int outer |random var
/declare TargetDist float outer |Distance to Target
/declare TargetLevel int outer |Level of Target
/declare TargetName string outer |Name of Target
/declare tmp string outer |Just a tmp string
/declare tmpint int outer |Just a tmp int
/declare tmpint2 int outer |Just a tmp int
/declare tmpint3 int outer |Just a tmp int
/declare tmpint4 int outer |Just a tmp int
/declare killcnt int outer |Kill counter (loot counter)
/varset killcnt 0
/declare homeX float outer |Our homepoint
/declare homeY float outer |Our homepoint
/declare rndX float outer |Our homepoint
/declare rndY float outer |Our homepoint
/varset homeX ${Me.X}
/varset homeY ${Me.Y}
/varset rndX ${Me.X}
/varset rndY ${Me.Y}
/echo Homepoint: ${Me.X} ${Me.Y}
/declare leftdown bool outer |Are we turning left
/declare rightdown bool outer |Are we turning right
/declare forwarddown bool outer |Are we moving forward
/declare petattacking bool outer |Is pet attacking
/declare theslack int outer |the global slack on FaceTarget
/varset theslack THE_SLACK_DEGREE
/declare oldposx float outer |Used to determine if we are stuck
/declare oldposy float outer |Used to determine if we are stuck
/declare slackcounter int outer |Used to unstuck ourselves
/declare slackchance int outer |Used to unstuck ourselves
/varset slackcounter 10000
/declare cnt1 int outer
/varset cnt1 0
/declare waitcounter int outer |How many times shall we get no target found before we do something (run/wait/gohome)
/varset waitcounter 0
|Getting targets
/declare numbtargs int outer
/declare target1 string outer
/if (${Defined[Param0]}) /varset target1 ${Param0}
/varcalc numbtargs ${target1.Count["|"]} + 1
/declare targets[${numbtargs}] string outer
/echo Targets: ${numbtargs}
/varset tmpint4 1
:nexttarget
/varcalc tmpint ${target1.Find["|"]} - 1
/if ( ${tmpint}>-1 ) {
/varcalc tmpint2 ${target1.Length} - ${tmpint} - 1
/echo targets[${tmpint4}] ${target1.Left[${tmpint}]}
/varset targets[${tmpint4}] ${target1.Left[${tmpint}]}
/varcalc tmpint4 ${tmpint4} + 1
/varset target1 ${target1.Right[${tmpint2}]}
/goto :nexttarget
} else {
/echo targets[${tmpint4}] ${target1}
/varset targets[${tmpint4}] ${target1}
}
/declare repeat bool outer
/declare myRequiredTarget bool outer
/goto :FirstTime
|The main loop. After an attack we go here to aquire a new target
:MainLoop1
/doevents
/varset TargetLevel ${Target.Level}
/varset TargetName ${Target.CleanName}
/call StopAttack
|/echo mainloop
/if ( ${Target.ID} && ${Target.Type.Equal["NPC"]} ) {
/echo Fight in progress: ${Target.CleanName}
/goto :MainAttackLoop
}
/varset cnt1 ${Math.Calc[${cnt1} + 1]}
/if ( ${cnt1}>=3 ) {
/call AssistPet
/delay 1s
/varset cnt1 0
/varset TargetLevel ${Target.Level}
/varset TargetName ${Target.CleanName}
/if ( ${Target.ID} && ${Target.Type.Equal["NPC"]} ) {
/echo Assisting pet: ${Target.CleanName}
/varset petattacking True
/goto :MainAttackLoop
}
}
/if ( ${Target.ID} ) /keypress ESC
:FirstTime
/call MoveForwardStop
/varset repeat False
/varset myRequiredTarget False
| Check if we are low on mana or health. Heal or sit down if low
/call ManaAndHealth
/if ( ${repeat} ) /goto :MainLoop1
| Make sure pet is up + all its buffs are on it
/call MaintainPet
/if ( ${repeat} ) /goto :MainLoop1
| Make sure all buffs on self are up
/call MaintainSelf
/if ( ${repeat} ) /goto :MainLoop1
| If I don't have a target, aquire a new target
|/echo Target: ${Target.CleanName}
/varset petattacking False
/if ( !${Target.ID} ) {
| Target next NPC
|/echo Do target
/varset TargetDist ${Math.Distance[${homeY},${homeX},0:${Me.Y},${Me.X},0]}
/if ( ${TargetDist}>MAX_RANGE_FROM_HOMEPOINT ) {
|Run to homespot
/echo To far away (${TargetDist})! Running home.
/call RunToSpot ${homeX} ${homeY}
/call MoveForwardStop
/if ( ${TargetDist}<40 ) /varset waitcounter 0
/goto :MainLoop1
}
/call TargetIt
/varset TargetDist ${Math.Distance[${homeY},${homeX},0:${Me.Y},${Me.X},0]}
/if ( ${TargetDist}>40 ) {
|If we are not at homespot, count till we run home
/varset waitcounter ${Math.Calc[${waitcounter} + 1]}
} else {
|If we are restless, run around after a little while
/if ( ${Bool[ARE_WE_RESTLESS]} ) {
/varset waitcounter ${Math.Calc[${waitcounter} - 1]}
/if ( ${waitcounter}<-5 ) {
:Retarget
/echo We are restless. Running a bit. ${rndX}, ${rndY}
/for tmpint 0 to 10
/call StepToSpot ${rndX} ${rndY}
/delay 1
/next tmpint
/call MoveForwardStop
/call TargetIt
/varset TargetDist ${Math.Distance[${rndY},${rndX},0:${Me.Y},${Me.X},0]}
/if ( ${TargetDist}<40 ) {
/varset waitcounter 0
/if ( ${Math.Rand[10]} < 5 ) {
/varset rndX ${Math.Calc[ ${Me.X} + ${Math.Rand[RESTLESS_RANGE]} * 2 ]}
} else {
/varset rndX ${Math.Calc[ ${Me.X} - ${Math.Rand[RESTLESS_RANGE]} * 2 ]}
}
/if ( ${Math.Rand[10]} < 5 ) {
/varset rndY ${Math.Calc[ ${Me.Y} + ${Math.Rand[RESTLESS_RANGE]} * 2 ]}
} else {
/varset rndY ${Math.Calc[ ${Me.Y} - ${Math.Rand[RESTLESS_RANGE]} * 2 ]}
}
/varset waitcounter 0
/goto :MainLoop1
}
/if ( !${Target.ID} ) /goto :Retarget
}
}
}
/if ( !${Target.ID} && ${waitcounter}==1 ) {
/if ( !${Me.Sitting} ) /sit
}
/if ( ${waitcounter}>3 ) {
|Run to homespot
/echo Running home.
/for rand 0 to 5
/call StepToSpot ${homeX} ${homeY}
/delay 1
/next rand
/call MoveForwardStop
/varset TargetDist ${Math.Distance[${homeY},${homeX},0:${Me.Y},${Me.X},0]}
/if ( ${TargetDist}<40 ) /varset waitcounter 0
/goto :MainLoop1
}
/if (!${Target.ID}) {
/delay 4s
/goto :MainLoop1
}
/varset myRequiredTarget True
|A target. If its 100% we go for it
/if ( ${Target.ID} && ${Target.PctHPs}<100 ) {
/echo Target aquired is < 100%
/keypress ESC
/delay 2s
/goto :MainLoop1
}
/varset TargetLevel ${Target.Level}
/varset TargetName ${Target.CleanName}
}
|Not having a npc in target means we have to try again
/if ( !${Target.Type.Equal["NPC"]} ) {
/delay 1s
/keypress ESC
/goto :MainLoop1
}
/echo Target: ${Target.CleanName} ${Target.Level} ${Target.Class}
|The main attack loop - Here all the attacking will take place
:MainAttackLoop
/doevents
/varset waitcounter 0
|Beep when we get below alarm health level
/if ( ${Me.PctHPs}<ALARM_HEALTH_BELOW_PCT ) {
/beep
}
/if ( !${Target.ID} ) {
/echo Ending fight, No Target
/call MoveForwardStop
/call DoTheLooting
/if ( ${Target} ) { /keypress ESC
}
|Assisting pet
/if (!${Target.ID}) {
/call AssistPet
:WaitUntill
/if ( ${Target.Type.Equal["Pet"]} ) {
/delay 1
/goto :WaitUntill
}
}
|/echo TargetType: ${Target.Type}
/if (!${Target.ID} || ${Target.Type.Equal["Corpse"]}) {
/call MoveForwardStop
/delay ${Math.Rand[30]}
/goto :MainLoop1
}
/if ( !${Target.Type.Equal["NPC"]} ) {
/call MoveForwardStop
/delay ${Math.Rand[70]}
/echo Ending fight, No NPC
/keypress ESC
/goto :MainLoop1
}
| Stop when close so we dont run around in circle and KICK
/varset TargetDist ${Math.Calc[ ${Target.DistancePredict} - (${Target.MaxRangeTo}/1.2) ]}
/if (${TargetDist}<6) {
/if ( ${Me.AbilityReady["kick"]} ) /doability "kick"
/call MoveForwardStop
}
| Initialize attack
/if ( ${TargetDist}<INITIALIZE_ATTACK_RANGE && !${petattacking} ) {
/if ( ${Target.PctHPs}<100 && ${myRequiredTarget} ) {
| If this target is below 100% and I targeted it manually it is probably just snatched before me
/keypress ESC
/echo Ending fight, Target < 100%
/goto :MainLoop1
}
/if (${Bool[SEND_PET_BEFORE_SLOW]}) {
/pet attack
/varset petattacking True
/echo Attacking ${Target.CleanName}!
}
/if (${Bool[DO_SLOW_ON_PULL]}) {
/if ( ${Bool[SLOW_GREENS]} || ( !${Bool[SLOW_GREENS]} && !${Target.ConColor.Equal["GREEN"]} ) ) {
/if ( ${Target.Level}>SLOW_ABOVE_LEVEL) {
/echo Casting slow!
/call Cast "SLOW_SPELL" gem2
}
}
}
/if (!${Me.Combat} && ${Target.PctHPs}<100) {
| Someone else grabbed it before I got the chance to charge (maybe during slow)
/pet back
/delay 1
/pet back
/keypress ESC
/echo Ending fight, Not Attacking + Target < 100% before Slow went in
/goto :MainLoop1
}
/if (!${Bool[SEND_PET_BEFORE_SLOW]}) {
/pet attack
/varset petattacking True
/echo Attacking ${Target.CleanName}!
}
/call DoTheNuke
}
/if ( ${TargetDist}>200) {
|If we are not attacking and the health of the mob is below 100% asume someone else has it. back off!
/if (!${Me.Combat} && ${Target.PctHPs}<100) {
/echo Ending fight, Not Attacking + Target < 100%
/keypress ESC
/goto :MainLoop1
}
}
/if ( ${Target.Type.Equal["NPC"]} && ${Target.PctHPs}>FORCE_ATTACK_WHEN_MOB_BELOW ) /call BackoffForPet
/call CheckGM
/call StepToTarget
/delay 1
|If we are moving forward, check if we are stuck, and remedy it if we are
/if (${forwarddown}) /call StuckFixTarget
|Add a little bit of strafing - Add to natural movement
/varset rand ${Math.Rand[600]}
/if ( ${rand}<100 ) {
/keypress strafe_right hold
} else /if ( ${rand}<200 ) {
/keypress strafe_left hold
} else
/keypress strafe_right
/keypress strafe_left
}
/goto :MainAttackLoop
:EndMacro
/endmacro
Sub DestroyCopper
/windowstate InventoryWindow open
/shift /notify InventoryWindow IW_Money3 leftmouseup
|Are we sure we want to destroy it? Give me 10 seconds to drop in autoinv
/delay 1s
/destroy
|/windowstate InventoryWindow close
/keypress I
/return
Sub DestroySilver
/windowstate InventoryWindow open
/shift /notify InventoryWindow IW_Money2 leftmouseup
|Are we sure we want to destroy it? Give me 10 seconds to drop in autoinv
/delay 1s
/destroy
/keypress I
|/windowstate InventoryWindow close
/return
|--------------------------------------------------------------------------------
|SUB: TargetIt
|--------------------------------------------------------------------------------
Sub TargetIt
/for tmpint 1 to ${numbtargs}
/target npc radius SEARCH_RADIUS nopcnear 200 ${targets[${tmpint}]}
/if ( ${Target.ID} ) /return
/next tmpint
/return
|--------------------------------------------------------------------------------
|SUB: DoTheNuke
|--------------------------------------------------------------------------------
Sub DoTheNuke
/if (${Bool[DO_NUKE_ON_PULL]}) {
/if ( ${Me.PctMana}>NUKE_ABOVE_MANA_PCT) {
/if ( ${Target.Level}>SLOW_ABOVE_LEVEL) {
/call Cast "NUKE_SPELL" gem1
}
}
}
/return
|--------------------------------------------------------------------------------
|SUB: BackoffForPet
|--------------------------------------------------------------------------------
Sub BackoffForPet
/declare TargDist float local
/if ( ${Math.Calc[ ${Me.Pet.PctHPs} - ${Me.PctHPs} ]} > LET_PET_TANK_IF_DIFFERENCE ) {
/keypress back hold
:BackOff1
/varset TargDist ${Math.Calc[ ${Target.Distance} - (${Target.MaxRangeTo}/1.2) - 15 ]}
/if ( ${TargDist}<0 ) {
/delay 1
/goto :BackOff1
}
/attack off
/keypress back
:Repeat1
/echo Letting pet tank some!
/call MaintainPet
/keypress ESC
/if ( !${Me.Sitting} ) /sit
|/delay 1s
|/if ( ${Target.ID} ) /return
|What if mob is dead
/call AssistPet
/delay 1s
/if ( !${Target.Type.Equal["Corpse"]} ) /return
/if ( !${Target.ID} ) /return
/if ( ${Target.PctHPs}<FORCE_ATTACK_WHEN_MOB_BELOW ) /return
/if ( !${Me.Sitting} ) /sit
/call MaintainSelf
/if ( !${Me.Sitting} ) /sit
|Nuke some!
/call DoTheNuke
/if ( !${Me.Sitting} ) /sit
|Will wait and help the pet til it reaches same % of health as self
/if ( ${Math.Calc[ ${Me.Pet.PctHPs} - ${Me.PctHPs} ]} > 0 ) /goto :Repeat1
/call MaintainPet
}
/return
|--------------------------------------------------------------------------------
|SUB: StartAttack
|--------------------------------------------------------------------------------
Sub StartAttack
/if ( !${Me.Combat} ) /attack on
/return
|--------------------------------------------------------------------------------
|SUB: StopAttack
|--------------------------------------------------------------------------------
Sub StopAttack
/if ( ${Me.Combat} ) /attack off
/return
|--------------------------------------------------------------------------------
|SUB: AssistPet
|--------------------------------------------------------------------------------
Sub AssistPet
/if ( !${Target.ID} ) {
|/pet target
|/delay 2
/keypress ESC
/keypress F1
/keypress F1
/assist
/delay 2
}
/return
|--------------------------------------------------------------------------------
|SUB: StepToTarget
|--------------------------------------------------------------------------------
Sub StepToTarget(float X, float Y)
|When stuck, run towards target with a large slack (120 degrees) for a little while - narrowing the slack
/if ( ${theslack} == 95 ) {
/varset theslack 94
/varset slackcounter 0
/varset slackchance ${Math.Calc[${Math.Rand[80]}]}
}
/if ( ${theslack} > THE_SLACK_DEGREE ) {
/varset slackcounter ${Math.Calc[${slackcounter}+1]}
}
/if ( ${slackcounter} == 20 ) {
/varset theslack 70
}
/if ( ${slackcounter} == 40 ) {
/varset theslack 50
}
/if ( ${slackcounter} == 60 ) {
/varset theslack 30
}
/if ( ${slackcounter} == ${slackchance} ) {
/varset theslack THE_SLACK_DEGREE
/varset slackcounter 10000
}
|/echo Counter: ${slackcounter}
/call FaceTarget
/declare TargDist float local
/varset TargDist ${Math.Calc[ ${Target.DistancePredict} - (${Target.MaxRangeTo}/1.2) ]}
/if ( ${TargDist} < 0 ) {
/call StartAttack
/call MoveForwardStop
/return
}
/call MoveForward
/return
|--------------------------------------------------------------------------------
|SUB: DoTheLooting
|--------------------------------------------------------------------------------
Sub DoTheLooting
/if (${TargetLevel}>LOOT_ABOVE_LEVEL) {
/target ${TargetName}'s corpse
/delay 1s
/call RunToSpotTarget
/if ( ${Target.Type.Equal["Corpse"]} ) {
/varcalc killcnt ${killcnt}+1
/echo Looting corpse #${killcnt}
/call LootMob
/varset theslack THE_SLACK_DEGREE
/varset slackcounter 10000
|/varset oldposx 99999
|/varset oldposy 99999
/call MoveForward
}
} else {
/keypress ESC
}
/return
|--------------------------------------------------------------------------------
|SUB: ManaAndHealth
|--------------------------------------------------------------------------------
Sub ManaAndHealth
/if ( ${Me.PctHPs}<HEAL_BELOW_PCT && ${Me.PctMana}<50 ) {
/delay 1s
/if ( !${Me.Sitting} ) /sit
/varset repeat True
/return
}
|Meditate?
/if ( ${Me.PctMana}<MIN_MANA_BEFORE_MEDITATE ) {
/echo Mana below MIN_MANA_BEFORE_MEDITATE%. Meditating.
/if ( !${Me.Sitting} ) /sit
/delay 10s
/if ( ${Me.PctMana}<MIN_MANA_BEFORE_MEDITATE ) {
/varset repeat True
/return
}
/echo Mana OK now.
}
|Heal?
/if ( ${Me.PctHPs}<HEAL_BELOW_PCT ) {
/target ${Me.Name}
/call Cast "HEAL_SPELL" gemHEAL_GEM
/if ( !${Me.Sitting} ) /sit
/varset repeat True
/return
}
/return
|--------------------------------------------------------------------------------
|SUB: MaintainPet
|--------------------------------------------------------------------------------
Sub MaintainPet
|If we have pet
/varset tmp ${Me.Pet}
/if ( ${Bool[ALLWAYS_HAVE_PET]} ) {
/if ( ${tmp.Equal["NULL"]} ) {
/echo Creating new pet
/call Cast "PET_SPELL" gemPET_GEM
/varset repeat True
/return
}
/if ( MAX_PET_RANGE_BEFORE_SUMMON>0 ) {
/if ( ${Me.Pet.Distance}>MAX_PET_RANGE_BEFORE_SUMMON ) {
/echo Summoning pet. Its range is ${Me.Pet.Distance}
/call Cast "Summon Companion" gem7
/delay 1s
/varset repeat True
/return
}
}
|KeepUpBuffsOnPet
/varset tmp ${Me.PetBuff["PET_SPELL1"]}
/if ( ${tmp.Equal["NULL"]} ) {
/target ${Me.Pet.Name}
/call Cast "PET_SPELL1" gemPET_GEM1
/varset repeat True
/return
}
/varset tmp ${Me.PetBuff["PET_SPELL2"]}
/if ( ${tmp.Equal["NULL"]} ) {
/target ${Me.Pet.Name}
/call Cast "PET_SPELL2" gemPET_GEM2
/varset repeat True
/return
}
/varset tmp ${Me.PetBuff["PET_SPELL3"]}
/if ( ${tmp.Equal["NULL"]} ) {
/target ${Me.Pet.Name}
/call Cast "PET_SPELL3" gemPET_GEM3
/varset repeat True
/return
}
/varset tmp ${Me.PetBuff["PET_SPELL4"]}
/if ( ${tmp.Equal["NULL"]} ) {
/target ${Me.Pet.Name}
/call Cast "PET_SPELL4" gemPET_GEM4
/varset repeat True
/return
}
/if ( ${Me.Pet.PctHPs}<HEAL_PET_BELOW_PCT ) {
/keypress ESC
/keypress F1
/keypress F1
/call Cast "HEAL_PET_SPELL" gemHEAL_PET_GEM
/if ( !${Me.Sitting} ) /sit
/varset repeat True
/return
}
}
/return
|--------------------------------------------------------------------------------
|SUB: MaintainSelf
|--------------------------------------------------------------------------------
Sub MaintainSelf
|KeepUpBuffsOnMe
/varset tmp "SELF_SPELL1"
/if ( ${tmp.Length}>0 ) {
/if ( !${Me.Buff["SELF_SPELL1"].ID} ) {
/target ${Me.Name}
/call Cast "SELF_SPELL1" gemSELF_GEM1
/varset repeat True
/return
}
}
/varset tmp "SELF_SPELL2"
/if ( ${tmp.Length}>0 ) {
/if ( !${Me.Buff["SELF_SPELL2"].ID} ) {
/target ${Me.Name}
/call Cast "SELF_SPELL2" gemSELF_GEM2
/varset repeat True
/return
}
}
/varset tmp "SELF_SPELL3"
/if ( ${tmp.Length}>0 ) {
/if ( !${Me.Buff["SELF_SPELL3"].ID} ) {
/target ${Me.Name}
/call Cast "SELF_SPELL3" gemSELF_GEM3
/varset repeat True
/return
}
}
/varset tmp "SELF_SPELL4"
/if ( ${tmp.Length}>0 ) {
/if ( !${Me.Buff["SELF_SPELL4"].ID} ) {
/target ${Me.Name}
/call Cast "SELF_SPELL4" gemSELF_GEM4
/varset repeat True
/return
}
}
/varset tmp "SELF_SPELL5"
/if ( ${tmp.Length}>0 ) {
/if ( !${Me.Buff["SELF_SPELL5"].ID} ) {
/target ${Me.Name}
/call Cast "SELF_SPELL5" gemSELF_GEM5
/varset repeat True
/return
}
}
/varset tmp "SELF_SPELL6"
/if ( ${tmp.Length}>0 ) {
/if ( !${Me.Buff["SELF_SPELL6"].ID} ) {
/target ${Me.Name}
/call Cast "SELF_SPELL6" gemSELF_GEM6
/varset repeat True
/return
}
}
/return
|--------------------------------------------------------------------------------
|SUB: MoveForward
|--------------------------------------------------------------------------------
Sub MoveForward
/keypress forward hold
/varset forwarddown True
/return
Sub MoveForwardStop
/if ( ${forwarddown} ) {
/keypress forward
/varset forwarddown False
}
/return
|--------------------------------------------------------------------------------
|SUB: MoveLeft
|--------------------------------------------------------------------------------
Sub MoveLeft
/keypress left hold
/varset leftdown True
/return
Sub MoveLeftStop
/if ( ${leftdown} ) {
/keypress left
/varset leftdown False
}
/return
|--------------------------------------------------------------------------------
|SUB: MoveRight
|--------------------------------------------------------------------------------
Sub MoveRight
/keypress right hold
/varset rightdown True
/return
Sub MoveRightStop
/if ( ${rightdown} ) {
/keypress right
/varset rightdown False
}
/return
|--------------------------------------------------------------------------------
|SUB: FaceTarget
|--------------------------------------------------------------------------------
Sub FaceTarget
/call FacePosition ${Target.X} ${Target.Y}
/return
|--------------------------------------------------------------------------------
|SUB: FacePosition
|--------------------------------------------------------------------------------
Sub FacePosition(float X, float Y)
|Face towards target - At a 'slack' degrees slack - more natural
/declare currdeg int local
/varset currdeg ${Me.Heading.DegreesCCW}
/declare targdeg string local
/varset targdeg ${Heading[${Y},${X}].DegreesCCW}
/if ( ${currdeg}<${targdeg} ) {
/if ( ${Math.Abs[${currdeg}-${targdeg}]} > ${theslack} ) {
/if (${Math.Calc[${targdeg}-${currdeg}]} < 180 ) {
/call MoveLeft
/delay ${Math.Rand[2]}
} else {
/call MoveRight
/delay ${Math.Rand[2]}
}
} else {
/call MoveLeftStop
/call MoveRightStop
}
} else {
/if ( ${Math.Abs[${targdeg}-${currdeg}]} > ${theslack} ) {
/if (${Math.Calc[${currdeg}-${targdeg}]} < 180 ) {
/call MoveRight
/delay ${Math.Rand[2]}
} else {
/call MoveLeft
/varset leftdown True
/delay ${Math.Rand[2]}
}
} else {
/call MoveLeftStop
/call MoveRightStop
}
}
/return
|--------------------------------------------------------------------------------
|SUB: StuckFixTarget
|--------------------------------------------------------------------------------
Sub StuckFixTarget
/declare targpct int local
/varset targpct ${Target.PctHPs}
/if ( ${Target.ID} ) {
/if ( ${targpct}==100 ) { |To prevent movement during fight when one stands still
/call StuckFix
}
}
/return
|--------------------------------------------------------------------------------
|SUB: StuckFix
|--------------------------------------------------------------------------------
Sub StuckFix
/declare moved float local
/declare rnd int local
|Trying to get out of a spot where we are stuck
/varset moved ${Math.Distance[${oldposy},${oldposx},0:${Me.Y},${Me.X},0]}
/varset rnd ${Math.Rand[1500]}
/if ( ${moved}<100 ) {
/if ( ${rnd}<250 ) {
/if ( ${moved}<0.10 ) {
/echo Back off1
/keypress back hold
/delay ${Math.Rand[15]}
/call MoveRight
/delay ${Math.Rand[15]}
/keypress back
/call MoveRightStop
/varset theslack 95
}
} else /if ( ${rnd}<500 ) {
/if ( ${moved}==0 ) {
/echo Back off2
/keypress back hold
/delay ${Math.Rand[15]}
/call MoveLeft
/delay ${Math.Rand[15]}
/keypress back
/call MoveLeftStop
/varset theslack 95
}
} else {
|/echo Dont back off
|There is a chance to do nothing.
}
}
/varset oldposx ${Me.X}
/varset oldposy ${Me.Y}
/return
|--------------------------------------------------------------------------------
|SUB: CheckGM
|--------------------------------------------------------------------------------
Sub CheckGM
/if (${Spawn[gm].ID}) {
/echo "QUITTING"
/endmacro
}
/return
|--------------------------------------------------------------------------------
|SUB: RunToSpot
|--------------------------------------------------------------------------------
Sub RunToSpotTarget
/varset tmp ${Target}
/if ( ${tmp.Equal["NULL"]} ) /return
/call RunToSpot ${Target.X} ${Target.Y}
/return
Sub StepToSpot(float X, float Y)
/declare TargDist float local |Distance to Target
|:RunLoop
|bytt til RANGE istedet for antall sekunder bak
/call FacePosition ${X} ${Y}
/varset TargDist ${Math.Distance[${Y},${X},0:${Me.Y},${Me.X},0]}
/if ( ${TargDist}<20 ) /return
/call MoveForward
/delay 2
/echo Distance to target ${TargDist}
/if (${forwarddown}) {
/call StuckFix
}
/if ( ${TargDist}<5 ) {
|/echo We are HOOOOOOOOME!
/call MoveForwardStop
/return
}
| /goto :RunLoop
/return
Sub RunToSpot(float X, float Y)
/declare TargDist float local |Distance to Target
:RunLoop
|bytt til RANGE istedet for antall sekunder bak
/call FacePosition ${X} ${Y}
/varset TargDist ${Math.Distance[${Y},${X},0:${Me.Y},${Me.X},0]}
/if ( ${TargDist}<20 ) /return
/call MoveForward
/delay 2
/echo Distance to spot ${TargDist}
/if (${forwarddown}) {
/call StuckFix
}
/if ( ${TargDist}<5 ) {
|/echo We are HOOOOOOOOME!
/call MoveForwardStop
/return
}
/goto :RunLoop
/return
|--------------------------------------------------------------------------------
|SUB: Looting
|--------------------------------------------------------------------------------
Sub LootMob
/declare LootSlot int inner 0
/declare LootCheck int inner 0
/declare LootTotal int inner 0
/call FaceTarget
/delay 1
/keypress forward
/keypress back
/fastdrop on
/lootn never
/delay 1s
/loot
/delay 1s
/if (!${Corpse.Items}) {
/echo NO LOOT! Cheap Bastard!
/keypress ESC
/keypress ESC
/return
}
/if (${Bool[LOOT_ITEMS]}) {
/varset LootTotal ${Corpse.Items}
/for LootSlot 1 to ${LootTotal}
/itemnotify loot${LootSlot} leftmouseup
/delay 1s
|/if (${RV_LootAllItems}) {
/echo Keeping a ${Cursor.Name}... WOOT!
/autoinventory
/delay 1s
|} else {
| /for LootCheck 1 to ${RV_LootArray.Size}
| /if (${Cursor.Name.Find[${RV_LootArray[${LootCheck}]}]}) {
| /echo Keeping a ${Cursor.Name}... WOOT!
| /varcalc RV_LootStats[${LootCheck}] ${RV_LootStats[${LootCheck}]}+1
| /autoinventory
| /delay 1s
| }
| /next LootCheck
|}
|/if (${Cursor.ID}) {
| /echo Destroying a ${Cursor.Name}...
| /destroy
| /delay 1s
|}
/next LootSlot
}
/keypress ESC
/keypress ESC
/return
Sub Event_LostTarget
/call StopAttack
/return
Sub Event_NoOverWrite
/return
Sub Event_SlainTarget
/return
Sub Event_SelfSlain
/call MoveForwardStop
/call MoveLeftStop
/call MoveRightStop
/endmacro
/return
Sub Event_Encumbered
/call DestroyCopper
/delay 1
/call DestroySilver
/return
Excellent commenting and structure 
