p3_buffs.inc

SUB p3_buffs_init {
	/call p3RegisterCommand STOP buffsStop 60

	/declare updateNetnoteTimer timer outer 0
	/declare buffCheckTimer timer outer 30
	/declare buffsEnabled bool outer true
	/declare emptySpawn spawn outer

	/call processArrayTargets iniBuffs

	/declare canDoExtendedStackCheck bool outer TRUE

	/if (${Plugin[MQ2Dannet].Name.Length}==NULL) {
		/varset canDoExtendedStackCheck FALSE
	}
	
	/netnote

	/RETURN
}

SUB buffsMaintenance() {
	/if (${buffsEnabled}==FALSE) /return

	/call updateNetnoteBuffDurations

	/if (${holdFunctionsAfterZoning}==TRUE && ${recentlyZoned}==TRUE) /return

	/if (${Me.Invis}==TRUE) /return
	/if (${Stick.Active}==TRUE && ${combatStateTimer}==0) /return
	/if (${Navigation.Active}==TRUE) /return
	/if (${Me.Casting.ID} !=0 && ${Twist.Twisting}==FALSE) /return
	|/if ((${Me.Moving} || ${movingTimer}>0) && ${canCastWhileMoving}==FALSE) /return

	/call checkBuffs
	/RETURN
}

SUB buffsStop() {
	/varset buffCheckTimer 30
	/RETURN
}

SUB updateNetnoteBuffDurations {
	/if (${updateNetnoteTimer}>0) /return
	/varset updateNetnoteTimer 5

	/declare i int local
	/declare buffDurations string local

	/for i 1 to 30
		/if (${Me.Buff[${i}].ID}==NULL) /continue
		/varset buffDurations ${buffDurations};${Me.Buff[${i}].Spell.ID}_${Me.Buff[${i}].Duration.TotalSeconds}
	/next i

	/for i 1 to 30
		/if (${Me.Song[${i}].ID}==NULL) /continue
		/varset buffDurations ${buffDurations};${Me.Song[${i}].Spell.ID}_${Me.Song[${i}].Duration.TotalSeconds}
	/next i

	/netnote ${buffDurations}

	/RETURN
}

