MacroQuest64

Need to talk about MacroQuest to other MacroQuest users?
https://mq64.org/phpBB3/

Loot Filter And Forage Macro with ini support version 3.1

https://mq64.org/phpBB3/viewtopic.php?t=7485

Page 1 of 2

Loot Filter And Forage Macro with ini support version 3.1

Posted: Wed May 26, 2004 9:40 pm
by draco
Ok, Here is a macro I have modified from a very good forage macro with Ini support to a MQData, MQDataVars full out loot filter.

Upcoming enhancements create the ini file if it doesn't exist.
Move the configuration settings to a settings section of the ini file. that way you don't have to use parameter unless you need/want to overide your preferences.

Thanks to all that have suffered my questions over the last month as I ported this one from pre-MQData pre /notify code.

I added the loot methods and converted it to be suitable to use as an include.

Code: Select all

|----------------------------
| Maintained by Draco
| Version 3.1
| To Be a general Purpose LootFilter
|
|Version 3.1 incorporated suggestions from forum.
|   Added check in Sub Forage for ability checks so when
|   included in larger loops just checks and return in order
|   Provide for cleaner calling code.
|
|Version 3.0 -Draco
| Seperated Load from ini made it a more generic array loader
| Ported to MQData/MQDataVar/Updated Events
| Fixed a Bug in Array indexing
|
|Version 2.3 -Draco
| Added a debug flag to assist in Debuging
| Added Loot Events
|
|Version 2.2 -Draco
| Added Loot routine and made it generic for all looting
|
|
|
| Forager with ini file support and
| statistic gathering and reporting
| version 2.1
| Set this define to the desired .ini file
| Requires a blank .ini file to start. The marco will
| populate the .ini file automatically for any zone
| and default to keeping the item. Then just change
| the values in the .ini file to 0 for an item to be
| automatically destroyed (requires FastItemDestroy
| be turned on in the options window)


#Event ZoneChange "Loading please wait#*#"
#Event NoCorpse  "You must first target a corpse to loot!"
#Event CorpseTooFar "You are too far away to loot that corpse."
#Event NotYourKill "You may not loot this Corpse at this time."


||**
[lootFilter]
version=3.1
**||


#turbo
#define ITEM_NAME 1
#define KEEP_DESTROY 2
#define LOOT_COUNT 3

Sub LootFilterSetup
   /declare LootINIFile       string outer "forager.ini"
   /declare debugLoot         int outer 0
   /declare EnableShowStats    int outer 0        | Set to 1 to show foraging statistics
   /declare EnableWriteLog    int outer 0        | Set to 1 to write statistics to MQLog
   /declare EnableClear       int outer 0        | Set to 1 to clear before writing stats

   /declare LootAttempts       int outer 0
   /declare LootSuccess       int outer 0
   /declare LootFailure       int outer 0
   /declare LootKeeps          int outer 0
   /declare LootDestroys       int outer 0
   /declare NumItem          int outer 0
   /declare LootIndex          int outer 0
   /declare ItemArray[3,60]    string outer
   /declare DefaultKeepItem    int outer 1
   /declare LootTooFar             int outer 0
   /declare NoCorpseToTarget   int outer 0
   /declare UnableToLoot      int outer 0

   | ##### User set variables #####

   | /alias /showstats /call ShowStats

   /call LoadFromIni  ${LootINIFile} global ItemArray ${NumItem}
   /varset NumItem ${Macro.Return}
   /call LoadFromIni ${LootINIFile} "${Zone}" ItemArray ${NumItem}
   /varset NumItem ${Macro.Return}
/return



| ########## Subroutines ##########

Sub Forage
  /if (${Me.Ability[Forage]} && ${Me.AbilityReady[Forage]}) {

     /doability Forage
     /varadd LootAttempts ${LootAttempts}+1
  }
/return


