MacroQuest64

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

need help with if commands

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

Page 1 of 1

need help with if commands

Posted: Sun Aug 15, 2004 9:59 pm
by grayfox107
this is just a macro from advchant by Raebis that I have changed, the idea was to add lev and a slow song into the mix as well a way to make run in the same circle without moving away but I cant figure out how to get the if statements to work involving the circle and the selection of songs when twisting. Im still figuring out how to write macros so anything would help.

Code: Select all




#event NeedTarget "You must first select a target for this spell!"
#event Exp        "You gain "
#event Died       "You have entered"
#event Caster     " begins to cast a spell."
#event Tell       "tells you"

#turbo 10

Sub Main(string DOTs,string Selos,int CRadius,string Health,string Slow,string Lev,int Paused)

   /if (!${Defined[CRadius]}) {
      /echo usage: chant.mac <DOTs, LVL6 Selos> <49selo> <radius> [<heal song>] [<Slow Song>] [<Lev Song>] [<Pause>]
      /return
   }

   /declare PauseFlag int outer

   /if (${Defined[Paused]}) {
       /if (${Paused}) {
           /varset PauseFlag 1
       } else {
           /varset PauseFlag 0
       }
   } else {
       /varset PauseFlag 0
   }

   /declare avoidadd string outer
   /declare avoidrem string outer

   /alias /pause /varcalc PauseFlag !${PauseFlag}
   /alias /avoidadd /varset avoidadd
   /alias /avoidrem /varset avoidrem

   /declare CirR outer

   /declare Songs[10] int outer
   /declare nSongs int outer
   /declare CurSong int outer
   /declare PrevSong int outer

   /declare Exper int outer
   /declare AAExp int outer

   /declare icount int outer

   /declare SongTimer timer outer
   /declare SeloSong int outer

   /declare HealSong int outer
   /declare SlowSong int outer
   /declare LevSong int outer
   /declare OrigSong int outer
   /declare OrigSong2 int outer

   /declare HealthMin outer
   /declare HealthMax outer

   /declare TargetHealthMin outer

   /declare DBLevel outer

   /declare TargetUpNext int outer

   /declare AnchorX int outer 	
   /declare AnchorY int outer

   /declare CampAnchorX int outer
   /declare CampAnchorY int outer 	


   /declare AvoidList[50] string outer UNDEFINED-ARRAY-ELEMENT 			

   /declare MyXLOC float outer
   /declare MyYLOC float outer

   /declare ObstCount int outer
   /declare EachSong int local

   /call AvoidINILoad

   /varset CampAnchorX 6072.78
   /varset CampAnchorY 867.39

   /varset PrevSong 0
   /varset MyXLOC 0.0
   /varset MyYLOC 0.0

   /varset nSongs ${DOTs.Length}
   /echo nSongs ${nSongs}
   /echo DOTs ${DOTs}
   /for EachSong 1 to ${nSongs}
      /varset Songs[${EachSong}] ${DOTs.Mid[${EachSong},1]}
      /echo Song ${EachSong}: ${Me.Gem[${Songs[${EachSong}]}].Name}
   /next EachSong

   /if (${Selos}!=0) {
      /varset SeloSong ${Selos}
      /echo Selo's: ${Me.Gem[${SeloSong}].Name}
   } else {
      /varset SeloSong 0
      /echo Not using level 49 Selos.
   }

   /if (!${Defined[Health]}) {
      /echo No HealSong. Please watch your health.
      /varset HealSong 0
   } else /if (${Health}!=0) {
      /varset HealSong ${Health}
      /echo Healsong: ${Me.Gem[${HealSong}].Name}
   } else {
      /echo No HealSong. Please watch your health.
      /varset HealSong 0
   }

   /if (!${Defined[Slow]}) {
      /echo No SlowSong. Your Prey may run away.
      /varset slowSong 0
   } else /if (${Slow}!=0) {
      /varset SlowSong ${Slow}
      /echo Slowsong: ${Me.Gem[${SlowSong}].Name}
   } else {
      /echo No SlowSong. Your Prey may run away.
      /varset slowSong 0
   }


   /if (!${Defined[Lev]}) {
      /echo No LevSong. You will either fall or drown.
      /varset LevSong 0
   } else /if (${Lev}!=0) {
      /varset LevSong ${Lev}
      /echo LevSong: ${Me.Gem[${LevSong}].Name}
   } else {
      /echo No LevSong. You will either fall or drown.
      /varset LevSong 0
   }



   /varset CirR ${CRadius}
   /echo Radius: ${CirR}

   /varset OrigSong ${Songs[1]}
   /varset OrigSong2 ${Songs[2]}
   /varset CurSong 1
   /varset Exper ${Me.Exp}
   /varset AAExp ${Me.AAExp}
   /varset SongTimer 1

   |/varset DBLevel $int($calc($calc($char(level)*.75)+1))
   /varset DBLevel 35

   /varset HealthMin 70
   /varset HealthMax 85

   /varset TargetHealthMin 20

   /varset TargetUpNext 0   

   /varset AnchorX ${Me.X}
   /varset AnchorY ${Me.Y}



   /echo Anchor dropped at ${AnchorX},${AnchorY}
   /echo Camp-Anchor dropped at ${CampAnchorX},${CampAnchorY}

   /if (${PauseFlag}==1) {
       /echo Script [PAUSED] issue an "/pause" to unpause it.
   }