SUB checkBuffs {
	/if (${buffCheckTimer}>0) /return
	/varset buffCheckTimer 15

	/declare i int local 
	/declare targetNames list local 
	/declare targetName string local
	/declare buffCastName string local
	/declare buffSpell spell local
	/declare buffSpellID int local
	/declare netbotName string local
	/declare checkSpellID int local 
	/declare buffSpawn spawn local
	/declare noholdTimerName string local
	/declare buffSpellRange int local
	/declare cancelCheck string local
	/declare note string local 
	/declare cancelConditions string local

	/declare j int local
	/declare k int local

	/for i 1 to ${iniBuffs.Size}
		/invoke ${targetNames.Clear}
		/if (${iniBuffs[${i},${bTargets}].Length}==0) /continue

		/if (${iniBuffs[${i},1].Equal[-]}) /break
		/if (${iniBuffs[${i},${bEnabled}].Equal[NO]}) /continue


		/if (${iniBuffs[${i},${bPreCommand}].NotEqual[-]}) {
			/echo performingcmd: ${iniBuffs[${i},${bPreCommand}]}
			/call p3command "${iniBuffs[${i},${bPreCommand}]}"
			/delay 5
		}

		/if ( (${Me.Moving} || ${movingTimer}>0) && ${iniBuffs[${i},${bCastableMoving}].Equal[-]}) {
			/continue
		}

		/if (${combatStateTimer}>0) {
			/if (${iniBuffs[${i},${bCastableDuringAssist}].Equal[-]} && ${iniBuffs[${i},${bCastOnlyDuringAssist}].Equal[-]}) {
				/if (${combatStateTimer}>0) /continue
			}
		}

		/if (${iniBuffs[${i},${bGiftOfMana}].NotEqual[-]}) {
			/if (${Me.Song[Gift Of Mana].ID}==NULL) /continue
		}

		/if (${iniBuffs[${i},${bCastableOnlyResting}].NotEqual[-]}) {
			/if (${combatStateTimer}>0) /continue
		}

		/if (${iniBuffs[${i},${bCastOnlyDuringAssist}].NotEqual[-]}) {
			/if (${combatStateTimer}==0) /continue
		}

		/if (${iniBuffs[${i},${bNotIfAssistTag}].NotEqual[-]}) {
			/if (${tempCombatTags.Count}>0 || ${assistTags.Count}>0) {
				/call validateAssistTags ${iniBuffs[${i},${bNotIfAssistTag}]} TRUE
				/if (${Macro.Return}==TRUE) /continue
			}
		}

		/if (${iniBuffs[${i},${bRequireAssistTag}].NotEqual[-]}) {
			/if (${tempCombatTags.Count}==0 && ${assistTags.Count}==0) /continue
			/call validateAssistTags ${iniBuffs[${i},${bRequireAssistTag}]} TRUE
			/if (${Macro.Return}==FALSE) /continue
		}

		/if (${iniBuffs[${i},${bMyName}].NotEqual[-]}) {
			/if (${Me.CleanName.Upper.NotEqual[${iniBuffs[${i},${bMyName}].Upper}]}) /continue
		}
		/if (${iniBuffs[${i},${bNotIfMounted}].NotEqual[-]}) {
			/if (${Me.Mount.ID}!=NULL) /continue
		}
		/if (${iniBuffs[${i},${bRequireCastIdle}].NotEqual[-]}) {
			/if (${idleCastingTimer}>0) /continue
		}
		/if (${iniBuffs[${i},${bRequireAssistTarget}].NotEqual[-]}) {
			/if (${assistSpawnID}==0) /continue
		}
		/if (${iniBuffs[${i},${bSelfOverHP}].NotEqual[-]}) {
			/if (${Me.PctHPs} < ${iniBuffs[${i},${bSelfOverHP}]}) /continue
		}
		/if (${iniBuffs[${i},${bSelfUnderHP}].NotEqual[-]}) {
			/if (${Me.PctHPs} >= ${iniBuffs[${i},${bSelfUnderHP}]}) /continue
		}
		/if (${iniBuffs[${i},${bSelfOverMana}].NotEqual[-]}) {
			/if (${Me.PctMana} < ${iniBuffs[${i},${bSelfOverMana}]}) /continue
		}
		/if (${iniBuffs[${i},${bSelfUnderMana}].NotEqual[-]}) {
			/if (${Me.PctMana} >= ${iniBuffs[${i},${bSelfUnderMana}]}) /continue
		}
		/if (${iniBuffs[${i},${bSelfUnderEnd}].NotEqual[-]}) {
			/if (${Me.PctEndurance} >= ${iniBuffs[${i},${bSelfUnderEnd}]} ) /continue
		}
		/if (${iniBuffs[${i},${bSelfOverEnd}].NotEqual[-]}) {
			/if (${Me.PctEndurance} < ${iniBuffs[${i},${bSelfUnderEnd}]} ) /continue
		}
		/if (${iniBuffs[${i},${bRequireMobsInProximity}].NotEqual[-]}) {
			/if (${SpawnCount[npc loc ${Me.X} ${Me.Y} radius 45]} < ${iniBuffs[${i},${bRequireMobsInProximity}]}) /continue
		}
		/if (${iniBuffs[${i},${bRequireUW}].NotEqual[-]}) {
			/if (${Me.FeetWet}==FALSE) /continue
		}

		/if (${iniBuffs[${i},${bRequireDiscNotReady}].NotEqual[-]}) {
			/if (${Me.CombatAbilityReady[${iniBuffs[${i},${bRequireDiscNotReady}]}]}==TRUE) /continue
		}


		| OBTAIN BUFF SPELL DETAIL
		/varset buffCastName ${iniBuffs[${i},${bName}]}

		/call getSpellFromCastRequest "${buffCastName}"
		/if (${Macro.Return.Equal[UNKNOWN]}) {
			/bc Warning: checkBuffs() getSpellFromCastRequest() returned UNKNOWN for ${iniBuffs[${i},${bName}]}. Not sure what to do. Disabling entry.
			/varset iniBuffs[${i},${bEnabled}] NO
			/RETURN
		} else {
			/vardata buffSpell ${Macro.Return}
		}

		/varset buffSpellID ${buffSpell.ID}

		/if (${iniBuffs[${i},${bForceSpellID}].NotEqual[-]}) {
			/varset buffSpellID ${iniBuffs[${i},${bForceSpellID}]}
		}

		/if (${isLockoutExpired[bufflockout_${buffSpellID}]}==FALSE) /CONTINUE


		/if (${iniBuffs[${i},${bIgnoreTargetType}].Equal[-]}) {
			/if (${buffSpell.TargetType.Equal[Pet]} || ${iniBuffs[${i},${bTargetType}].Upper.Equal[PET]} ) {
				/if (${Me.Pet.ID}==NULL) /continue
				/if (${Me.PetBuff[${buffSpell.Name}]}!=NULL) /continue
				/goto :skipNetBots
			} else /if (${buffSpell.TargetType.Equal[Self]}) {
				/invoke ${targetNames.Append[${Me.CleanName}]}
			} else {
				/invoke ${targetNames.Append[${iniBuffs[${i},${bTargets}]}]}
			}
		} else {
			/invoke ${targetNames.Append[${iniBuffs[${i},${bTargets}]}]}
		}

		/varset buffSpellRange ${buffSpell.Range}
		/if (${buffSpell.TargetType.Equal[Group v1]}) /varset buffSpellRange ${buffSpell.AERange}
		/if (${buffSpell.TargetType.Equal[Group v2]}) /varset buffSpellRange ${buffSpell.AERange}
		/if (${buffSpell.TargetType.Equal[Single]}) /varset buffSpellRange ${buffSpell.MyRange}
		/if (${buffSpell.TargetType.Equal[Self]} && ${iniBuffs[${i},${bIgnoreTargetType}].NotEqual[-]}) /varset buffSpellRange 50

		| TARGETNAMES ARE ALL POSSIBLE TARGETS REGARDLESS OF WHETHER OR NOT THEY HAVE THE BUFF.
		| THIS LOOP REMOVES PEOPLE WHO DONT QUALIFY FOR A CAST, TYPICALLY BECAUSE THEY HAVE THE
		| BUFF. BUFF ENTRIES WITH REBUFFSECONDS MAY KEEP PEOPLE IN THE LIST WHO ALREADY HAVE
		| THE BUFF IF THE TIME ON THE BUFF IS LOW ENOUGH.



		/for j ${Math.Calc[${targetNames.Count}-1]} downto 0
			/varset targetName ${targetNames.Item[${j}]}
			/if (${targetName.Length}==0) /continue

			/if (${Spawn[${targetName}].ID}==NULL) {
				/invoke ${targetNames.Remove[${targetName}]}
				/continue
			}

			/if (${NetBots[${targetName}].State.Equal[DEAD]}) /continue


			|/echo ${targetName} ${iniBuffs[1,1]}

			| HAVE THE BUFF?
			/if (${Select[${buffSpellID},${NetBots[${targetName}].Buff}]}>0 || ${Select[${buffSpellID},${NetBots[${targetName}].ShortBuff}]}>0) {

				| REBUFF SECONDS DONT MATER? REMOVE THIS PERSON FROM BUFF CANDIDATES
				/if (${iniBuffs[${i},${bRebuffSeconds}].Equal[-]}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}

				| REBUFFSECONDS ENTRY PRESENT, EXAMINE NETNOTE

				| EMPTY NETNOTE.  REMOVE FROM CANDIDATES SINCE THEY HAVE THE BUFF
				/if (${NetBots[${targetName}].Note.Length}==0) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}

				| NO NETNOTE FOR SPELL FOUND - ASSUME PERSON NEEDS BUFF - LEAVE THEM IN LIST

				/if (${NetBots[${targetName}].Note.Find[;${buffSpellID}_]}==NULL) /continue
				
				| NETNOTE FOR SPELLID EXISTS, CHECK
				/varset note ${NetBots[${targetName}].Note}
				/varset note ${note.Right[ -${note.Find[;${buffSpellID}_]} ]}

				| REMAINING BUFF TIME IS SUFFICIENT, REMOVE PLAYER FROM BUFF CANDIDATES
				/if (${note.Token[1,;].Token[2,_]} > ${iniBuffs[${i},${bRebuffSeconds}]}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}

				| REMAINING TIME IS NOT SUFFICIENT, LEAVE THEM IN THE LIST BY DOING NOTHING
			}

			|/if (${Select[${buffSpellID},${NetBots[${targetName}].ShortBuff}]}>0) {
			|	/invoke ${targetNames.Remove[${targetName}]}
			|	/continue
			|}

			/if (${NetBots[${targetName}].InZone}==FALSE) { 
				/invoke ${targetNames.Remove[${targetName}]}
				/continue
			}

			/if (${iniBuffs[${i},${bExtendedStackCheck}].NotEqual[-]} && ${canDoExtendedStackCheck}==TRUE) {
				/dquery ${targetName} -q "Spell[${buffSpell}].Stacks" 
				/if (${DanNet.Q}==FALSE) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bRequireGroupInRange}].NotEqual[-]}) {
				/if (${targetName.NotEqual[${Me.CleanName}]} && ${Group.Member[${targetName}].Index}==NULL) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}

				/if (${Spawn[pc ${targetName}].Distance3D} > ${buffSpellRange}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bTargetUnderHP}].NotEqual[-]}) {
				/if (${NetBots[${targetName}].PctHPs} > ${iniBuffs[${i},${bTargetUnderHP}]}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bTargetUnderMana}].NotEqual[-]}) {
				/if (${NetBots[${targetName}].PctMana} > ${iniBuffs[${i},${bTargetUnderMana}]}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bTargetOverHP}].NotEqual[-]}) {
				/if (${NetBots[${targetName}].PctHPs} <= ${iniBuffs[${i},${bTargetOverHP}]}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bNotIfShortBuff}].NotEqual[-]}) {
				/varset checkSpellID ${Spell[${iniBuffs[${i},${bNotIfShortBuff}]}].ID}
				/if (${Select[${checkSpellID},${NetBots[${targetName}].ShortBuff}]}>0) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bNotIfLongBuff}].NotEqual[-]}) {
				/varset checkSpellID ${Spell[${iniBuffs[${i},${bNotIfLongBuff}]}].ID}
				/if (${Select[${checkSpellID},${NetBots[${targetName}].Buff}]}>0) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bTargetOverLevel}].NotEqual[-]}) {
				/if (${NetBots[${targetName}].Level} < ${iniBuffs[${i},${bTargetOverLevel}]}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${iniBuffs[${i},${bTargetUnderLevel}].NotEqual[-]}) {
				/if (${NetBots[${targetName}].Level} >= ${iniBuffs[${i},${bTargetUnderLevel}]}) {
					/invoke ${targetNames.Remove[${targetName}]}
					/continue
				}
			}

			/if (${Spawn[pc ${targetName}].Distance3D} > ${buffSpellRange}) {
				/invoke ${targetNames.Remove[${targetName}]}
				/continue
			}
		/next j


		/if (${targetNames.Count}==0) {
			/if (${iniBuffs[${i},${bRevertToBandolier}].NotEqual[-]}) {
				/if (${bandolierProfileIsActive[${iniBuffs[${i},${bRevertToBandolier}]}]}==FALSE) {
					/band activate ${iniBuffs[${i},${bRevertToBandolier}]}
				}
			}
			/continue
		}

		/if (${iniBuffs[${i},${bActivateBandolier}].NotEqual[-]}) {
			/if (${bandolierProfileIsActive[${iniBuffs[${i},${bActivateBandolier}]}]}==FALSE) {
				/band activate ${iniBuffs[${i},${bActivateBandolier}]}
			}
		}

		/if (${iniBuffs[${i},${bRequireGroupInRange}].NotEqual[-]}) {
			/for k 1 to ${Group.Members}
				/if (${Spawn[group =${Group.Member[${k}]}].ID}==NULL) /continue
				/if (${Spawn[group =${k}].Distance3D} > ${buffSpellRange}) /continue
			/next k
		}

		:skipNetBots

		/vardata buffSpawn emptySpawn

		/if (${iniBuffs[${i},${bTargetType}].Upper.Equal[PET]}) {
			/vardata buffSpawn Spawn[id ${Me.Pet.ID}]
		} else {
			/if (${iniBuffs[${i},${bUseTeamIndex}].NotEqual[-]}) {
				/if (${targetNames.Count}<${teamIndex}) /continue
				/if (${Spawn[pc ${targetNames.Item[${teamIndex}]}].ID}==NULL) /continue
				/vardata buffSpawn Spawn[pc ${targetNames.Item[${teamIndex}]}]
			} else {
				/for k 0 to ${Math.Calc[${targetNames.Count}-1]}
					/vardata buffSpawn Spawn[pc ${targetNames.Item[${k}]}]
					/if (${isLockoutExpired[noHoldTimer_${buffSpawn.ID}_${buffSpellID}]}==TRUE) /break
				/next k
			}
		}

		/if (${buffSpawn.ID}==NULL) /continue
		/if (${isLockoutExpired[noHoldTimer_${buffSpawn.ID}_${buffSpellID}]}==FALSE) /continue

		/if (${iniBuffs[${i},${bNoCast}].NotEqual[-]}) /continue

		/if (${iniBuffs[${i},${bMemInGem}].NotEqual[-]} && ${Me.Gem[${buffCastName}]}==NULL) {
			/call memorizeSpellInGem "${buffCastName}" ${iniBuffs[${i},${bMemInGem}]}
			/if (${Macro.Return}==FALSE) {
				/varset iniBuffs[${i},${bEnabled}] NO
				/continue
			}
		}

		/if (${isCastReady[${buffCastName}]}==FALSE) {
			/continue
		}
		
		/if (${iniBuffs[${i},${bDoCommand}].NotEqual[-]}) {
			/docommand ${iniBuffs[${i},${bDoCommand}]}
			/delay 3
		}


		/invoke (${cq.Append[CAST;SPELL=${buffCastName};FORCETARGETTING=${iniBuffs[${i},${bForceTargetting}]};TARGETID=${buffSpawn.ID};SPELLID=${buffSpellID};CANCELCONDITIONS=${cancelConditions};SRC=iniBuffs;SRCIDX=${i};ONRESULT=onBuffCastResult]})

		/varset buffCheckTimer 15
		/break

	/next i

	/RETURN
}

