MacroQuest64

Code: Select all

   /if (${Me.Class.Name.Equal[Shadow Knight]}) /if (${Target.ID}==${MobID}) /if (!${Me.Casting.ID}) /if (${Target.Distance}<=${MeleeDistance}) /goto :attackSpellsSK 
  /goto :attackMeleeLoop 

  :attackSpellsSK 

 
|    /if (${Me.SpellReady["Zevfeer's Bite"]}) /if (${Me.PctMana}>20) /if (${Target.PctHPs}<97) /echo Spell RDY
     /if (${Me.SpellReady["Zevfeer's Bite"]}) /if (${Me.PctMana}>20) /if (${Target.PctHPs}<97) /call cast "Zevfeer's Bite" 
|    /if (${Me.SpellReady[Aura of Hate]}) /if (${Me.PctMana}>20) /if (${Target.PctHPs}<96) /call cast "Aura of Hate" 
|    /if (${Me.SpellReady[Spear of Decay]}) /if (${Me.PctMana}>20) /if (${Target.PctHPs}<95) /call cast "Spear of Decay"
|    /if (${Me.SpellReady[Spear of Plague]}) /if (${Me.PctMana}>20) /if (${Target.PctHPs}<95) /call cast "Spear of Plague" 
|    /if (${Me.SpellReady[Bond of Death]}) /if (${Me.PctHPs}<90)  /if (${Me.PctMana}>20) /if (${Target.PctHPs}<90) /call cast "Bond of Death" 
  /goto :attackMeleeLoop 

Code: Select all