:Loop

    /if (${avoidadd.Length}) {
        /echo ${avoidadd.Length} for ${avoidadd}
        /call AvoidINIAdd "${avoidadd}"
        /varset avoidadd
    }

    /if (${avoidrem.Length}) {
        /echo ${avoidrem.Length} for ${avoidrem}
        /call AvoidINIRemove "${avoidrem}"
        /varset avoidrem
    }

    /if (${PauseFlag}==1) {
        /delay 1
        /doevents AddAvoid
        /doevents RemoveAvoid
        /goto :Loop
    }

   /if (${TargetUpNext}<=0) /if (!${Target.ID}) {
      /call GetTarget
      |/delay 2
   }

   /if (${TargetUpNext}>0) /if (${Target.ID}) {
      /echo User Selected Target or Aggroed while running
      /varset TargetUpNext 0
   }

   /if (${Target.Distance}>300) /if (${Target.PctHPs}<=20) {
      /echo Target Has left range... Getting a new target; id was ${Target.ID}
      /cleanup
      /call GetTarget
      /delay 2
   }



/if (!${Spawn[gm].ID}) { 

    /if (${HealSong}) /if (${Me.PctHPs}<${HealthMin}) {
      /if (${Songs[1]}!=${HealSong}) {
         /echo Healing On - Health: ${Me.PctHPs}% to ${HealthMax}%
         /varset Songs[1] ${HealSong}
      }
   }

   /if (${HealSong}) /if (${Me.PctHPs}>=${HealthMax}) {
      /if (${Songs[1]}!=${OrigSong}) {
         /echo Healing Off
         /varset Songs[1] ${OrigSong}
      }
   } 


   /if (${SlowSong}) /if (${Target.PctHPs}<${TargetHealthMin}) {
      /if (${Songs[2]}!=${SlowSong}) {
         /echo Slowing On On - Health: Target Health is less than ${TargetHealthMin}%
         /varset Songs[2] ${SlowSong}
      }
   }

   /if (${SlowSong}) /if (${Target.PctHPs}>${TargetHealthMin}) {
      /if (${Songs[2]}!=${OrigSong2}) {
         /echo Slowing Off
         /varset Songs[2] ${OrigSong2}
      }
   }
} else {

/if (${HealSong}) /if (${Songs[1]}!=${HealSong}) {
         /varset Songs[1] ${HealSong}
      }
   

 
      /if (${LevSong}) /if (${Songs[2]}!=${LevSong}) {
         /echo Starting the Lev. Song
         /varset Songs[2] ${LevSong}
      }
    )	

)


   |/delay 2
   /if (${SeloSong}) /if (!${Me.Casting.ID}) /if (!${Me.Buff[$Me.Gem[${SeloSong}].Name].Duration}) /varset SongTimer 1
   /if (${SongTimer}>0) /if (!${Me.Casting.ID}) /call SongFailed
   /call Circ
   /delay 1
   /doevents
   |/delay 1
   /goto :Loop
/return