sub LootMob
    /declare LootSlot int local 1
      /lootn never
      /delay 1s
      /varset LootTooFar 0
      /loot
      /delay 10
   /doevents NotYourKill
   /doevents CorpseTooFar
   :lootloop
   /if (${LootTooFar}==1) /goto :doneloot
   /if (${Corpse.Items}==0) {
       /if (${debugLoot}>0) /echo Corpse Empty
      /goto :doneloot
   }
   /if (${LootSlot}>=32) /goto :doneloot
   /itemnotify Loot${LootSlot} leftmouseup
   /delay 2s
    /if (${debugLoot}>0) /echo Cursor has: ${Cursor}

   | Use LootFilter Check here initially building the LootINIFile then file will be edited
   | to Adjust for preference on Keep Destroy
   /call CheckItem
   /call HandleItem

   /if (${Bool[${Cursor.Name}]}) {
    /delay 1s
    /if (${debugLoot}>0) /echo Destroying: ${Cursor.Name}
    /destroy
    /delay 1s
   }

   /varcalc LootSlot ${LootSlot}+1
   /goto :lootloop
   :doneloot
   /notify LootWnd DoneButton leftmouseup
   /lootn always
   /varset LootSlot 0
/return



Sub LogStats
  /declare xy int local
  /if (${EnableClear}==1) /mqlog clear
  /mqlog #############################################
    /mqlog For Zone: ${Zone}
    /mqlog Attempts = (${LootAttempts})
    /mqlog Success  = (${LootSuccess})  [(${Math.Calc[${LootSuccess}/${LootAttempts}*100]})%]
    /mqlog Failures = (${LootFailure})  [(${Math.Calc[${LootFailure}/${LootAttempts}*100]})%]
    /mqlog Keeps    = (${LootKeeps})    [(${Math.Calc[${LootKeeps}/${LootAttempts}*100]})%]
    /mqlog Destroys = (${LootDestroys}) [(${Math.Calc[${LootDestroys}/${LootAttempts}*100]})%]
    /mqlog [Idx] [Item] [Keep] [Qty] [%]
    /mqlog -------------------------------------------
    /if (${NumItem}>0) {
      /for xy 1 to ${NumItem}
         /if (${ItemArray[LOOT_COUNT,${xy}]}>0) {
               /mqlog "[${xy}] [${ItemArray[ITEM_NAME,${xy}]}] [${ItemArray[KEEP_DESTROY,${xy}]}] [${ItemArray[LOOT_COUNT,${xy}]}] [${Math.Calc[${ItemArray[LOOT_COUNT,${xy}]}/${LootAttempts}*100]}%]"
          }
      /next xy
  }
/return

Sub ShowStats
  /declare xy int local
  /if (${EnableClear}==1) /clear
  /echo #############################################
  /echo For Zone: ${Zone}
  /echo Attempts = (${LootAttempts})
  /echo Success  = (${LootSuccess})  [(${Math.Calc[${LootSuccess}/${LootAttempts}*100]})%]
  /echo Failures = (${LootFailure})  [(${Math.Calc[${LootFailure}/${LootAttempts}*100]})%]
  /echo Keeps    = (${LootKeeps})    [(${Math.Calc[${LootKeeps}/${LootAttempts}*100]})%]
  /echo Destroys = (${LootDestroys}) [(${Math.Calc[${LootDestroys}/${LootAttempts}*100]})%]
  /echo [Idx] [Item] [Keep] [Qty] [%]
  /echo -------------------------------------------
  /if (${NumItem}>0) {
    /for xy 1 to ${NumItem}
       /if (${ItemArray[LOOT_COUNT,${xy}]}>0) {
             /echo "[${xy}] [${ItemArray[ITEM_NAME,${xy}]}] [${ItemArray[KEEP_DESTROY,${xy}]}] [${ItemArray[LOOT_COUNT,${xy}]}] [${Math.Calc[${ItemArray[LOOT_COUNT,${xy}]}/${LootAttempts}*100]}%]"
        }
    /next xy
  }
/return