| spell_routines.inc
|
| Written by Rusty~
| Last Modified 8/12/2004
|
| *Note: this will no longer cast AA abilities, until the AA ability struct is fixed (which i hope they havent given up on)
|
| Features:
| - Casts spells, clicks items, or uses AA abilities for you
| - Allows back to back casting without waiting on spell gems to pop all the way up
| - Will interrupt spell if target dies while casting. If on a mount, it will dismount and duck if the time left
|   is greater than 7 seconds, else it will move forward a bit to interrupt, then move you back
|    ** IMPORTANT: if you don't want to interrupt a spell while mounted, put this at the top of your macro: **
|    **   /declare noInterrupt int outer 1                                                                  **
| - Allows you to use items in bags. Equips item, clicks it, then returns it to its previous location
| - Lets you set how long you want to keep trying to cast the spell (defaults to 0)
|   If the spell is interrupted before the given time, it will recast, else it will return CAST_INTERRUPTED
| - Lets you call a custom subroutine while waiting for spell to finish casting
|   Try to keep custom subroutines very small. A common use would be to interrupt the spell if a certain condition is true
| - This file also includes a sub named Interrupt. You can call this to interrupt any spell you're casting instantly.
| - You can also use the SwapItem sub included in this to swap items to certain slots
| - Note: if you don't want this to cast spells while you're invis, in your main macro have this at the top:
|      /declare noInvis int outer 1
|   This will wait till invis is off to cast the spell
|
|======================================================================================================================
|  SwapItem:  a subroutine which is used in the Cast sub itself. You don't need to do this to cast an item in a bag
|             but you can call it in your macro to SwapItems (such as weapons or focus items)
|    Usage:   
|        /call SwapItem "item name" slotname|slotID
|    Examples:
|   
|    To swap Darkblade of the Warlord to your main hand:
|        /call SwapItem "Darkblade of the Warlord" mainhand
|
|    To swap stat food in one bag with other food in another bag:
|        /call SwapItem "Bristlebanes Party Platter" ${FindItem[halas 10lb meat pie].InvSlot}
|
|======================================================================================================================
|  Cast: the main subroutine that casts spells or items for you|
|     Usage:
|        /call Cast "spellname|itemname|AAname|AA#" [item|alt|gem#] [give up time][s|m] [custom subroutine name]
|     Examples:
|
|     To cast Howl of Tashan and mem it in slot 3 if not memmed:
|       /call Cast "Howl of Tashan" gem3
|
|     To cast Arcane Rune and keep trying for 7 seconds, in case of interrupts.
|       /call Cast "Arcane Rune" gem5 7s
|
|     To click Grim Aura earring that's in a bag:
|       /call Cast "Shrunken Goblin Skull Earring" item
|
|     To use AA ability Eldritch Rune:
|       /call Cast "Eldritch Rune" alt
|         or
|       /call Cast "173" alt
|
|     To call a subroutine that interrupts CH if target gets healed before it lands:
|       /call Cast "Complete Healing" gem1 0 CheckHP
|     Then in your macro have somewhere:
|       Sub CheckHP
|          /if ( ${Target.PctHPs}>=80 ) /call Interrupt
|       /return
|
| Returns these values:
|----------------------+----------------------------------------------------------------------+
| CAST_CANCELLED       | Spell was cancelled by ducking (either manually or because mob died) |
| CAST_CANNOTSEE       | You can't see your target                                            |
| CAST_IMMUNE          | Target is immune to this spell                                       |
| CAST_INTERRUPTED     | Casting was interrupted and exceeded the given time limit            |
| CAST_NOTARGET        | You don't have a target selected for this spell                      |
| CAST_NOTMEMMED       | Spell is not memmed and you gem to mem was not specified             |
| CAST_NOTREADY        | AA ability or spell is not ready yet                                 |
| CAST_OUTOFMANA       | You don't have enough mana for this spell!                           |
| CAST_OUTOFRANGE      | Target is out of range                                               |
| CAST_RESISTED        | Your spell was resisted!                                             |
| CAST_SUCCESS         | Your spell was cast successfully! (yay)                              |
| CAST_UNKNOWNSPELL    | Spell/Item/Ability was not found                                     |
|----------------------+----------------------------------------------------------------------+

#event BeginCast "You begin casting#*#"
#event Collapse "Your gate is too unstable, and collapses.#*#"
#event Fizzle "Your spell fizzles#*#"
#event Immune "Your target is immune to changes in its attack speed#*#"
#event Immune "Your target is immune to changes in its run speed#*#"
#event Immune "Your target cannot be mesmerized#*#"
#event Interrupt "Your casting has been interrupted#*#"
#event Interrupt "Your spell is interrupted#*#"
#event NoLOS "You cannot see your target.#*#"
#event NoTarget "You must first select a target for this spell!#*#"
#event NotReady "Spell recast time not yet met.#*#"
#event OutOfMana "Insufficient Mana to cast this spell!#*#"
#event OutOfRange "Your target is out of range, get closer!#*#"
#event Recover "You haven't recovered yet...#*#"
#event Recover "Spell recovery time not yet met#*#"
#event Resisted "Your target resisted the #*#"
#event Standing "You must be standing to cast a spell#*#"
#event Stunned "You are stunned#*#"
#event Stunned "You cannot cast while stunned#*#"
#event Stunned "You *CANNOT* cast spells, you have been silenced!#*#"


Sub Cast(string spellName,string spellType,timer giveUpTimer,string mySub)
   /if ( ${Me.Invis} && ${noInvis} ) /echo You're invis... waiting to cast
:wait_for_stop
   /if ( ${Me.Casting.ID} || ( ${Me.Invis} && ${noInvis} ) ) {
      /delay 1
      /goto :wait_for_stop
   } 
   /if ( ${Me.Speed} ) {
   :wait_for_stop2
      /delay 1
      /if ( ${Me.Moving} ) /goto :wait_for_stop2
   }
   /if ( !${Defined[giveUpTimer]} ) /declare giveUpTimer timer local 0
   /if ( !${Defined[spellRecastTime1]} ) {
      /if ( !${Defined[noInterrupt]} ) /declare noInterrupt int outer 0
      /declare lastSpell string outer
      /declare refreshTime timer outer 0
      /declare itemRefreshTime float outer 0
      /declare i int local
      /declare castReturn string outer
      /delay 5
      /for i 1 to 8
         /declare spellRecastTime${i} timer outer
         /if ( ${Me.SpellReady[${i}]} ) {
            /varset spellRecastTime${i} 0
         } else {
            /varcalc spellRecastTime${i} 10*${Me.Gem[${i}].RecastTime}
         }
      /next i
   }
   /declare currentTarget int local
   /declare currentTargetType string local
   /declare swapItemBack bool local false
   /declare delayTime timer local
   /declare castEndTime timer local
   /declare moveBack bool local
   /if ( !${Defined[spellType]} ) /declare spellType string local spell
   /if ( ( ${spellType.Equal[spell]} || ${spellType.Left[3].Equal[gem]} ) && !${Int[${Me.Book[${spellName}]}]} ) {
      /echo Spell: "${spellName}" was not found in your book
      /return CAST_UNKNOWNSPELL
   }
   /if ( ${spellType.Equal[spell]} || ${spellType.Left[3].Equal[gem]} ) {
      /if ( !${Me.Gem[${spellName}]} ) {
         /if ( ${spellType.Left[3].Equal[gem]} ) {
            /memspell ${spellType.Right[1]} "${spellName}"
         } else {
            /return CAST_NOTMEMMED
         }
         /delay 6s ${Me.Gem[${spellName}]}
         /if ( !${Me.Gem[${spellName}]} ) {
            /echo Spell mem interrupted...
            /return CAST_INTERRUPTED
         }
         :wait_for_mem
         /delay 15s ${Me.SpellReady[${spellName}]}
         /if ( !${Me.SpellReady[${spellName}]} ) {
            /if ( ${giveUpTimer} ) /goto :wait_for_mem
            /return CAST_NOTREADY
         }
      }
      /varset spellType spell
   }
   /if ( ${spellName.Find[illusion: ]} ) /alt activate 217 | && ${Me.AltAbility[project illusion]} ) /call Cast "project illusion" "alt"
   /declare slotName int local
   /declare slotID int local
   /declare oldSlotID int local
   /declare oldItemName string local