Sub Event_Timer(string TimerName)
   /if (${String[${TimerName}].Equal[SongTimer]}) {
      | ${Me.Buff[${Me.Gem[4]}].ID}
      /if (${SeloSong}) /if (!${Me.Buff[${Me.Gem[${SeloSong}]}].ID}) {
         /echo Selos not up!!!
         /stopsong
         /cast ${SeloSong}
         /varset PrevSong 0
         /varset SongTimer 30
         /call Circ
         /doevents
         /return
      }

      | ${Me.Buff[${Me.Gem[4].Name}].Duration}<=6) {
      /if (${SeloSong}) /if (${Me.Buff[${Me.Gem[${SeloSong}].Name}].Duration}<=6) {
         /echo Selos about to die
         /stopsong
         /cast ${SeloSong}
         /varset PrevSong 0
         /varset SongTimer 30
         /call Circ
         /doevents
         /return
      }

      /delay 2
      /stopsong
      /echo ${CurSong} casting ${Songs[${CurSong}]}
      /cast ${Songs[${CurSong}]}
      /varset PrevSong ${CurSong}
      /varcalc CurSong ${CurSong}+1
      /if (${CurSong}>${nSongs}) /varset CurSong 1
      /varset SongTimer 30
      /call Circ
      /doevents
   }
/return

Sub Circ
   /doevents

   /declare CirX local
   /declare CirY local

   /call CheckObst

   /if (${Target.ID}) {

/if (${Spawn[gm].ID}) { 

     /varset CirY ${CampAnchorY}
     /varset CirX ${CampAnchorX}

   } 
     /varset CirY ${AnchorY}
     /varset CirX ${AnchorX}

   } else {

        /if (${TargetUpNext}!=0) {

	
/if (${Spawn[gm].ID}) { 

     /varset CirY ${CampAnchorY}
     /varset CirX ${CampAnchorX}

   }
     /varset CirY ${AnchorY}
     /varset CirX ${AnchorX}


}


            /if (${Spawn[ID ${TargetUpNext}].Distance}<=${Math.Calc[${CirR}*2]}) {
                /if (${Target.ID}) {
                    /if (${Target.ID}!=${TargetUpNext}) {
                        /target id ${TargetUpNext}
                    }
                } else {
                    /target id ${TargetUpNext}
                }
                /varset TargetUpNext 0
            }
        }
   }

   /if (${Math.Distance[${CirX},${CirY}]}<${Math.Calc[${CirR}/2]}) {
      /face heading ${Math.Calc[${Heading[${CirX},${CirY}].DegreesCCW}+180]}
   } else {
      /face heading ${Math.Calc[${Heading[${CirX},${CirY}].DegreesCCW}+${Math.Calc[90*${CirR}/${Math.Distance[${CirX},${CirY}]}]}]}
   }
/return

Sub SongFailed
   /if (!${PrevSong}) {
      /varset SongTimer 1
      /return
   }
   /varset CurSong ${PrevSong}
   /varset SongTimer 1
/return

Sub Event_NeedTarget
   /if (${TargetUpNext}<=0) /call GetTarget
/return

Sub Event_Exp
   /varset AAExp ${Math.Calc[${Me.AAExp}-${AAExp}]}
   /varset Exper ${Math.Calc[${Me.Exp}-${Exper}]}

   /echo EXP: ${Exper}:${Me.PctExp}% - AAXP: ${AAExp}:${Me.AAExp}% - ${Math.Calc[${Macro.RunTime}/60]} minutes

   /varset Exper ${Me.Exp}
   /varset AAExp ${Me.AAExp}

   /if (${TargetUpNext}==0) /if (${Target.ID}==0) /call GetTarget
/return