Sub CheckItem
  /declare iter int local
  /varcalc LootAttempts ${LootAttempts}+1
  /if (${NumItem}==0) {
    /varset NumItem 1
    /call AddToArray ${NumItem)
    /varset LootIndex 0
  } else {
       /for iter 1 to ${NumItem}
            /if ( ${Cursor.Name.Equal[${ItemArray[ITEM_NAME,${iter}]}]} ) {
            /varset LootIndex ${iter}
               /if (${debugLoot}>0) /echo "${ItemArray[ITEM_NAME,${iter}]} : ${ItemArray[KEEP_DESTROY,${iter}]}: ${ItemArray{LOOT_COUNT,${iter}]}"
         }
       /next iter
       /if (${LootIndex}==0) {
         /varcalc NumItem ${NumItem}+1
         /if (${debugLoot}>0) /echo "${Cursor.Name} not found!"
         /call AddToArray  ${NumItem)
       } else {
            /varcalc ItemArray[LOOT_COUNT,${LootIndex}] ${ItemArray[LOOT_COUNT,${LootIndex}]}+1
       }
  }
/return

Sub AddToArray(int endPos)
    /if (${debugLoot}>0) /echo "Adding ${Cursor} to Item Array"
    /varset ItemArray[ITEM_NAME,${NumItem}] ${Cursor}
    /varset ItemArray[KEEP_DESTROY,${NumItem}] ${Ini["${LootINIFile}","${Zone}","${Cursor}" NOTFOUND]}
    /if (${ItemArray[KEEP_DESTROY,${NumItem}].Equal[NOTFOUND]} ) {
       /if (${debugLoot}>0) /echo "${Cursor} Not Found in ${LootINIFile}"
       /varset ItemArray[KEEP_DESTROY,${NumItem}] ${DefaultKeepItem}
       /ini "${LootINIFile}" "${Zone}" "${Cursor}" ${DefaultKeepItem}
       /if (${debugLoot}>0) /echo "Added [${Zone}] ${Cursor}=${DefaultKeepItem} to ${LootINIFile}"
       /mqlog "Added [${Zone}] ${Cursor}=${DefaultKeepItem} to ${LootINIFile}"
    }
    /varset ItemArray[LOOT_COUNT,${NumItem}] 1
/return

Sub HandleItem
  /if ( ${ItemArray[KEEP_DESTROY,${LootIndex}].NotEqual[1]} ) {
    /varcalc LootDestroys ${LootDestroys}+1
    /if (${debugLoot}>0)  /echo Destroying: ${Cursor.Name}
      /destroy
  } else {
    /varcalc LootKeeps ${LootKeeps}+1
      /if (${debugLoot}>0)  /echo Keeping: ${Cursor.Name}
    /autoinv
  }
/return

| ########## Subroutines ##########

Sub LoadFromIni(string iniFileName, string zoneName, ArrayName, startIndex )

   /declare IniPosition int local 0
   /declare IniList string local
   /declare finishIndex int local ${startIndex}

    /if (${debugLoot}>0) /echo "Loading Loot Table for ${zoneName}: ${Ini[${iniFileName},${zoneName}]}"
    /varset IniList ${Ini[${iniFileName},${zoneName}]}
    /if (${Bool[${IniList}]}) {
      /if (${debugLoot}>0) /echo "KeySet[${zoneName}]=${IniList}"

   :CheckZoneLoot
       /varcalc IniPosition ${IniPosition}+1
       /varcalc finishIndex ${finishIndex}+1
       /if (${debugLoot}>0) /echo Item(${IniPosition}): ${IniList.Arg[${IniPosition},|]}

       /varset ${ArrayName}[1,${finishIndex}] ${IniList.Arg[${IniPosition},|]}
       /varset ${ArrayName}[2,${finishIndex}] ${Ini[${iniFileName},${zoneName},${${ArrayName}[1,${finishIndex}]}]}

       /if (${debugLoot}>0) /echo "ZONE LOAD ${${ArrayName}[1,${finishIndex}]}=${${ArrayName}[2,${finishIndex}]}"

      /if (${Bool[${IniList.Arg[${Math.Calc[${IniPosition}+1]},|]}]}) /goto :CheckZoneLoot
    }