:clear_events
   /if ( ${Me.SpellReady[${spellName}]} ) /varset spellRecastTime${Me.Gem[${spellName}]} 0
   /call ClearReturn
   /doevents Recover
   /doevents BeginCast
   /doevents Fizzle
   /doevents Interrupt
   /doevents Standing
   /doevents OutOfRange
   /doevents OutOfMana
   /doevents NoLOS
   /doevents Resisted
   /doevents Immune
   /doevents Stunned
   /doevents Collapse
   /doevents NoTarget
   /doevents NotReady
   /if ( !${castReturn.Equal[CAST_SUCCESS]} ) {
      /delay 1
      /goto :clear_events
   }
   /varset giveUpTimer ${giveUpTimer.OriginalValue}
   /declare recoverWaitTime timer local 30
:cast_loop
   /if ( ${Me.Ducking} ) /keypress duck
   /if ( !${Me.Standing} ) /stand
   /if ( ${spellType.Equal[item]} ) {
      /if ( !${FindItem[${spellName}].InvSlot} ) {
         /echo Cannot find item: ${spellName}
         /return CAST_UNKNOWNSPELL
      }     
      /if ( ${FindItem[${spellName}].InvSlot}>29 ) {
         /varset swapItemBack true
         /if ( ${FindItem[${spellName}].WornSlot[1]} ) {
            /varset slotName ${FindItem[${spellName}].WornSlot[1]}
         } else {
            /varset slotName pack8
         }
         /varset slotID ${InvSlot[${slotName}].ID}
         /varset oldSlotID ${FindItem[${spellName}].InvSlot.ID}
         /varset oldItemName ${InvSlot[${slotID}].Item.Name}
         /call SwapItem "${spellName}" ${slotID}
      }
      /varset itemRefreshTime ${Math.Calc[${MacroQuest.Running}+200]}
      /echo Casting: ${FindItem[${spellName}].Spell.Name}${If[!${FindItem[${spellName}].Spell.TargetType.Equal[PB AE]} && !${FindItem[${spellName}].Spell.TargetType.Equal[self]} && ${Target.ID}, on >> ${Target.CleanName} <<,]}
      /cast item "${spellName}"
   } else /if ( ${spellType.Equal[spell]} ) {
   :wait_for_spell
      /if ( ${spellRecastTime${Me.Gem[${spellName}]}} ) {
         /if ( !${giveUpTimer} ) /return CAST_NOTREADY
         /delay 1
         /goto :wait_for_spell
      }
      /if ( !${refreshTime} ) /goto :skip_delay
   :wait_on_refresh
      /if ( ${refreshTime}>0 ) {
         /delay 1
         /goto :wait_on_refresh
      }
      /varcalc delayTime 10*(1.5-${Spell[${spellName}].MyCastTime})
   :cast_delay_loop
      /if ( ${delayTime}>0 ) {
         /delay 1
         /goto :cast_delay_loop
      }
   :skip_delay
      /cast "${spellName}"
   } else {
      /if ( !${Me.AltAbilityReady[${spellName}]} ) /return CAST_NOTREADY
      /varset itemRefreshTime ${Math.Calc[${MacroQuest.Running}+200]}
      /echo Using AA Ability: ${AltAbility[${spellName}].Name}
      /alt activate ${AltAbility[${spellName}].ID}
   }
   /if ( ${Me.Casting.ID} ) {
      /varcalc castEndTime ${Me.Casting.MyCastTime}*10
      /if ( ${spellType.Equal[spell]} ) /echo Casting: ${Me.Casting.Name}${If[!${Me.Casting.TargetType.Equal[PB AE]} && !${Me.Casting.TargetType.Equal[self]} && ${Target.ID}, on >> ${Target.CleanName} <<,]}
   }
   /varset currentTarget ${Target.ID}
   /varset currentTargetType ${Target.Type}
   /varset moveBack false