Sub GetTarget
   /declare LastMobID int local 0
   /declare FirstMobID int local 0
   /declare MobID int local 0
   /declare SRadius int local


   /varset MobID ${Spawn[npc radius ${Math.Calc[${CirR}*2]}].ID}
   /varset FirstMobID ${MobID}
   /echo MobID ${MobID}

   :CheckAggrodMobs
   /if (${MobID}!=0) {
       /if (${Spawn[ID ${MobID}].Speed}>100) {
          /call AvoidTargets ${MobID}
          /if (${Macro.Return}==1) {
             /target id ${MobID}
             /echo Kiting aggro'd mob: ${Target.CleanName}
             /return
          }
       }
       /varset LastMobID ${MobID}
       /varset MobID ${Spawn[npc id ${LastMobID} radius ${Math.Calc[${CirR}*2]} next].ID}
       /if (${FirstMobID}==${MobID}) {
           /goto :NoAggrodMobs
       }
       /goto :CheckAggrodMobs
       :NoAggrodMobs
   }
   /echo no aggro'd mobs found

   /varset MobID 0
   /varset FirstMobID 0
   /varset LastMobID 0
   /alert clear 1
   | a clear alert and noalert don't mix
   /alert add 1 npc this_is_bogus
   /for SRadius 100 to 10000 step 100
      /if (${MobID}==0) {
          /varset MobID ${Spawn[noalert 1 npc range ${DBLevel} ${Me.Level} loc ${AnchorX} ${AnchorY} radius ${SRadius}].ID}
          /varset FirstMobID ${MobID}
      } else {
          /varset LastMobID ${MobID}
          /varset MobID ${Spawn[noalert 1 npc range ${DBLevel} ${Me.Level} loc ${AnchorX} ${AnchorY} radius ${SRadius}].ID}
          /if (${FirstMobID}==${MobID}) {
              /next SRadius
          }
      }
      /if (${MobID}!=0) {
         /call AvoidTargets ${MobID}
         /if (${Macro.Return}==1) {
            /echo not avoiding ${Spawn[ID ${MobID}].CleanName}
            /goto :Done
         } else {
            /alert add 1 npc ${Spawn[ID ${MobID}].CleanName}
        }
      }
   /next SRadius

   /varset MobID ${Spawn[npc]}
   /echo No mobs found, action required!
   /beep
   /beep
   /beep
   /beep
:Done
   /varset TargetUpNext ${MobID}
   /echo Next: ${Spawn[ID ${MobID}].Level} ${Spawn[ID ${MobID}].CleanName} - Distance: ${Spawn[ID ${MobID}].Distance}
/return



|#############################################################################


Sub AvoidTargets(int TempMobID)
    /declare Element int local 1

:AvoidCheckLoop

    /if (${AvoidList[${Element}].Equal[UNDEFINED-ARRAY-ELEMENT]}) {
        /return 1
    }

    /if (${AvoidList[${Element}].Equal[${Spawn[ID ${TempMobID}].CleanName}]}) {
        /echo AVOIDING ${AvoidList[${Element}]}
        /return 0
    }
    /varcalc Element ${Element}+1
/goto :AvoidCheckLoop
/return 1


|#############################################################################


Sub AvoidINIRemove(string RemoveName)
/declare TempElements local 0
/declare TempVar int local 0
/declare TempItem string local

:RemCheckLoop
    /varset TempItem ${Ini[AvoidList.ini,Avoid,${TempVar},NOTFOUND]}
    /if (${TempItem.Equal[NULL]}) {
        | no file
        /goto :RemFoundInArray
    }
    /if (${TempItem.Equal[NOTFOUND]}) {
        /echo ${RemoveName} not in AvoidList.ini
        /goto :RemFoundInArray
    }

    /if (${RemoveName.Equal[${TempItem}]}) {
        /varset AvoidList[${Math.Calc[${TempVar}+1]}] Empty 
        /echo ${RemoveName} removed from AvoidList.ini
        /ini AvoidList.ini Avoid ${TempVar} Empty
    :VerifyRemoval
        /if (!${Ini[AvoidList.ini,Avoid,${TempVar},NOTFOUND].Equal[Empty]}) {
            /echo verify removal unsuccessful
            /goto :VerifyRemoval
        }
        /goto :RemFoundInArray
    }
    /varcalc TempVar ${TempVar}+1
    /goto :RemCheckLoop
:RemFoundInArray
/return


|#############################################################################


Sub AvoidINIAdd(string AddName)
/declare TempElements int local 0
/declare TempVar int local 1
/declare TempItem string local

/echo AvoidINIAdd ${AddName}