/return ${finishIndex}

Sub Event_ZoneChange
   /delay 1m
   /call LoadFromIni  ${LootINIFile} global ItemArray 0
   /varset NumItem ${Macro.Return}
   /call LoadFromIni ${LootINIFile} "${Zone}" ItemArray ${NumItem}
   /varset NumItem ${Macro.Return}
/return

Sub Event_CorpseTooFar
   /varset LootTooFar 1
/return

Sub Event_NoCorpse
   /varset NoCorpseToTarget 1
   /return
Sub Event_NotYourKill
   /varset UnableToLoot 1
/return

Usage:
In your initialization code call LootFilterSetup
After a corpse is targetted call LootMob i.e.

Code: Select all


|Loot.mac
#include lootFilter.inc


Sub Main
	/call lootFilterSetup
	/call LootMob
/return

Code: Select all

|----------------------------
| Forager with ini file support and
| statistic gathering and reporting
| version 3.0 By Draco
| Move the guts to forager.inc left this as a place to call the main loop
| I have used to /call CheckItem and /call HandleItem in my lootMob code
| sample Here:
| sub LootMob
|   /lootn never
|   /delay 1s
|   /loot
|   /delay 1s
|   /varset LootTooFar 0
|   :lootloop
|   /if (${LootTooFar}==1) /goto :doneloot
|   /if (${LootSlot}>=32) /goto :doneloot
|   /click left corpse ${LootSlot}
|   /delay 1s
|  /if (${Bool[${Cursor.Name}]}) /goto :doneloot
|   | Use Forager Check here initially building the LootINIFile then file will be edited
|   | to Adjust for preference on Keep Destroy
|   /call CheckItem
|   /call HandleItem
|
|  /if "$cursor()"}=="TRUE" {
|     /delay 1s
|     /click left destroy
|      /delay 1s
|   }
|   /varadd LootSlot 1
|   /varset CheckLoot 0
|   /goto :lootloop
|   :doneloot
|   /lootn always
|   /varset LootSlot 0
|/return
|
| This loot loop was orignally found in Grimkjacks hunter.mac I removed his
| loot filter arrays and use calls to the included forager.inc. I also
| implemented several of the sugestion found in this forum to include a outer
| section, etc.
|
| version 2.1
| Set this define to the desired .ini file
| Requires a blank .ini file to start. The marco will
| populate the .ini file automatically for any zone
| and default to keeping the item. Then just change
| the values in the .ini file to 0 for an item to be
| automatically destroyed (requires FastItemDestroy
| be turned on in the options window)
|
| TODO
| Add a combat check to forage to turn off attack forage them turn it back on.


#turbo

#include "lootFilter.inc"

Sub Main

 /call ForageSetup

:Continue
  /varset ForageIndex 0
  /if (${Me.Ability[Forage]} && ${Me.AbilityReady[Forage]}) {
	  /call Forage
	  /if( ${Bool[${Cursor.Name}]} ){
	    /varcalc ForageFailure ${ForageFailure}+1
	  } else {
	    /varcalc ForageSuccess ${ForageSuccess}+1
	    /call CheckItem
	    /call HandleItem

	  }

	/if (${EnableShowStats}==1 ) /call ShowStats
  	/if (${EnableWriteLog}==1 ) /call LogStats

  }
  |/delay ${ForageDelay}
  /goto :Continue

/return

Though, I included sample macro implementations I posted this in snipets because, I feel the real power of this macro is being able to be included in hunter macros , etc. Enjoy, please comment. If we can make these better I welcome the input. And again The orginal macro was not mine. However unfortunately there name isn't in the code.

Sample ini

Code: Select all

[Global]
Spider Silk=1
Roots=1
Fishing Grubs=0