:wait_cast_loop
   /if ( ${Defined[mySub]} ) /call ${mySub}
   /if ( ${Me.Casting.ID} ) {
      /if ( ${currentTarget} && !${Spawn[${currentTarget}].Type.Equal[${currentTargetType}]} ) {
         /if ( !${Me.Casting.TargetType.Equal[PB AE]} && !${Me.Casting.TargetType.Equal[self]} && !${moveBack} && ( !${Me.Mount.ID} || !${noInterrupt} ) ) {
            /if ( !${Me.Mount.ID} || ${castEndTime}>70 ) {
               /call Interrupt
            } else /if ( ${Me.Casting.RecastTime}>3 && ${spellType.Equal[spell]} ) {
               /keypress forward hold
               /delay 6
               /keypress forward
               /varset moveBack true
               /varset castReturn CAST_CANCELLED
            }
         }
      }
      /if ( ${Me.State.Equal[DUCK]} ) /varset castReturn CAST_CANCELLED
      /delay 1
      /goto :wait_cast_loop
   }
   /if ( ${moveBack} ) {
      /keypress back hold
      /delay 6
      /keypress back
      /delay 15 !${Me.Moving}
   }
   /if ( ${swapItemBack} ) {
      /if ( ${FindItem[${oldItemName}].ID} ) {
         /call SwapItem "${oldItemName}" ${slotID}         
      } else /if ( ${FindItem[${spellName}].ID} ) {
         /call SwapItem "${spellName}" ${oldSlotID}
      }
   }
   /if ( ${castReturn.Equal[CAST_CANCELLED]} ) {
      /echo Spell was cancelled...
      /return CAST_CANCELLED
   }
   /call ClearReturn
   /doevents Recover
   /doevents BeginCast
   /doevents Fizzle
   /doevents Interrupt
   /doevents Standing
   /doevents OutOfRange
   /doevents OutOfMana
   /doevents NoLOS
   /doevents Resisted
   /doevents Immune
   /doevents Stunned
   /doevents Collapse
   /doevents NoTarget
   /doevents NotReady

   /if ( !${castReturn.Equal[CAST_SUCCESS]} ) {
      /if ( ${castReturn.Equal[CAST_NOTREADY]} ) /return CAST_NOTREADY
      /if ( ${castReturn.Equal[CAST_FIZZLE]} ) {
         /echo Spell Fizzled. Recasting...
         /goto :cast_loop
      }
      /if ( ${castReturn.Equal[CAST_RECOVER]} && ${spellType.Equal[spell]} ) {
         /if ( !${recoverWaitTime} ) {
            /varcalc spellRecastTime${Me.Gem[${spellName}]} 10*${Spell[${spellName}].RecastTime}
            /if ( !${giveUpTimer} ) /return CAST_NOTREADY
         }
         /goto :cast_loop
      }
      /if ( ${castReturn.Equal[CAST_RESTART]} ) /goto :cast_loop
      /if ( ${castReturn.Equal[CAST_STUNNED]} ) {
         /if ( ${Me.Stunned} ) {
            /delay 3s !${Me.Stunned}
         } else {
            /delay 7
         }
         /goto :cast_loop
      }
      /if ( ${castReturn.Equal[CAST_INTERRUPTED]} ) {
         /if ( ${giveUpTimer} ) {
            /echo Spell was interrupted. Recasting...
            /goto :cast_loop
         }
         /echo Spell was interrupted...
         /return CAST_INTERRUPTED
      }
   }
   /if ( ${spellType.Equal[spell]} ) {
      /varset lastSpell ${spellName}
      /if ( !${castReturn.Equal[CAST_CANNOTSEE]} && !${castReturn.Equal[CAST_OUTOFRANGE]} && !${castReturn.Equal[CAST_OUTOFMANA]} && !${castReturn.Equal[CAST_NOTARGET]} ) {
         /varcalc refreshTime 10*${Spell[${spellName}].RecoveryTime}
         /varcalc spellRecastTime${Me.Gem[${spellName}]} 10*${Spell[${spellName}].RecastTime}
      }
   } else {
      /varset lastSpell ${spellType}
   :wait_item_loop
      /if ( ${itemRefreshTime} > ${MacroQuest.Running} ) {
         /delay 1
         /goto :wait_item_loop
      }
   }
   /if ( ${castReturn.Equal[CAST_COLLAPSE]} ) {
      /varset giveUpTimer 200
      /goto :cast_loop
   }
   /return ${castReturn}

