|---Add at the end of General
/call LoadIni General MemKissHelp string "Usage: "MemKissSpellsOn=1" mems max # of spells from ini if not memorized"
/call LoadIni General MemKissSpellsOn int 1
/call LoadIni General MKSnotouchHelp string "Usage: "MKSnotouchGems=10 11 12" | =NULL if all avail ;tells MemKissSpells to not touch certain Spells in gem # e.g. 10 11 and 12"
/call LoadIni General MKSnotouchGems string NULL
|---Add just before Mainloop
/call MemKissSpells
|---Add these 2 subs at the end of macro
|-----------------------------------------------------------------------------
| SUB: MemKissSpells to get needed Spells loaded
| ----------------------------------------------------------------------------
Sub MemKissSpells
/if (${Debug}) /echo MemKissSpells: Enter Me.Class - ${Me.Class} MiscGem set to - ${Me.Gem[${MiscGem}]}
/echo Memming max # of spells as setup in ini, NoTouchGems and Bardtwistgems will remain
/if (!${MemKissSpellsOn}) /return
|Wanted to safe old spellset but it does not work anymore /safespellset NormalSet
|Getting rid of the Spell in MiscGem until better logic found to handle it
/if (${Me.Gem[${MiscGem}].ID}) {
/varcalc MiscGem ${MiscGem}-1
/delay 2
/nomodkey /notify CastSpellWnd CSPW_Spell${MiscGem} rightmouseup
/delay 10 ${Me.Gem[${MiscGem}].ID}<1
/varcalc MiscGem ${MiscGem}+1
}
/declare i int local
/declare j int local
/declare k int local
/declare l int local
/declare m int local
|Checking for Slots avail
/declare AvSlots int local 8
/if (${Me.AltAbility[Mnemonic Retention]}>=21) {
/varset AvSlots 12
} else /if (${Me.AltAbility[Mnemonic Retention]}>9) {
/varset AvSlots 11
} else /if (${Me.AltAbility[Mnemonic Retention]}>3) {
/varset AvSlots 10
} else /if (${Me.AltAbility[Mnemonic Retention]}>0) /varset AvSlots 9
|Sorting Gems not to touch, Bardtwists included
/declare Notouchgems[${AvSlots}] string local AVAILABLE
/varset Notouchgems[${MiscGem}] ${MiscGem}
/declare NTGtempstring string local NULL
/varset NTGtempstring ${MKSnotouchGems} ${TwistWhat} ${MeleeTwistWhat}
/declare TempArg string local NULL
|/echo NTGtempstring ${NTGtempstring}
/varset i 1
/for j 1 to 40
/varset TempArg ${NTGtempstring.Arg[${j}, ]}
|/echo TempArg ${j} ${TempArg}
/if (${TempArg.Equal[NULL]}) {
/varcalc i ${i}+1
/if (${i}>=4) /goto :notouchset
/goto :skipnull1
}
/for k 1 to ${Notouchgems.Size}
/if (${NTGtempstring.Arg[${j}, ].Equal[${k}]}) /varset Notouchgems[${k}] ${TempArg}
|/echo ${NTGtempstring.Arg[${j}, ].Equal[${k}]} k ${k} Equal NTGtempstring.Arg[${j}, ] ${NTGtempstring.Arg[${j}, ]}
/next k
:skipnull1
/next j
:notouchset
|Gathering spells possibly to be memmed
/declare ArrayNames[7] string local
/varset ArrayNames[1] Aggro
/varset ArrayNames[2] Heals
/varset ArrayNames[3] DPS
/varset ArrayNames[4] AE
/varset ArrayNames[5] Cures
/varset ArrayNames[6] Buffs
/varset ArrayNames[7] Burn
/declare Spellnmbrs int local 5
/for i 1 to ${ArrayNames.Size}
/varcalc Spellnmbrs ${Spellnmbrs}+${${ArrayNames[${i}]}.Size}
/if (${Debug}) {
/echo ${Spellnmbrs}+${${ArrayNames[${i}]}.Size}
/delay 5
}
/next i
/declare SpellsToConsider[${Spellnmbrs}] string local NULL
/declare CleanSpellName string local NULL
/varset i 1
/if (${Bool[${MezSpell}]}) {
/varset CleanSpellName ${MezSpell.Arg[1,|]}
/if (${Me.AltAbility[${CleanSpellName}]}<1 && !${Me.AltAbilityReady[${CleanSpellName}]} && ${Me.Book[${CleanSpellName}]}) {
/if (${Me.Gem[${CleanSpellName}]}) {
/varset Notouchgems[${Me.Gem[${CleanSpellName}]}] ${Me.Gem[${CleanSpellName}]}
} else {
/varset SpellsToConsider[${i}] ${CleanSpellName}
/varcalc i ${i}+1
}
}
}
/if (${Bool[${MezAESpell}]}) {
/varset CleanSpellName ${MezAESpell.Arg[1,|]}
/if (${Me.AltAbility[${CleanSpellName}]}<1 && !${Me.AltAbilityReady[${CleanSpellName}]} && ${Me.Book[${CleanSpellName}]}) {
/if (${Me.Gem[${CleanSpellName}]}) {
/varset Notouchgems[${Me.Gem[${CleanSpellName}]}] ${Me.Gem[${CleanSpellName}]}
} else {
/varset SpellsToConsider[${i}] ${CleanSpellName}
/varcalc i ${i}+1
}
}
}
/if (${Bool[${AutoRezWith}]}) {
/varset CleanSpellName ${AutoRezWith.Arg[1,|]}
/if (${Me.AltAbility[${CleanSpellName}]}<1 && !${Me.AltAbilityReady[${CleanSpellName}]} && ${Me.Book[${CleanSpellName}]}) {
/if (${Me.Gem[${CleanSpellName}]}) {
/varset Notouchgems[${Me.Gem[${CleanSpellName}]}] ${Me.Gem[${CleanSpellName}]}
} else {
/varset SpellsToConsider[${i}] ${CleanSpellName}
/varcalc i ${i}+1
}
}
}
/if (${Bool[${PullWith}]}) {
/varset CleanSpellName ${PullWith.Arg[1,|]}
/if (${Me.AltAbility[${CleanSpellName}]}<1 && !${Me.AltAbilityReady[${CleanSpellName}]} && ${Me.Book[${CleanSpellName}]}) {
/if (${Me.Gem[${CleanSpellName}]}) {
/varset Notouchgems[${Me.Gem[${CleanSpellName}]}] ${Me.Gem[${CleanSpellName}]}
} else {
/varset SpellsToConsider[${i}] ${CleanSpellName}
/varcalc i ${i}+1
}
}
}
/if (${Bool[${GoMSpell}]}) {
/varset CleanSpellName ${GoMSpell.Arg[1,|]}
/if (${Me.AltAbility[${CleanSpellName}]}<1 && !${Me.AltAbilityReady[${CleanSpellName}]} && ${Me.Book[${CleanSpellName}]}) {
/if (${Me.Gem[${CleanSpellName}]}) {
/varset Notouchgems[${Me.Gem[${CleanSpellName}]}] ${Me.Gem[${CleanSpellName}]}
} else {
/varset SpellsToConsider[${i}] ${CleanSpellName}
/varcalc i ${i}+1
}
}
}
/for j 1 to ${ArrayNames.Size}
/for k 1 to ${${ArrayNames[${j}]}.Size}
/varset CleanSpellName ${ArrayNames[${j}]}[${k}]
/if (${Debug}) {
/echo ${ArrayNames[${j}]} k ${k} ${${ArrayNames[${j}]}[${k}]} j ${j}
/delay 2
}
/if (${Bool[${${ArrayNames[${j}]}[${k}]}]}) {
/varset CleanSpellName ${${ArrayNames[${j}]}[${k}]}
/varset CleanSpellName ${CleanSpellName.Arg[1,|]}
/varset TempArg ${CleanSpellName.Arg[2,|]}
/if (${Debug}) /echo ${CleanSpellName} j ${j} k ${k}
/if (${Me.AltAbility[${CleanSpellName}]}<1 && !${Me.AltAbilityReady[${CleanSpellName}]} && ${Me.Book[${CleanSpellName}]}) {
/if (${Me.Gem[${CleanSpellName}]}) {
/varset Notouchgems[${Me.Gem[${CleanSpellName}]}] ${Me.Gem[${CleanSpellName}]}
} else {
/for l 1 to ${Spellnmbrs}
/if (!${Bool[${SpellsToConsider[${l}]}]}) /goto :skipnull
/if (${SpellsToConsider[${l}].Equal[${CleanSpellName}]}) /goto :skipdbl
/next l
:skipnull
/varset SpellsToConsider[${i}] ${CleanSpellName}
/varcalc i ${i}+1
:skipdbl
}
}
}
/next k
/next j
|Sorting the spells considered for memorization in order highest to lowest RecastTime, hopefully spells with fast recast will be covered by MiscGem later
|Also memming spells right away in order
/varset i 1
/declare SpellsToMem[${AvSlots}] string local NULL
/for j 1 to ${SpellsToConsider.Size}
/if (${Bool[${SpellsToConsider[${j}]}]}) /varcalc i ${i}+1
/next j
/varset m 10000
/varset l 0
/for k 1 to ${AvSlots}
/for j 1 to ${i}
|/echo ${m}>${Spell[${SpellsToConsider[${j}]}].RecastTime}>${l}
/if (${m}>${Spell[${SpellsToConsider[${j}]}].RecastTime}>${l}) {
/varset SpellsToMem[${k}] ${SpellsToConsider[${j}]}
/varset l ${Spell[${SpellsToMem[${k}]}].RecastTime}
}
/next j
/if (${Me.Book[${SpellsToMem[${k}]}]}) /varset m ${Spell[${SpellsToMem[${k}]}].RecastTime}
/varset l 0
|/if (${Me.Book[${SpellsToMem[${k}]}]}) /goto :spellmemfinished
|/echo i ${i} j ${j} AvSlots ${AvSlots} SpellsToMem[${k}] ${SpellsToMem[${k}]}
/for j 1 to ${AvSlots}
|/if (${Notouchgems[${j}].Equal[AVAILABLE]}) /echo Notouchgems[${j}].Equal[AVAILABLE] ${Notouchgems[${j}].Equal[AVAILABLE]} && Me.Book[${SpellsToMem[${k}]}] ${Me.Book[${SpellsToMem[${k}]}]}
/if (${Notouchgems[${j}].Equal[AVAILABLE]} && ${Me.Book[${SpellsToMem[${k}]}]}) {
|/echo memming j ${j} spell "${SpellsToMem[${k}]}"
/call MemSlot ${j} "${SpellsToMem[${k}]}"
|/echo Notouchgems[${j}] ${Notouchgems[${j}]} Me.Gem[${SpellsToMem[${k}]}] ${Me.Gem[${SpellsToMem[${k}]}]}
/if (${Bool[${Me.Gem[${SpellsToMem[${k}]}]}]}) {
/varset Notouchgems[${j}] ${Me.Gem[${SpellsToMem[${k}]}]}
/goto :spellmemmed
}
}
/next j
:spellmemmed
/next k
:spellmemfinished
/if (${Debug}) {
/echo MemKissSpells: Leave
|/for i 1 to ${AvSlots}
| /echo Notouchgems[${i}] ${Notouchgems[${i}]}
| /if (${Bool[${SpellsToConsider[${i}]}]}) /echo SpellsToConsider[${i}] ${SpellsToConsider[${i}]}
| /if (${Bool[${SpellsToMem[${i}]}]}) /echo SpellsToMem[${i}] ${SpellsToMem[${i}]}
| /delay 1
|/next i
}
/return
Sub MemSlot(int MemSlot,string ToMemSpell)
/if (${Debug}) /echo MemSlot: Enter, Trying to mem spell ${ToMemSpell}.
/if (${Bool[${Me.Gem[${ToMemSpell}]}]}) {
/nomodkey /notify CastSpellWnd CSPW_Spell${Math.Calc[${MemSlot}-1]} rightmouseup
/delay 10 !${Bool[${Me.Gem[${MemSlot}]}]}
}
/if (${Bool[${Me.Standing}]} && !${Me.Mount.ID}) {
/sit
/delay 15 !${Me.Standing}
}
:memretry
/delay 5
/if (${Bool[${Plugin[mq2instantmem]}]}) {
/memspell ${MemSlot} "${ToMemSpell}"
} else {
/memorize "${ToMemSpell}" ${MemSlot}
}
/delay 30 ${Me.Gem[${MemSlot}].Name.Find[${ToMemSpell}]}
/if (${Me.Gem[${MemSlot}].Name.Find[${ToMemSpell}]}<1) /if (!${Bool[${twice}]}) {
/delay 15
/declare twice bool local TRUE
/goto :memretry
}
/if (${Debug}) /echo MemSlot: Leave
/return