Wow

Posted: Thu May 27, 2004 1:12 pm
by jdelpheki
if only tou had a ground spawn.inc and a randome corpse target you would have made the perfect zone cleaner. picks up everything not currently claimed :)

Posted: Thu May 27, 2004 1:22 pm
by draco
Actually, I'm at work now. But, I isolated the loot all corpses in and area Routine to my main file. Since it calls movement routine and wouldn't have been self contained. The loot area attemps to loot if the Corpse too far event fires. Logic in the loot area calls the movement code and then tries again.

A ground spawn routine wouldn't be hard to write. Just write a routine that targets and picks them up. Them just use /call checkItem and /call HandleItem to filter it. I'll look into adding it.

cool

Posted: Thu May 27, 2004 1:51 pm
by jdelpheki
might want to isolate the remaining time on the corpses. if you just want to loot left overs be faster than walking to a unlootable one

Posted: Tue Jun 08, 2004 9:50 am
by draco
I would do that outside this include from the calling macro. i.e. Wherever lootMob is called from. I purposely didn't put any movement in this include to keep it general. Though, it has some helper events to let you know that the corpse is too Far. I leave it up to the integrator to determine how to get to the corpse. I have included this in my hunter macros. I also use the above loot.mac as a hotkey. now, I would add those kinds of checks in loot.mac. Though, the one posted was merely, meant as an example.

ok so what do I need to do to get this to work?

Posted: Sun Jun 27, 2004 2:00 am
by JWWQ
How does this work?

Do I need to set up blank Ini files? In what Locations? Do I need to uncomment certain lines or pre-reset some declare values in the macro code? Which of the 3 code clips can be used as the .mac and which should be saved as .inc? Should I name certain code-clips certain filenames?
Do I need to save different portions of this code in different .mac files or different .inc files?

Which parts? I have played with this macro for 3 hours now, trying to figure how to get it to work. I have read and reread te post, input several echo commands into the code to track why the macro didnt seem to be writing any item-lists to any .ini files in my mq2/release/macros folder.

I have poured over the scant information in the readme mq2 help file for info on Arrays.

I have 2 questions.... 1 how do I get an array to work? What is it? How do I use Arrays to tap ini Data? (ok that was really only 1 question.....the next?)


Question 2 - What specific steps do I need to take to get this macro runnable on my machine? (Please be as specific as possible, assuming nothing.) IF you want to call me an idiot while you tell me as if I were a 4-year old, that would be great...just as long as I get the 4-year-old explaination.


I am sure this is something rather obvious and I must have overlooked some silly silly thing, but PLEASE! help.....

Send PM if you would like, but I think others might need this info too.

no prob

Posted: Sun Jun 27, 2004 9:31 am
by macrolover
JWWQ the first code is the include and the third code is the mac. it's a forager in current state all you need from it to forage is this.

Code: Select all

#turbo

#include "lootFilter.inc"

Sub Main

/call ForageSetup

:Continue
  /varset ForageIndex 0
  /if (${Me.Ability[Forage]} && ${Me.AbilityReady[Forage]}) {
     /call Forage
     /if( ${Bool[${Cursor.Name}]} ){
       /varcalc ForageFailure ${ForageFailure}+1
     } else {
       /varcalc ForageSuccess ${ForageSuccess}+1
       /call CheckItem
       /call HandleItem

     }

   /if (${EnableShowStats}==1 ) /call ShowStats
     /if (${EnableWriteLog}==1 ) /call LogStats

  }
  |/delay ${ForageDelay}
  /goto :Continue

/return
plus the include named as lootfilter.inc

Ok lemme see if i got this right?

Posted: Mon Jun 28, 2004 12:03 pm
by JWWQ
I am interested in this only for Looting those corpses.

(I may make a forager character later, but for now, Looting is it.)

In my Macros Folder I will save the following
1.) lootfilter.inc - This is the first piece of code. ( I can just copy/paste
the beast as is.)