Sub SwapItem(string itemName,string slotName)
   /if ( ${Me.Inventory[${slotName}].Name.Equal[${itemName}]} ) /return
   /declare slotID int local
   /declare oldSlotID int local
   /declare oldItem string local
   /varset slotID ${InvSlot[${slotName}].ID}       | slotID = slot you're swapping item to
   /varset oldSlotID ${FindItem[${itemName}].InvSlot.ID} | oldSlotID = slot the item was originally in
   /varset oldItem ${InvSlot[${slotName}].Item.Name}     | oldItem = name of item in the slot you're swapping to
   /if ( !${slotID} ) {
      /echo Invalid slot name: ${slotName}
      /return
   }
   /if ( !${oldSlotID} ) {
      /echo Could not find item ${itemName}
      /return
   }
:auto_inv
   /if ( ${Cursor.ID} && !${Cursor.Container} ) {
      /autoinventory
      /goto :auto_inv
   }

:pick_up_item
 | if the item is in a bag and it's not open, then open it!
   /if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup

 | if the slot you're putting it in is inside a bag and it's not open, then open it!
   /if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup

 | ok.. pick up the item now!
   /squelch /nomodkey /shiftkey /itemnotify ${InvSlot[${oldSlotID}]} leftmouseup

 | if item isn't on your cursor, try again!
   /if ( !${Cursor.Name.Equal[${itemName}]} && ${FindItem[${itemName}].ID} ) /goto :pick_up_item