:AddCheckLoop
    /varset TempItem ${Ini[AvoidList.ini,Avoid,${TempVar},NOTFOUND]}

    /if (${TempItem.Equal[NULL]}) {
        | no file
        /goto :FoundInArray
    }

    /if (${TempItem.Equal[NOTFOUND]}) {
        /varset AvoidList[${Math.Calc[${TempVar}+1]}] ${AddName}
        /goto :AddItem
    }

    /if (${TempItem.Equal[${AddName}]}) {
        /echo ${AddName} already in AvoidList.ini
        /goto :FoundInArray
    }

    /if (${TempItem.Equal[Empty]}) {
        /varset AvoidList[${Math.Calc[${TempVar}+1]}] ${AddName}
        /goto :AddItem
    }

    /varcalc TempVar ${TempVar}+1
    /goto :AddCheckLoop

:AddItem

    /ini AvoidList.ini Avoid ${TempVar} "${AddName}"

:VerifyAdd
    /if (!${Ini[AvoidList.ini,Avoid,${TempVar},NOTFOUND].Equal[${AddName}]}) {
        /echo verify addition unsuccessful
        /goto :VerifyAdd
    }

/echo ${AddName} added to AvoidList.ini

:FoundInArray
/return


|#############################################################################


Sub AvoidINILoad
/declare TempItem string local
/declare AvoidItemNum int local 0

:LoadAvoidLoop

    /varset TempItem ${Ini[AvoidList.ini,Avoid,${AvoidItemNum},NOTFOUND]}
    /if (${TempItem.Equal[NULL]}) {
        /goto :DoneLoading
    }
    /if (${TempItem.Equal[NOTFOUND]}) {
        /goto :DoneLoading
    }
    | note: indexing starts at 1 not 0
    /echo adding ${TempItem} to avoid list at ${Math.Calc[${AvoidItemNum}+1].Int}
    /varset AvoidList[${Math.Calc[${AvoidItemNum}+1]}] ${TempItem}
    /varcalc AvoidItemNum ${AvoidItemNum}+1
    /goto :LoadAvoidLoop
:DoneLoading
/return


|#############################################################################


Sub Event_AddAvoid(string EvtText)
/if (${EvtText.Mid[6,10].Equal[avoid add ]}) {
    /call AvoidINIAdd "${EvtText.Mid[16,${Math.Calc[${EvtText.Length}-16]}]}"
}
/return

Sub Event_RemoveAvoid(EvtText)
/if (${EvtText.Mid[6,13].Equal[avoid remove ]}) {
    /call AvoidINIRemove "${EvtText.Mid[19,${Math.Calc[${EvtText.Length}-19]}]}"
}
/return

Sub Event_Caster(string CastText)
   /declare CasterID int local
   /varset CasterID ${Spawn[${CastText.Left[${Math.Calc[${String[${CastText}].Length}-24]}]}].ID}
   /if (!${Spawn[ID ${CasterID}].Type.Equal[NPC]}) /return
   /if (${Target.ID}==${CasterID}) /return
   /if (${Spawn[ID ${CasterID}].Distance}<=${Math.Calc[${CirR}*2]}) {
      /target id ${CasterID}
      /echo Targeting Caster: ${Target.CleanName}
   }
/return

Sub Event_Died
   /delay 260s
   /sit
   /delay 10
   /camp desktop
   /delay 40s
/return



sub CheckObst
    /if (${MyXLOC}==${Me.X}) /if (${MyYLOC}==${Me.Y}) {
        /echo STUCK!!!
        /call HitObst 1
    }
    /varset MyXLOC ${Me.X}
    /varset MyYLOC ${Me.Y}
/return

sub HitObst
   /keypress up
   /keypress down hold
   /if (${Math.Rand[99]}>50) {

      /delay 2
      /keypress down
      /keypress Right hold
      /delay 2
      /delay ${Param0}
      /keypress Right
   } else {
      /delay 2
      /keypress down
      /keypress Left hold
      /delay 2
      /delay ${Param0}
      /keypress Left
   }
   /keypress down
   /keypress Right
   /keypress Left
   /keypress up
   /keypress num_lock
/return

Posted: Sun Aug 15, 2004 11:08 pm
by Sparr
i got one word for you.

testcase
All times are UTC-05:00
Page 1 of 1
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/