2.) Myloot.mac - This is the 3rd piece of code in the original post.
(Same copy/paste, Save As... )

Then,

3.) Log into EverQuest and run MQ2.

4.) Type "/macro MyLoot.mac"

That's it?

Should there be a

2 1/2.) Create a blank ini file called forager.ini

2 3/4.) Do something with the 2nd piece of code?

Also...

The macro first does "/call ForageSetup" but there is no "Sub ForageSetup" in the lootfilter.inc or the Myloot.mac.

Thank you so much for your help. These few assumptions that I can overcome, wil undoubtedly catapult me into competency. *crosses fingers*

Posted: Mon Jun 28, 2004 4:03 pm
by macrolover
okay on the /call change it to /call LootFilterSetup

Posted: Thu Jul 01, 2004 10:46 pm
by draco
Sorry, I have been busy. working on other marcos. I didn't realize this one was getting so mucha attention. That said. To do simple loot corpse. just copy the lootFilter.inc and the loot.mac The will give you a runnable macro. THe include file does generate the ini as it goes. You may need an empty file however, Whenever it encounters something it had never seen before it adds it to the file. the DefaultDestroy item flag is very important. USE WITH EXTREME CAUTION. This would destroy your epic if you let it. YOU HAVE BEEN WARNED. That said.

Just drop the pieces of code in your macro folder. create a empty forager.ini and let it run. you you are looking for some in particular you could fill it in in the file. I originally. used this macro to forage for druid epic pieces. The figured it would be great to use wehn farming to sort out what I wanted to keep versus destroy. There are lots of uses. But it is pretty easy to use.

draco

Posted: Thu Jul 01, 2004 11:24 pm
by macrolover
isn't the loot part of your macro commented out?

Posted: Fri Jul 09, 2004 11:29 pm
by zanomo
I tried the code, while the looting works but there are something strange, somehow it was destroying some items while storing the other. I did the initialzation once in the code and do the looting in the main code and have created an empty forager.ini in both the macro and ini directory. When I turn the debug mode on, it said "Loading Table for The Halls of Honor: NULL" and the forager.ini never got populated with anything after a number of new item looted/destroyed. It is empty all the while. I am not too sure how the ini initialization works and how to fixed this.

I don't know where the code went wrong or what I did wrong, any advise where to look please?

Thanks for your suggestion in advance. :smile:

Posted: Mon Jul 12, 2004 11:09 pm
by Wendel
Can anyone post a sample ini?

I'd like to try this out as just a loot macro, but can't seem to figure out the ini

Posted: Mon Jul 12, 2004 11:22 pm
by aChallenged1
Code needs to be edited and corrected for the BBCode change that made all the old codes with < and > signs turn into the HTML equivilents < and > respectively.

If you have copied this reciently, you will need to go through and make the changes yourself. This can be done via notepad using CTRL H and using the replace feature.

Posted: Tue Jul 13, 2004 2:47 am
by zanomo
Thanks for the tip about the < and > signs. I have most part of the macro working before I asked for help. It is just that the ini part not function. It wasn't creating any ini file and when i created an empty forager.ini file in ALL the MQ2 directories (because i wasn't sure if it is accessing the ini file in the folder where the macro is stored or in the other ini folder), it was not doing anything with any of it either.

I had copy a sample forager.ini from another discussion trail where this macro seemed to be originated, but this macro wasn't doing anything to it either.

The reason why i want to use this macro is to be able to populate the ini file with foraged and looted items so I can select afterward which one i wanted to keep or destroy. However this is the part that I cannot make it to work.

I already have a simple forage and loot subroutine which keeps everything.

Any suggestion? I am quite new to MQ2 although I have wrote a few utilities for my own characters I have not touch on the ini file area. The readme manual doesn't have much examples on it. Can anyone point me to somewhere where there are references and examples regarding how to create and modify the ini file so I can modify and debug it myself please? Thanks!
All times are UTC-04:00
Page 1 of 2
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/