:exchange_items
   /if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup
   /if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup

 | put the item in the new slot, and pick up whatever item was there
   /squelch /nomodkey /shiftkey /itemnotify ${slotID} leftmouseup

 | if it didnt get exchanged, try again!
   /if ( !${InvSlot[${slotID}].Item.Name.Equal[${itemName}]} && ${Cursor.Name.Equal[${itemName}]} ) /goto :exchange_items
:drop_item
   /if ( !${Cursor.Container} || ( ${InvSlot[${oldSlotID}]}<30 && ${InvSlot[${oldSlotID}]}>=22 ) ) {
      /if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup
      /if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup
      /squelch /nomodkey /itemnotify ${oldSlotID} leftmouseup
      /if ( ${Cursor.ID} ) {
         /if ( !${Cursor.Name.Equal[${oldItem}]} && !${Cursor.Container} ) /autoinventory
         /goto :drop_item
      }
   }
:close_pack
   /if ( ${InvSlot[${oldSlotID}].Pack} && ${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} && ( ${Cursor.Name.Equal[${itemName}]} || ${FindItem[${itemName}].ID} ) ) {
      /squelch /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup
      /goto :close_pack
   }
   /if ( ${InvSlot[${slotID}].Pack} && ${Window[${InvSlot[${slotID}].Pack.Name}].Open} && ( ${Cursor.Name.Equal[${itemName}]} || ${FindItem[${itemName}].ID} ) ) {
      /squelch /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup
      /goto :close_pack
   }
/return

Sub Interrupt
   /if ( ${Me.Mount.ID} ) /dismount
   /if ( !${Me.Ducking} ) {
      /keypress duck
      /keypress duck
   }
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_CANCELLED
/return ${Macro.Return}

Sub ClearReturn
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_SUCCESS
/return

Sub Event_Fizzle
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_FIZZLE
/return

Sub Event_Resisted
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_RESISTED
/return

Sub Event_Interrupt
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_INTERRUPTED
/return

Sub Event_Recover
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_RECOVER
/return

Sub Event_Immune
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_IMMUNE
/return

Sub Event_Stunned
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_STUNNED
/return

Sub Event_NoLOS
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_CANNOTSEE
/return

Sub Event_Standing
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_RESTART
/return

Sub Event_Collapse
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_COLLAPSE
/return

Sub Event_OutOfMana
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_OUTOFMANA
/return

Sub Event_OutOfRange
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_OUTOFRANGE
/return

Sub Event_NoTarget
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_NOTARGET
/return

Sub Event_NotReady
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_NOTREADY
/return

Sub Event_BeginCast
   /if ( ${Defined[castReturn]} ) /varset castReturn CAST_SUCCESS
/return

Code: Select all

First-chance exception in eqgame.exe (MQ2MAIN.DLL): 0xC0000005: Access Violation.
The thread 0x2A8 has exited with code 0 (0x0).
The thread 0x2AC has exited with code 0 (0x0).
The thread 0x1E4 has exited with code 0 (0x0).
The thread 0x574 has exited with code 0 (0x0).
The thread 0xCB8 has exited with code 0 (0x0).
The thread 0xCBC has exited with code 0 (0x0).
The thread 0xD5C has exited with code 0 (0x0).
The thread 0x234 has exited with code 0 (0x0).
The thread 0x2D0 has exited with code 0 (0x0).
The thread 0x39C has exited with code 0 (0x0).
The thread 0x2B4 has exited with code 0 (0x0).

Code: Select all

0012ae8c 012e63d2 06ac62c0 0012b6f7 0012aec8 MQ2Main!MQ2CharacterType::GetMember+0xd7a (FPO: [EBP 0x0012b6ec] [4,2,4]) (CONV: thiscall) [E:\MQ\MQ2Main\MQ2DataTypes.cpp @ 1734]