SUB onBuffCastResult(string result, string opts) {

	/declare i int local ${getStackCommandOpt[${opts},SRCIDX]}
	/declare targetID int local ${getStackCommandOpt[${opts},TARGETID]}
	/declare buffSpellID ${getStackCommandOpt[${opts},SPELLID]}
	/declare targetName string ${Spawn[id ${targetID}]}

	/if (${NetBots[${targetName}].ID}!=NULL) {
		/bct ${targetName} //netnote
	}

	/if (${iniBuffs[${i},${bNoSitTimer}].NotEqual[-]}) {
		/call pauseAutoMed ${iniBuffs[${i},${bNoSitTimer}]}
	}

	/if (${result.Equal[FAIL_NOHOLD]}==TRUE) {
		/echo Spell did not take hold. Locking out buff ${Spell[${buffSpellID}]} for 5m.
		/call lockout noHoldTimer_${targetID}_${buffSpellID} 300
	}

	/if (${iniBuffs[${i},${bRecastDelay}].NotEqual[-]}) {
		/call lockout bufflockout_${buffSpellID} ${iniBuffs[${i},${bRecastDelay}]}
		/echo Buff recast requested. Locking out buff ${Spell[${buffSpellID}]} for ${iniBuffs[${i},${bRecastDelay}]}.
	}

	/if (${result.Equal.Equal[PASS_CAST_SUCCESS]}) {
		/if (${NetBots[${Spawn[id ${targetID}].CleanName}].Level}!=NULL) {
			/bc tell ${NetBots[${Spawn[id ${targetID}].CleanName} NETNOTE
			/squelch /bct ${targetName} //netnote
		}
	}


	/RETURN
}