Aion AutoIt Bot Beta [Open Source]

NewbieDie · 11/02/2009, 19:37

Hallo Erstmal

Ich benutze 10.0 Planys version weil Chefes irgendwie nicht funzt.

So noch paar fragen ersten in was muss man die Zeit eingeben in Milisekunden oder in Sekunden ?!? und bei mir funzt irgendwie die Chainskills nicht obwohl ich DA nen Häckchen habe

spiele nen Sorc irgendwer ne Idee?
Dann kommt noch dazu das er sich ziemlich lange zeit lässt zwischen den Casts also ich sag mal bestimmt 1-4sekunden.

MfG

Chai · 11/02/2009, 19:42

Casttime in MS und die CD in Sekunden.

damaged · 11/02/2009, 20:02

Hey,

jo planys versionen sind sehr gut, die anderen haben gute ansaetze aber sehr maessige umsetzung. wenn ich mir den source anschau krieg ichs grauen.

danke allerdings fuer den rangecheck()

gerade eben versuche ich eine FleeCheck() funktion zu schreiben, mit range krieg ichs leidern nicht hin da der char immer hinterherlaeuft.

allerdings koennte ichs mit der ausrichtung bestimmten, haben sie den rücken zu mir fliehen sie.

leider stell ich mich grad total an wenns darum geht die funktion zum lesen der rotation/ausrichtung zu schreiben.
waer kewl wenn mir jemand unter die arme greift.

hier der link mit den offsets, interessand ist das target heading/rotation:

danke schonmal

NewbieDie · 11/02/2009, 20:09

Hmm ok das ist ja schonmal was danke Chai stellt sich mir noch die Frage warum führt er den Chain Skill nicht aus von Eiskette... und kann ich irgendwie einstellen das er alle 30min nen buff durchführt.

MfG

edit: und ja mir stellt sich auch noch die frage warum er nicht immer beim neuen mob bei Attack 1 anfängt sondern manchmal attack 2 oder 4 wie er gerade lustig ist ^^

Calcifer · 11/02/2009, 20:15

Quote:

Originally Posted by Honola

steht für die kettenfähigkeit die was direkt danach benutzt wird.
warum er es d.a genannt hat ist eine gute frage..a für attack aber das d..grübel^^

das geht irgdnewie nicht bei mir.
auch wenn ich den hacken rien mache macht er keine doppelattake

Chai · 11/02/2009, 20:51

Quote:

Originally Posted by NewbieDie

Hmm ok das ist ja schonmal was danke Chai stellt sich mir noch die Frage warum führt er den Chain Skill nicht aus von Eiskette... und kann ich irgendwie einstellen das er alle 30min nen buff durchführt.

MfG

edit: und ja mir stellt sich auch noch die frage warum er nicht immer beim neuen mob bei Attack 1 anfängt sondern manchmal attack 2 oder 4 wie er gerade lustig ist ^^

Probier mal bei Eiskette 3500ms bis 3700 ms das muss man etwas rumfummeln.

Rumpel · 11/02/2009, 20:59

kann mich mal einer auklären? ich habe ein mage und blick das mit den zeiteinstellungen mal gar nicht. Wäre für Hilfe dankbar!!

Chai · 11/02/2009, 21:26

damaged · 11/02/2009, 22:03

so ich klapp fast um, muss mal schlafen ^^

also zu erklaerung:
ich farm die verdammten voegel die wegrennen, dabei adde ich und verrecke als sin.

das gilt es zu vermeiden:
entweder ich merke wenn sie fliehen an ihrer rotation
oder sobald ich mich X meter von meinem letzten waypoint entferne exitloop und add mit zum wp ziehen.

ka irgendsowas... leider kann verreckt der bot mit der momentanen version spaetesten alle 2h.

gute nacht.

unknown661 · 11/02/2009, 22:35

so ich meld mich auch wieder mal^^ hab in letzter zeit 0 zeit zum coden, hab nicht mal zeit den bot laufen zu lassen mein char gammelt noch immer auf 22 rum. aber echt nice wie sich das projekt weiterentwickelt hat. gogogo weiterso =) hoffe ich kann bald wieder mehr zeit investieren!

btw hab heute fanpost bekommen xD

Quote:

Originally Posted by Dante66666

Soso, du dummes *********, Bots versauen den anderen Spielern den Spass, wenn du zu Dumm bist normal zu Spielen oder mit was anständiges zu programmieren tust du mir leid... fahr zur Hölle

YMMD!

SayuriInuzuka · 11/03/2009, 01:19

Bei mir geht der WD Point nicht festzulegen,habe nen Laptop und 2 Plustasten und beide gehen nicht =(

IMMER 0-0-0

Grearson · 11/03/2009, 03:50

hm ggf bei der Lap Tastatur <Function> und + ? brauchst halt das Numpad plus, und das oft bei kleineren lappys über ne doppelte Tastenbelegung gelöst, ansonsten guck mal obdie Numlock taste an ist.

chefes78 · 11/03/2009, 06:50

Quote:

Originally Posted by SayuriInuzuka

Bei mir geht der WD Point nicht festzulegen,habe nen Laptop und 2 Plustasten und beide gehen nicht =(

IMMER 0-0-0

geht auch manuell über den Add WP Button (click für jeden WP..)

PS:

ich muss nur noch die "attack ready" richtig auslesen dann funzt 10.6... sollte heue
Abend so weit sein...

falls jemand zeit hat...

Code:

#AutoIT3Wrapper_UseUpx=n
#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_outfile=AutoAion_beta_010.exe
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****

#include <Array.au3>
#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>
#include <GuiConstants.au3>
#Include <file.au3>
#include <NoMadMemory.au3>

GuiCreate("AutoAion v0.10.10 Beta ", 270,600, 0, 0, -1, $WS_EX_TOPMOST)                          	;;;: Quickfix Nr. 3  - Added by Chefes78 - 28.10.2009 (Makes the Gui top most window (without focus ... ) ... like this you can see what the bot is doing (Tooltips... )
GUICtrlCreatePic("logo.jpg", 0, 536, 270, 74)
GUISetBkColor(0xffffff)
GUISetState(@SW_SHOW)
GuiCtrlSetState(-1,$GUI_DISABLE)


HotKeySet("{F5}","stop")
HotKeySet("{F7}","outahere")
HotKeySet("{F8}","allup")
HotKeySet("{NUMPADADD}","_keyboardToWpInterface")
;~ Global $avArray = StringSplit("$EN1,$EN2,$EN3,$EN4,$EN5,$EN6,$EN7,$EN8,$EN9,$EN10", ",")

Global $alive
global $attackdistmax
Global $attackdistmin
global $abstand1
Global $looted
global $atck
Global $loopcounter = 0
global $abstand
Global $configFile = "AA.conf"
Global $Run = False
Global $enemyKillCount = 0
Global $enemyEpCount = 0
Global $playerEnergy
Global $playerEnergyMax
Global $playerHP
Global $playerHPMax
Global $playerEP
Global $playerEPMax
Global $targetHPpercent
Global $AionRun = False
Global $pid = 0
Global $openmem = 0
Global $baseADDR = 0
Global $finalADDR = 0
Global $wpField[1000]
Global $count =1
Global $countMax=0
global $pi = 3.14159265358979323846264338327950
global $file1 = "data.txt"
global $attack1 = "x"
global $attack2 = "x"
global $attack3 = "x"
global $attack4 = "x"
global $attack5 = "x"
global $attack6 = "x"
global $attack7 = "x"
global $attackgk = "1"
Global $attackgd = "5"
global $attackgdm = "15"
global $attack8 = "x"
global $loot = "x"
global $reg = "x"
Global $i =0
global $attack1c = "0"
global $attack2c = "0"
global $attack3c = "0"
global $attack4c = "0"
global $attack5c = "0"
global $attack6c = "0"
global $attack7c = "0"
global $attack8c = "0"

global $attack1Cd = "0"
global $attack2Cd = "0"
global $attack3Cd = "0"
global $attack4Cd = "0"
global $attack5Cd = "0"
global $attack6Cd = "0"
global $attack7Cd = "0"
global $attack8Cd = "0"

global $attack1LastCast = "0"
global $attack2LastCast = "0"
global $attack3LastCast = "0"
global $attack4LastCast = "0"
global $attack5LastCast = "0"
global $attack6LastCast = "0"
global $attack7LastCast = "0"
global $attack8LastCast = "0"

;~ global $attack1LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack2LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack3LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack4LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack5LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack6LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack7LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack8LastCast = _TimeGetStamp() - $attack1Cooldown

;~ Global $attack1LastCast =  _TimeGetStamp() - $attack1Cooldown


;~ global $attack1LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack2LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack3LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack5LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack6LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack7LastCast = _TimeGetStamp() - $attack1Cooldown
;~ global $attack8LastCast = _TimeGetStamp() - $attack1Cooldown


global $killCount
global $status
global $TimeCount
global $jumper = 0

global $attack1_da
global $attack2_da
global $attack3_da
global $attack4_da
global $attack5_da
global $attack6_da


global $attack1mm_da
global $attack2mm_da
global $attack3mm_da
global $attack4mm_da
global $attack5mm_da
global $attack6mm_da

global $attack8hp = 85
global $reg_minLife = 40
global $reg_minMana = 10

global $timeDiff = 0;
global $lastTime = 0;
global $newTime = 0;
global $avgTime = 0;

global $rot_down = "a down"
global $rot_up = "a up"

Global $timeToShutdownOutput
Global $sdtimerInput
Global $timeToShutdown = 0
Global $timeCache = 0

Global $combatStartTimer = 0
Global $combatAnimaLibera = 0
Global $goodCombat = 0
Global $combatFlag = 0
Global $lastBlackListEnemy = 0


; THE FUTURE!
Global $confVar1
Global $confVar2
Global $confVar3
Global $confVar4
Global $confVar5
Global $confVar6
Global $confVar7
Global $confVar8
Global $confVar9
Global $confVar10
Global $confVar11
Global $confVar12
Global $confVar13
Global $confVar14
Global $confVar15
Global $confVar16
Global $confVar17
Global $confVar18
Global $confVar19
Global $confVar20
Global $confVar21
Global $confVar22
Global $confVar23
Global $confVar24
Global $confVar25
Global $confVar26
Global $confVar27
Global $confVar28
Global $confVar29
Global $confVar30
Global $confVar31
Global $confVar32
Global $confVar33
Global $confVar34
Global $confVar35
Global $confVar36
Global $confVar37
Global $confVar38
Global $confVar39
Global $confVar40
Global $confVar41
Global $confVar42
Global $confVar43
Global $confVar44
Global $confVar45
Global $confVar46
Global $confVar47



$attack1_da = GUICtrlCreateCheckbox("DA", 195, 30, 35, 20)
$attack2_da = GUICtrlCreateCheckbox("DA",195, 60, 35, 20)
$attack3_da = GUICtrlCreateCheckbox("DA", 195, 90, 35, 20)
$attack4_da = GUICtrlCreateCheckbox("DA", 195, 180, 35, 20)
$attack5_da = GUICtrlCreateCheckbox("DA", 195, 120, 35, 20)
$attack6_da = GUICtrlCreateCheckbox("DA", 195, 150, 35, 20)

$attacklmm_da = GUICtrlCreateLabel(" - Max -",    230, 183, 50, 20)
$attacklmm_da = GUICtrlCreateLabel("Distance",225, 5 , 50, 20)

$attack1mm_da = GUICtrlCreateCheckbox("Max", 230, 30, 50, 20)
$attack2mm_da = GUICtrlCreateCheckbox("Max", 230, 60, 50, 20)
$attack3mm_da = GUICtrlCreateCheckbox("Max", 230, 90, 50, 20)
$attack4mm_da = GUICtrlCreateCheckbox("Max", 230, 120, 50, 20)
$attack5mm_da = GUICtrlCreateCheckbox("Max", 230, 150, 50, 20)

;~ $attack1mm_da = GUICtrlCreateCheckbox("Mx.", 235, 30, 50, 20)

readKeys()

$Label1 = GUICtrlCreateLabel("Key", 65, 10, 60, 17)
$Label1 = GUICtrlCreateLabel("Casttime", 100, 10, 60, 17)
$Label1 = GUICtrlCreateLabel("Cooldown", 150, 10, 60, 17)

$Label1 = GUICtrlCreateLabel("Kill Count:", 150, 270, 60, 17)
$killCount = GUICtrlCreateLabel($enemyKillCount, 200, 270, 100, 17)
$Label1 = GUICtrlCreateLabel("EP Count:", 150, 290, 60, 17)
$epCount = GUICtrlCreateLabel($enemyEpCount, 200, 290, 100, 17)
$Label1 = GUICtrlCreateLabel("Lvl-up in:", 150, 310, 60, 17)
$TimeCount = GUICtrlCreateLabel($avgTime, 200, 310, 100, 17)
$Label1 = GUICtrlCreateLabel("Shutdown:", 150, 330, 60, 17)
$timeToShutdownOutput = GUICtrlCreateLabel("-----", 210, 330, 100, 17)

$Label1 = GUICtrlCreateLabel("Attack 1:", 15, 32, 44, 17)
$attack1Key = GUICtrlCreateInput($attack1, 65, 30, 20, 21)
$attack1Cast = GUICtrlCreateInput($attack1c, 100, 30, 40, 21)
$attack1Cooldown = GUICtrlCreateInput($attack1Cd, 150, 30, 40, 21)

$Label2 = GUICtrlCreateLabel("Attack 2:", 15, 62, 44, 17)
$attack2Key = GUICtrlCreateInput($attack2, 65, 60, 20, 21)
$attack2Cast = GUICtrlCreateInput($attack2c, 100, 60, 40, 21)
$attack2Cooldown = GUICtrlCreateInput($attack2Cd, 150, 60, 40, 21)


$Label3 = GUICtrlCreateLabel("Attack 3:", 15, 92, 44, 17)
$attack3Key = GUICtrlCreateInput($attack3, 65, 90, 20, 21)
$attack3Cast = GUICtrlCreateInput($attack3c, 100, 90, 40, 21)
$attack3Cooldown = GUICtrlCreateInput($attack3Cd, 150, 90, 40, 21)

$Label5 = GUICtrlCreateLabel("Attack 4:", 15, 122, 44, 17)
$attack5Key = GUICtrlCreateInput($attack5, 65, 120, 20, 21)
$attack5Cast = GUICtrlCreateInput($attack5c, 100, 120, 40, 21)
$attack5Cooldown = GUICtrlCreateInput($attack5Cd, 150, 120, 40, 21)

$Label6 = GUICtrlCreateLabel("Attack 5:", 15, 152, 44, 17)
$attack6Key = GUICtrlCreateInput($attack6, 65, 150, 20, 21)
$attack6Cast = GUICtrlCreateInput($attack6c, 100, 150, 40, 21)
$attack6Cooldown = GUICtrlCreateInput($attack6Cd, 150, 150, 40, 21)

$Label4 = GUICtrlCreateLabel("PreCast:", 17, 182, 50, 17)
$attack4Key = GUICtrlCreateInput($attack4, 65, 180, 20, 21)
$attack4Cast = GUICtrlCreateInput($attack4c, 100, 180, 40, 21)
$attack4Cooldown = GUICtrlCreateInput($attack4Cd, 150, 180, 40, 21)

$Label7 = GUICtrlCreateLabel("PostCast:", 14, 212, 50, 17)
$attack7Key = GUICtrlCreateInput($attack7, 65, 210, 20, 21)
$attack7Cast = GUICtrlCreateInput($attack7c, 100, 210, 40, 21)
$attack7Cooldown = GUICtrlCreateInput($attack7Cd, 150, 210, 40, 21)

$Label8 = GUICtrlCreateLabel("Em Cast:", 14, 242, 50, 17)
$attack8Key = GUICtrlCreateInput($attack8, 65, 240, 20, 21)
$attack8Cast = GUICtrlCreateInput($attack8c, 100, 240, 40, 21)
$attack8Cooldown = GUICtrlCreateInput($attack8Cd, 150, 240, 40, 21)
$Label8 = GUICtrlCreateLabel("HP:", 191, 242, 18, 17)
$attack8hitPoint = GUICtrlCreateInput($attack8hp, 210, 240, 20, 21)
$Label8 = GUICtrlCreateLabel("%", 232, 242, 10, 17)


$Label3 = GUICtrlCreateLabel("Loot:", 35, 272, 25, 17)
$lootKey = GUICtrlCreateInput($loot, 65, 270, 20, 21)

$Label3 = GUICtrlCreateLabel("Reg:", 36, 302, 22, 17)
$regKey = GUICtrlCreateInput($reg, 65, 300, 20, 21)
$Label3 = GUICtrlCreateLabel("HP:", 90, 302, 19, 15)
$Label3 = GUICtrlCreateLabel("MA:", 90, 330, 19, 15)
$regMin = GUICtrlCreateInput($reg_minLife, 110, 300, 20, 21)
$regMinMana = GUICtrlCreateInput($reg_minMana, 110, 327, 20, 21)
$Label3 = GUICtrlCreateLabel("%", 130, 302, 10, 17)
$Label3 = GUICtrlCreateLabel("%", 130, 330, 10, 17)

$Label9 = GUICtrlCreateLabel("Key:", 38 ,360, 20, 17)
$Labe20 = GUICtrlCreateLabel("Min distance:", 98,360, 70, 17)
$Labe21 = GUICtrlCreateLabel("Max:", 193 ,360, 23, 17)
$atck = GUICtrlCreateInput($attackgk, 65, 358, 20, 21)
$attackdistmin = GUICtrlCreateInput($attackgd, 165,358, 22, 21)
$attackdistmax = GUICtrlCreateInput($attackgdm, 219 ,358, 27, 21)
GUICtrlCreatePic("attack.jpg", 10, 355 , 25	, 25)




$Label6 = GUICtrlCreateLabel("Filename:", 40,390, 70, 17)
$wpFileInput = GUICtrlCreateInput("", 140, 407, 70, 20)
$Label6 = GUICtrlCreateLabel("Filename:", 150,390, 70, 17)
$wpSaveInput = GUICtrlCreateInput("", 30, 407, 70, 20)
; status field
$status = GUICtrlCreateLabel("Start Bot-Engine... done!"&getCredits(), 5,490, 230, 55)
;buttons
$buttonSave = GuiCtrlCreateButton("Save", 30,460,70,20)
$buttonRun = GuiCtrlCreateButton("Run Bot", 140,460,70,20)
$buttonAddWayPoint = GuiCtrlCreateButton("Add WP", 30,430,70,20)
$buttonOpenWayPoint = GuiCtrlCreateButton("Open WP", 140,430,70,20)


$Label2 = GUICtrlCreateLabel("Timer:", 200, 495, 44, 17)
$sdtimerInput = GUICtrlCreateInput("0", 200, 510, 60, 21)




Func outahere()
	send("{w up}")
	send("{s up}")
	Send("{a up}")
	send("{d up}")
Exit
EndFunc

Func allup()
	WinActivate("AION Client")
	sleep(2000)
	Send("{w up}")
	send("{s up}")
	Send("{a up}")
	send("{d up}")
	Return $run = False
EndFunc

Func stop()
		Send("{w up}")
		send("{s up}")
		Send("{a up}")
		send("{d up}")
;~ 		Return $Run = False
		GUICtrlSetData ($buttonRun,"Finishing Kill")
		sleep(500)
		do
			if ( CheckEnemyDead() = False ) Then

					Sleep(700)
					GUICtrlSetData ($buttonRun,"Killing last")
					sleep(700)
					GUICtrlSetData ($buttonRun,"going Idle")
					if  $run = False Then
							Send("{w up}")
							send("{s up}")
							Send("{a up}")
							send("{d up}")
					ExitLoop
				EndIf
				EndIf
			Until CheckEnemyDead()  = True
			sleep(800)
			GUICtrlSetData ($buttonRun,"Start Bot")
			Return $run = False
	EndFunc


;~ Func stop()
;~ 		Send("{w up}")
;~ 		$Run = False
;~ 		GUICtrlSetData ($buttonRun,"Start Bot")
;~ 	EndFunc





;#################################################
;interface functions
;#################################################
func readKeys()
	if FileExists($file1) Then

	$attack1 = FileReadLine($file1,"1")
	$attack2 = FileReadLine($file1,"2")
	$attack3 = FileReadLine($file1,"3")
	$attack4 = FileReadLine($file1,"14")

	$loot = FileReadLine($file1,"4")
	$reg = FileReadLine($file1,"5")
	$reg_minLife = FileReadLine($file1,"12")
	$reg_minMana = FileReadLine($file1,"13")

	$attack1c = FileReadLine($file1,"6")
	$attack2c = FileReadLine($file1,"7")
	$attack3c = FileReadLine($file1,"8")
	$attack4c = FileReadLine($file1,"15")

	$attack1Cd = FileReadLine($file1,"9")
	$attack2Cd = FileReadLine($file1,"10")
	$attack3Cd = FileReadLine($file1,"11")
	$attack4Cd = FileReadLine($file1,"16")

	if (FileReadLine($file1,"17") == 1) Then
		GUICtrlSetState($attack1_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"18") == 1) Then
		GUICtrlSetState($attack2_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"19") == 1) Then
		GUICtrlSetState($attack3_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"20") == 1) Then
		GUICtrlSetState($attack4_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"21") == 1) Then
		GUICtrlSetState($attack5_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"22") == 1) Then
		GUICtrlSetState($attack6_da,$GUI_CHECKED)
	EndIf

	if (FileReadLine($file1,"39") == 1) Then
		GUICtrlSetState($attack1mm_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"40") == 1) Then
		GUICtrlSetState($attack2mm_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"41") == 1) Then
		GUICtrlSetState($attack3mm_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"42") == 1) Then
		GUICtrlSetState($attack4mm_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"43") == 1) Then
		GUICtrlSetState($attack5mm_da,$GUI_CHECKED)
	EndIf
	if (FileReadLine($file1,"44") == 1) Then
		GUICtrlSetState($attack6mm_da,$GUI_CHECKED)
	EndIf




	$attack5 = FileReadLine($file1,"23")
	$attack5c = FileReadLine($file1,"24")
	$attack5Cd = FileReadLine($file1,"25")
	$attack6 = FileReadLine($file1,"26")
	$attack6c = FileReadLine($file1,"27")
	$attack6Cd = FileReadLine($file1,"28")
	$attack7 = FileReadLine($file1,"29")
	$attack7c = FileReadLine($file1,"30")
	$attack7Cd = FileReadLine($file1,"31")

	$attack8 = FileReadLine($file1,"32")
	$attack8c = FileReadLine($file1,"33")
	$attack8Cd = FileReadLine($file1,"34")
	$attack8hp = FileReadLine($file1,"35")
	$attackgk =  FileReadLine($file1,"36")
	$attackgd = FileReadLine($file1,"37")
	$attackgdm = FileReadLine($file1,"38")


	GUICtrlSetData($status,"Save and Load new Values")
	EndIf
EndFunc



Func saveKeys()
	$readAttack1 = GuiCtrlRead($attack1Key)
	$readAttack2 = GuiCtrlRead($attack2Key)
	$readAttack3 = GuiCtrlRead($attack3Key)
	$readAttack4 = GuiCtrlRead($attack4Key)
	$readAttack5 = GuiCtrlRead($attack5Key)
	$readAttack6 = GuiCtrlRead($attack6Key)
	$readAttack7 = GuiCtrlRead($attack7Key)
	$readAttack8 = GuiCtrlRead($attack8Key)

	$readAttack1cast = GuiCtrlRead($attack1Cast)
	$readAttack2cast = GuiCtrlRead($attack2Cast)
	$readAttack3cast = GuiCtrlRead($attack3Cast)
	$readAttack4cast = GuiCtrlRead($attack4Cast)
	$readAttack5cast = GuiCtrlRead($attack5Cast)
	$readAttack6cast = GuiCtrlRead($attack6Cast)
	$readAttack7cast = GuiCtrlRead($attack7Cast)
	$readAttack8cast = GuiCtrlRead($attack8Cast)

	$readAttack1cd = GuiCtrlRead($attack1Cooldown)
	$readAttack2cd = GuiCtrlRead($attack2Cooldown)
	$readAttack3cd = GuiCtrlRead($attack3Cooldown)
	$readAttack4cd = GuiCtrlRead($attack4Cooldown)
	$readAttack5cd = GuiCtrlRead($attack5Cooldown)
	$readAttack6cd = GuiCtrlRead($attack6Cooldown)
	$readAttack7cd = GuiCtrlRead($attack7Cooldown)
	$readAttack8cd = GuiCtrlRead($attack8Cooldown)

	$readAttack1da = GuiCtrlRead($attack1_da)
	$readAttack2da = GuiCtrlRead($attack2_da)
	$readAttack3da = GuiCtrlRead($attack3_da)
	$readAttack4da = GuiCtrlRead($attack4_da)
	$readAttack5da = GuiCtrlRead($attack5_da)
	$readAttack6da = GuiCtrlRead($attack6_da)

	$readAttack1mm = GuiCtrlRead($attack1mm_da)
	$readAttack2mm = GuiCtrlRead($attack2mm_da)
	$readAttack3mm = GuiCtrlRead($attack3mm_da)
	$readAttack4mm = GuiCtrlRead($attack4mm_da)
	$readAttack5mm = GuiCtrlRead($attack5mm_da)
	$readAttack6mm = GuiCtrlRead($attack6mm_da)

	$readAttack8hp = GuiCtrlRead($attack8hitPoint)
	$reg_minLife = GuiCtrlRead($regMin)
	$reg_minMana = GuiCtrlRead($regMinMana)




	$readatck = GuiCtrlRead($atck)
	$readattackdistmin = GuiCtrlRead($attackdistmin)
	$readattackdistmax = GuiCtrlRead($attackdistmax)



	$readLoot = GuiCtrlRead($lootKey)
	$readReg = GuiCtrlRead($regKey)
	FileDelete("data.txt")
	FileWriteLine($file1,$readAttack1)		;1
	FileWriteLine($file1,$readAttack2)		;2
	FileWriteLine($file1,$readAttack3)		;3
	FileWriteLine($file1,$readLoot)			;4
	FileWriteLine($file1,$readReg)			;5
	FileWriteLine($file1,$readAttack1cast)	;6
	FileWriteLine($file1,$readAttack2cast)	;7
	FileWriteLine($file1,$readAttack3cast)	;8
	FileWriteLine($file1,$readAttack1cd)	;9
	FileWriteLine($file1,$readAttack2cd)	;10
	FileWriteLine($file1,$readAttack3cd)	;11
	FileWriteLine($file1,$reg_minLife)		;12
	FileWriteLine($file1,$reg_minMana)		;13
	FileWriteLine($file1,$readAttack4)		;14
	FileWriteLine($file1,$readAttack4cast)	;15
	FileWriteLine($file1,$readAttack4cd)	;16

	FileWriteLine($file1,$readAttack1da)	;17
	FileWriteLine($file1,$readAttack2da)	;18
	FileWriteLine($file1,$readAttack3da)	;19
	FileWriteLine($file1,$readAttack4da)	;20

	FileWriteLine($file1,$readAttack5da)	;21
	FileWriteLine($file1,$readAttack6da)	;22
	FileWriteLine($file1,$readAttack5)		;23
	FileWriteLine($file1,$readAttack5cast)	;24
	FileWriteLine($file1,$readAttack5cd)	;25
	FileWriteLine($file1,$readAttack6)		;26
	FileWriteLine($file1,$readAttack6cast)	;27
	FileWriteLine($file1,$readAttack6cd)	;28
	FileWriteLine($file1,$readAttack7)		;29
	FileWriteLine($file1,$readAttack7cast)	;30
	FileWriteLine($file1,$readAttack7cd)	;31
	FileWriteLine($file1,$readAttack8)		;32
	FileWriteLine($file1,$readAttack8cast)	;33
	FileWriteLine($file1,$readAttack8cd)	;34
	FileWriteLine($file1,$readAttack8hp)	;35
	FileWriteLine($file1,$readatck)			;36
	FileWriteLine($file1,$readattackdistmin) ;37
	FileWriteLine($file1,$readattackdistmax) ;38

	FileWriteLine($file1,$readAttack1mm)	 ;39
	FileWriteLine($file1,$readAttack2mm) 	;40
	FileWriteLine($file1,$readAttack3mm) 	;41
	FileWriteLine($file1,$readAttack4mm) 	;42
	FileWriteLine($file1,$readAttack5mm) 	;43
	FileWriteLine($file1,$readAttack6mm) 	;44

	readKeys()
EndFunc

; THE FUTURE!
Func loadConfig()
	$confVar1 = FileReadLine($configFile,"1")
	$confVar2 = FileReadLine($configFile,"2")
	$confVar3 = FileReadLine($configFile,"3")
	$confVar4 = FileReadLine($configFile,"4")
	$confVar5 = FileReadLine($configFile,"5")
	$confVar6 = FileReadLine($configFile,"6")
	$confVar7 = FileReadLine($configFile,"7")
	$confVar8 = FileReadLine($configFile,"8")
	$confVar9 = FileReadLine($configFile,"9")
	$confVar10 = FileReadLine($configFile,"10")
	$confVar11 = FileReadLine($configFile,"11")
	$confVar12 = FileReadLine($configFile,"12")
	$confVar13 = FileReadLine($configFile,"13")
	$confVar14 = FileReadLine($configFile,"14")
	$confVar15 = FileReadLine($configFile,"15")
	$confVar16 = FileReadLine($configFile,"16")
	$confVar17 = FileReadLine($configFile,"17")
	$confVar18 = FileReadLine($configFile,"18")
	$confVar19 = FileReadLine($configFile,"19")
	$confVar20 = FileReadLine($configFile,"20")
	$confVar21 = FileReadLine($configFile,"21")
	$confVar22 = FileReadLine($configFile,"22")
	$confVar23 = FileReadLine($configFile,"23")
	$confVar24 = FileReadLine($configFile,"24")
	$confVar25 = FileReadLine($configFile,"25")
	$confVar26 = FileReadLine($configFile,"26")
	$confVar27 = FileReadLine($configFile,"27")
	$confVar28 = FileReadLine($configFile,"28")
	$confVar29 = FileReadLine($configFile,"29")
	$confVar30 = FileReadLine($configFile,"30")
	$confVar31 = FileReadLine($configFile,"31")
	$confVar32 = FileReadLine($configFile,"32")
	$confVar33 = FileReadLine($configFile,"33")
	$confVar34 = FileReadLine($configFile,"34")
	$confVar35 = FileReadLine($configFile,"35")
	$confVar36 = FileReadLine($configFile,"36")
	$confVar37 = FileReadLine($configFile,"37")
	$confVar38 = FileReadLine($configFile,"38")
	$confVar39 = FileReadLine($configFile,"39")
	$confVar40 = FileReadLine($configFile,"40")
	$confVar41 = FileReadLine($configFile,"41")
	$confVar42 = FileReadLine($configFile,"42")
	$confVar43 = FileReadLine($configFile,"43")

EndFunc

Func _toolTip($msg)
	GUICtrlSetData($status,$msg)
EndFunc

;#################################################
;Memory Read/write functions
;#################################################


Func OpenAionMemory()
	$pid = ProcessExists("AION.bin")
	If $pid == -1 Then
		Return
	EndIf
	$openmem = _MemoryOpen($pid)
	If @error Then
		Return
	EndIf
	$AionRun = True
EndFunc


Func MemReadDLLEnemyHP($offset)
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _MemoryRead($finaladdr,$openmem)
	$MemTest = _memoryread(   $MemTest+ 0x1C4,$openmem)
    $MemTest = _memoryread(   $MemTest + 0x0034, $openmem,"byte" )
    Return $MemTest
EndFunc

Func MemReadDLLEnemyLevel($offset)
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _MemoryRead($finaladdr,$openmem)
	$MemTest = _memoryread(   $MemTest+ 0x1C4,$openmem)
    $MemTest = _memoryread(   $MemTest + 0x0032, $openmem,"byte" )
    Return $MemTest
EndFunc

Func MemReadTargetType($offset)
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _MemoryRead($finaladdr,$openmem)
	$MemTest = _memoryread(   $MemTest+ 0x1C4,$openmem)
    $MemTest = _memoryread(   $MemTest + 0x0168, $openmem )
    Return $MemTest
EndFunc

Func MemReadtargetxCoord($offset)
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _memoryread($finaladdr,$openmem)
	$MemTest = _memoryread($MemTest+ 0x28,$openmem,"float")
    Return $MemTest
EndFunc

Func MemReadtargetYCoord($offset)
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _memoryread($finaladdr,$openmem)
	$MemTest = _memoryread($MemTest+ 0x2c,$openmem,"float")
    Return $MemTest
EndFunc



Func MemReadDLL($offset)
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _MemoryRead($finaladdr,$openmem)

    Return $MemTest
EndFunc

Func MemReadDLLFloat($offset)
	$StaticOffset = Dec($offset)
	Global $pid
	Global $CUROffset[1]
	$CUROffset[0] = 0
	$baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
	$finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
	$MemTest = _MemoryRead($finaladdr,$openmem,"float")
	Return $MemTest
EndFunc

Func MemWriteDLL($offset, $data)
	$StaticOffset = Dec($offset)
	Global $pid
	Global $CUROffset[1]
	$CUROffset[0] = 0
	$baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
	$finalADDR = "0x" & Hex($baseADDR + $StaticOffset)

	_MemoryWrite($finalADDR,$openmem,$data,"float")
	Return
EndFunc

Func MemReadEntity($offset)
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _memoryread($finaladdr,$openmem)
	$MemTest = _memoryread($MemTest+ 0x1C4,$openmem)
    Return $MemTest
EndFunc

Func MemReadTargetName($offset = "4F68FC")
    $StaticOffset = Dec($offset)
    Global $pid
    Global $CUROffset[1]
    $CUROffset[0] = 0
    $baseADDR = _MemoryModuleGetBaseAddress($pid, "Game.dll")
    $finalADDR = "0x" & Hex($baseADDR + $StaticOffset)
    $MemTest = _memoryread($finaladdr,$openmem)
	$MemTest = _memoryread($MemTest+ 0x4 ,$openmem)
	;$MemTest = _memoryread(   $MemTest + 0x0036 , $openmem,"byte" )
    Return $MemTest
EndFunc

; the HP of the TargetEnemy
Func CheckEnemyDead()
	return MemReadDLLEnemyHP("4F68FC")
	;Return 0
EndFunc

Func playerCurrectEP()
	return MemReadDLL("8EEEA8")
EndFunc

Func PlayerMaxEP()
	return MemReadDLL("8EEE98")
EndFunc

Func playerCurrectMana()
	return MemReadDLL("8EEEC0")
EndFunc

Func PlayerMaxMana()
	return MemReadDLL("8EEEBC")
EndFunc

Func playerCurrectHp()
	return MemReadDLL("8EEEB8")
EndFunc

Func playerCurrectHpPercent()
	$val = MemReadDLL("8EEEB8")
	$Pval = ($val * 100) / PlayerMaxHp()
	return Round($Pval)
EndFunc

Func playerCurrectMpPercent()
	$val2 = MemReadDLL("8EEEC0")
	$Pval2 = ($val2 * 100) / PlayerMaxMana()
	return Round($Pval2)
EndFunc

Func PlayerMaxHp()
	return MemReadDLL("8EEEB4")
EndFunc

Func PlayerxPos()
	return MemReadDLLFloat("8E6944")
EndFunc

Func PlayeryPos()
	return MemReadDLLFloat("8E6940")
EndFunc

Func PlayerZPos()
	return MemReadDLLFloat("8E6948")
EndFunc

; Angel of the Player 360° / 2 :)
Func GetPlayerPos()
	Return MemReadDLLFloat("8E40C0")
EndFunc

Func GetEnemyLvl()
	Return MemReadDLLEnemyLevel("4F68FC")
EndFunc

Func getEnityId()
	Return MemReadEntity("4F68FC")
EndFunc

Func getTargetOfTarget()
	Return MemReadTargetName()
EndFunc

Func getEnemyType()
	Return MemReadTargetType("4F68FC")
EndFunc

Func ReadMemValues()
	$playerHP = playerCurrectHp()
	$playerHPMax = PlayerMaxHp()

	$playerEP = playerCurrectEP()
	$playerEPMax = PlayerMaxEP()
	$playerEnergy = playerCurrectMana()
	$playerEnergyMax = PlayerMaxMana()
EndFunc

;#################################################
;fight functions
;#################################################




Func regenhpnmp()
if ((playerCurrectHp()/$playerHPMax)*100) < $reg_minLife Or ((playerCurrectMana()/$playerEnergyMax)*100) < $reg_minMana Then
			_toolTip("start Reging")
			Sleep(100)
				while PlayerMaxHp() <> playerCurrectHp()
					if( CheckEnemyDead() <> 0 And enemyInsgid() ) Then
						send($atck)
						KillEnemy()
						Return False
						ExitLoop									;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
					EndIf																			;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
				Sleep(1000)
				WEnd

				while PlayerMaxMana() <> playerCurrectMana()
					if( CheckEnemyDead() <> 0 And enemyInsgid() ) Then
						send($atck)
						KillEnemy()
						Return False
						ExitLoop											;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
					EndIf																									;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
				sleep(1000)
				WEnd


			Send("{w down}")
			Sleep(100)
			Send("{w up}")

Else
			if ( lookaround() = False ) Then
				$jumper = _getRandomJumpTimer()
				walkPoints()
			Else
;~ 			send($atck)
			KillEnemy()
;~ 		EndIf
;~ 		return True
			EndIf
EndIf
		$jumper = _getRandomJumpTimer()

EndFunc


Func enemyInsgid()
	$enemyhp = CheckEnemyDead()
	if $enemyhp <> 0 And $enemyhp > 99 And getEnemyType() <> 0 then
		if GetEnemyLvl() = 1 Then
			return false
		EndIf
		return true
	EndIf
	return false
EndFunc

Func enemydistokmin()
;~ 	if ( enemyInsgid() = False ) Then
;~ 		Send("{w down}")
;~ 		sleep(5)
;~ 		send("{w up}")
;~ 		lookaround()

;~ 	Else
		send($atck)
		Do
		$enemydokmin = GetDistance()
			if ($enemydokmin > $attackdistmin) then
			sleep(40)
			_toolTip("waiting for target range -"&$enemydokmin&"m")
			EndIf
		Until $enemydokmin <= $attackdistmin
		Send("{w up}")
		Send("{a up}")
		send("{d up}")
		send("{s down}")
		sleep(20)
		send("{s up}")
		return true
;~ 	EndIf
	EndFunc																;;;;;;;;;;;KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
																		;;;;;;;;;;;KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
Func enemydistokmax()
;~ 	if ( enemyInsgid() = False ) Then
;~ 269s7
;~ 		lookaround()
;~ 	Else
send($atck)                                                          ;;;;;;;;;;;KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
	Do
	$enemydokmax = GetDistance()
	if $enemydokmax >= $attackdistmax Then
	sleep(40)
	_toolTip("waiting for target range -"&$enemydokmax&"m")
	EndIf
	Until $enemydokmax <= $attackdistmax
		Send("{w up}")
		Send("{a up}")
		send("{d up}")
		send("{s down}")
		sleep(20)
		send("{s up}")
		return true
;~ 	EndIf
EndFunc

Func KillEnemy()
;~ 		$combatStartTimer = _TimeGetStamp() + 10
;~ 		$combatAnimaLibera = 0
;~ 		$goodCombat = 0
;~ 		$combatFlag = 0
;~ 		$timeDiff = _TimeGetStamp()
		_toolTip("start attacking")
																		;;;: waits until the mob is in range - Added by kknb 30.10.2009
			if $attack4 <> "x" then

				if($combatFlag == 2) Then
					return false
				EndIf
					if ( enemydistokmax() ) then
						Send("{w up}")
						send("{s up}")
						Send("{a up}")
						send("{d up}")
						if ( F_buff() ) Then
						sleep(500)

							if ( combat() = False ) Then
								aftercombat()
							EndIf
						EndIf
;~ 					EndIf
					Else
;~ 						if (enemyInsgid() = false ) then
;~ 						if lookaround() = False Then
;~ 						walkPoints()
;~ 					EndIf
;~ 					EndIf

				send($atck)
				Do
					If $Run = False Then
							Send("{w up}")
							send("{s up}")
							Send("{a up}")
							send("{d up}")
							ExitLoop

					EndIf

						$enemydokmax = GetDistance()
						sleep(40)
				until $enemydokmax <= $attackdistmax
						send("{s down}")
						sleep(200)
						send("{s up}")
;~ 						if ( F_buff() ) Then
;~ 						combat()



						if ( F_buff() ) Then
							sleep(500)
;~ 							if ( combat() = False) then


							if ( combat() = False ) Then
								aftercombat()
							EndIf
						EndIf



;~ 						EndIf
			EndIf

				If $Run = False Then
					Send("{w up}")
					send("{s up}")
					Send("{a up}")
					send("{d up}")
;~ 					ExitLoop

				EndIf

				If $Run = False Then
					Send("{w up}")
					send("{s up}")
					Send("{a up}")
					send("{d up}")
;~ 					ExitLoop
				EndIf
			EndIf

				sleep(100)

			$combatStartTimer = _TimeGetStamp() + 10
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

EndFunc

func combat()
		$combatStartTimer = _TimeGetStamp() + 10
		$combatAnimaLibera = 0
		$goodCombat = 0
		$combatFlag = 0
		$timeDiff = _TimeGetStamp()
		_toolTip("start combat")


Do

$alive = CheckEnemyDead()

			;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
			if $attack1 <> "x" then
				_toolTip("start Attack1")
				if(GuiCtrlRead($attack1mm_da) == 0) Then
					if ( enemydistokmin() ) then
;~ 						F_arttack1()
						validateAttack()
						if (F_arttack1() = False ) Then
						EndIf
					EndIf
				EndIf
			EndIf

							if $attack2 <> "x" then
							_toolTip("start Attack2")
								if(GuiCtrlRead($attack2mm_da) == 0) Then
									if ( enemydistokmin() ) then
;~ 										F_arttack2()
										validateAttack()
										if (F_arttack2() = False ) Then
										EndIf
									EndIf
								EndIf
							EndIf

											if $attack3 <> "x" then
											_toolTip("start Attack3")
												if(GuiCtrlRead($attack3mm_da) == 0) Then
													if ( enemydistokmin() ) then
;~ 														F_arttack3()
														validateAttack()
														if (F_arttack3() = False ) Then
														EndIf
													EndIf
												EndIf
											EndIf
															if $attack5 <> "x" then
															_toolTip("start Attack4")
																if(GuiCtrlRead($attack4mm_da) == 0) Then
																	if ( enemydistokmin() ) then
;~ 																		F_arttack5()
																		validateAttack()
																		if (F_arttack5() = False ) Then
																		EndIf
																	EndIf
																EndIf
															EndIf

																			if $attack6 <> "x" then
																			_toolTip("start Attack6")
																				if(GuiCtrlRead($attack5mm_da) == 0) Then
																					if ( enemydistokmin() ) then
;~ 																						F_arttack5()
																						validateAttack()
																						if (F_arttack6() = False ) Then
																						sleep(10)
																						EndIf
																					EndIf
																				EndIf
																			EndIf




Until $alive = 0

							if ( CheckEnemyDead() = 0 ) then
;~ 								$alive = 0
								Return False

							Else
								Return True
							EndIf

EndFunc

;~ Func combat()

;~ 		while CheckEnemyDead() <> 0                                                   ;;;;;;;;;;; WHILE ENEMY ALIVE START

;~ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;~ 			if $attack1 <> "x" then
;~ 				if($combatFlag == 2) Then
;~ 					return false
;~ 				EndIf
;~ 				if(GuiCtrlRead($attack1mm_da) == 0) Then
;~ 					if ( enemydistokmin() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 					Send("{w up}")
;~ 					send("{s up}")
;~ 					Send("{a up}")
;~ 					send("{d up}")
;~ 						F_arttack1()
;~ 						validateAttack()


;~ 					Else
;~ 						send($atck)
;~ 						Do
;~ 							If $Run = False Then
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							ExitLoop

;~ 							EndIf
;~ 							$enemydokmin = GetDistance()
;~ 							sleep(40)
;~ 						until $enemydokmin <= $attackdistmin
;~ 							send("{s down}")
;~ 							sleep(10)
;~ 							send("{s up}")
;~ 							F_arttack1()
;~ 							validateAttack()

;~ 					EndIf

;~ 				EndIf

;~ 				if (GuiCtrlRead($attack1mm_da) == 1) Then
;~ 				if($combatFlag == 2) Then
;~ 					return false
;~ 				EndIf

;~ 						if ( enemydistokmax() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							F_arttack1()
;~ 							validateAttack()


;~ 						Else
;~ 							send($atck)
;~ 							Do
;~ 								If $Run = False Then
;~ 									Send("{w up}")
;~ 									send("{s up}")
;~ 									Send("{a up}")
;~ 									send("{d up}")
;~ 									ExitLoop
;~ 								EndIf
;~ 								$enemydokmin = GetDistance()
;~ 								sleep(40)
;~ 							until $enemydokmin <= $attackdistmin
;~ 								send("{s down}")
;~ 								sleep(10)
;~ 								send("{s up}")
;~ 								F_arttack1()
;~ 								validateAttack()

;~ 						EndIf

;~ 				EndIf

;~ 			EndIf

;~ 	sleep(300)


;~ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;~ 			if $attack2 <> "x" then
;~ 				if($combatFlag == 2) Then
;~ 					return false
;~ 				EndIf
;~ 				if(GuiCtrlRead($attack2mm_da) == 0) Then
;~ 					if ( enemydistokmin() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 					Send("{w up}")
;~ 					send("{s up}")
;~ 					Send("{a up}")
;~ 					send("{d up}")
;~ 						F_arttack2()
;~ 						validateAttack()


;~ 					Else
;~ 						send($atck)
;~ 						Do
;~ 							If $Run = False Then
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							ExitLoop

;~ 							EndIf
;~ 							$enemydokmin = GetDistance()
;~ 							sleep(40)
;~ 						until $enemydokmin <= $attackdistmin
;~ 							send("{s down}")
;~ 							sleep(10)
;~ 							send("{s up}")
;~ 							F_arttack2()
;~ 							validateAttack()

;~ 					EndIf

;~ 				EndIf

;~ 				if (GuiCtrlRead($attack2mm_da) == 1) Then


;~ 						if ( enemydistokmax() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							F_arttack2()
;~ 							validateAttack()


;~ 						Else
;~ 							send($atck)
;~ 							Do
;~ 								If $Run = False Then
;~ 									Send("{w up}")
;~ 									send("{s up}")
;~ 									Send("{a up}")
;~ 									send("{d up}")
;~ 									ExitLoop
;~ 								EndIf
;~ 								$enemydokmin = GetDistance()
;~ 								sleep(40)
;~ 							until $enemydokmin <= $attackdistmin
;~ 								send("{s down}")
;~ 								sleep(10)
;~ 								send("{s up}")
;~ 								F_arttack2()
;~ 								validateAttack()

;~ 						EndIf
;~ 				EndIf

;~ 			EndIf

;~ 	sleep(100)


;~ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;~ 			if $attack3 <> "x" then
;~ 				if($combatFlag == 2) Then
;~ 					return false
;~ 				EndIf
;~ 				if(GuiCtrlRead($attack3mm_da) == 0) Then
;~ 					if ( enemydistokmin() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 					Send("{w up}")
;~ 					send("{s up}")
;~ 					Send("{a up}")
;~ 					send("{d up}")
;~ 						F_arttack3()
;~ 						validateAttack()


;~ 					Else
;~ 						send($atck)
;~ 						Do
;~ 							If $Run = False Then
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							ExitLoop

;~ 							EndIf
;~ 							$enemydokmin = GetDistance()
;~ 							sleep(40)
;~ 						until $enemydokmin <= $attackdistmin
;~ 							send("{s down}")
;~ 							sleep(10)
;~ 							send("{s up}")
;~ 							F_arttack3()
;~ 							validateAttack()

;~ 					EndIf

;~ 				EndIf

;~ 				if (GuiCtrlRead($attack3mm_da) == 1) Then


;~ 						if ( enemydistokmax() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							F_arttack3()
;~ 							validateAttack()


;~ 						Else
;~ 							send($atck)
;~ 							Do
;~ 								If $Run = False Then
;~ 									Send("{w up}")
;~ 									send("{s up}")
;~ 									Send("{a up}")
;~ 									send("{d up}")
;~ 									ExitLoop
;~ 								EndIf
;~ 								$enemydokmin = GetDistance()
;~ 								sleep(40)
;~ 							until $enemydokmin <= $attackdistmin
;~ 								send("{s down}")
;~ 								sleep(10)
;~ 								send("{s up}")
;~ 								F_arttack3()
;~ 								validateAttack()

;~ 						EndIf
;~ 				EndIf

;~ 			Endif

;~ 	sleep(100)




;~ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;~ 			if $attack5 <> "x" then
;~ 								if($combatFlag == 2) Then
;~ 					return false
;~ 				EndIf
;~ 				if(GuiCtrlRead($attack4mm_da) == 0) Then
;~ 					if ( enemydistokmin() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 					Send("{w up}")
;~ 					send("{s up}")
;~ 					Send("{a up}")
;~ 					send("{d up}")
;~ 						F_arttack5()
;~ 						validateAttack()


;~ 					Else
;~ 						send($atck)
;~ 						Do
;~ 							If $Run = False Then
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							ExitLoop

;~ 							EndIf
;~ 							$enemydokmin = GetDistance()
;~ 							sleep(40)
;~ 						until $enemydokmin <= $attackdistmin
;~ 							send("{s down}")
;~ 							sleep(10)
;~ 							send("{s up}")
;~ 							F_arttack5()
;~ 							validateAttack()

;~ 					EndIf

;~ 				EndIf



;~ 					if(GuiCtrlRead($attack4mm_da) == 1) Then
;~ 						if ( enemydistokmax() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							F_arttack5()
;~ 							validateAttack()


;~ 						Else
;~ 							send($atck)
;~ 							Do
;~ 								If $Run = False Then
;~ 									Send("{w up}")
;~ 									send("{s up}")
;~ 									Send("{a up}")
;~ 									send("{d up}")
;~ 									ExitLoop
;~ 								EndIf
;~ 								$enemydokmin = GetDistance()
;~ 								sleep(40)
;~ 							until $enemydokmin <= $attackdistmin
;~ 								send("{s down}")
;~ 								sleep(10)
;~ 								send("{s up}")
;~ 								F_arttack5()
;~ 								validateAttack()

;~ 						EndIf
;~ 					EndIf

;~ EndIf

;~ 	sleep(100)



;~ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;~ 			if $attack6 <> "x" then
;~ 				if($combatFlag == 2) Then
;~ 					return false
;~ 				EndIf
;~ 				if(GuiCtrlRead($attack5mm_da) == 0) Then
;~ 					if ( enemydistokmin() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 					Send("{w up}")
;~ 					send("{s up}")
;~ 					Send("{a up}")
;~ 					send("{d up}")
;~ 						F_arttack5()
;~ 						validateAttack()


;~ 					Else
;~ 						send($atck)
;~ 						Do
;~ 							If $Run = False Then
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							ExitLoop

;~ 							EndIf
;~ 							$enemydokmin = GetDistance()
;~ 							sleep(40)
;~ 						until $enemydokmin <= $attackdistmin
;~ 							send("{s down}")
;~ 							sleep(10)
;~ 							send("{s up}")
;~ 							F_arttack5()
;~ 							validateAttack()

;~ 					EndIf

;~ 				EndIf

;~ 				if (GuiCtrlRead($attack5mm_da) == 1) Then

;~ 					if(GuiCtrlRead($attack5mm_da) == 1) Then
;~ 						if ( enemydistokmax() ) then                                ;,,,,,,,,,,,,,,,  change to max for rangespell
;~ 							Send("{w up}")
;~ 							send("{s up}")
;~ 							Send("{a up}")
;~ 							send("{d up}")
;~ 							F_arttack5()
;~ 							validateAttack()


;~ 						Else
;~ 							send($atck)
;~ 							Do
;~ 								If $Run = False Then
;~ 									Send("{w up}")
;~ 									send("{s up}")
;~ 									Send("{a up}")
;~ 									send("{d up}")
;~ 									ExitLoop
;~ 								EndIf
;~ 								$enemydokmin = GetDistance()
;~ 								sleep(40)
;~ 							until $enemydokmin <= $attackdistmin
;~ 								send("{s down}")
;~ 								sleep(10)
;~ 								send("{s up}")
;~ 								F_arttack5()
;~ 								validateAttack()

;~ 						EndIf
;~ 					EndIf
;~ 				EndIf

;~ 			EndIf

;~ 	sleep(100)



;~ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;~ 		WEnd														;;;;			WEND END ...

;~ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;~ EndFunc

func aftercombat()
		_toolTip("Mob down")
		;;; add 1 to the kill counter :)
		$enemyKillCount = $enemyKillCount + 1
		GUICtrlSetData( $killCount, $enemyKillCount)
		Sleep(1800)
		;;; ep counter
		$newEp = playerCurrectEP() - $playerEP
		$playerEP = playerCurrectEP()
		$enemyEpCount = $enemyEpCount + $newEp
		GUICtrlSetData($epCount , $enemyEpCount)
		;;; loot
		F_EmCast()
		sleep(50)
		Send("{s down}")
		$zufall = random(85,105)
		sleep($zufall)
		send("{s up}")

		_toolTip("start Looting")


		Sleep(2000)
		Send($loot)

		calcTime($newEp)
		$looted = True

		Sleep(3000)


		if(enemyInsgid() and  CheckEnemyDead() <> 0  ) Then
			$looted = False
			if (enemydistokmax()) Then
				F_EmCast()
				$looted = False
;~ 				send($atck)																				;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
				killenemy()
			EndIf																					;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
																						;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
		Else
			if $attack7 <> "x" then
				if ( F_PostAttack() = True) then
				sleep(300)
				regenhpnmp()
;~ 				Return True


				if ( F_PostAttack() = false) then
				killenemy()
;~ 				Return False
				EndIf
				EndIf
			EndIf

;~ 		if ((playerCurrectHp()/$playerHPMax)*100) < $reg_minLife Or ((playerCurrectMana()/$playerEnergyMax)*100) < $reg_minMana Then
;~ 			_toolTip("start Reging")
;~ 			Sleep(100)
;~ 			if ( regenhpnmp() ) then
;~ 			if ( regenhpnmp() = False ) then
;~ 			return true
;~ 			EndIf

;~ 			if ( lookaround() = False ) Then
;~ 				walkPoints()
;~ 			EndIf



;~ 		EndIf
		EndIf
EndFunc





Func GetDistance()																				;;;: distance  - Added by kknb 30.10.2009
    $y1 = PlayerXPos()
    $targetx = MemReadtargetxCoord("4F68FC")
    $x1 = PlayerYPos()
    $targety = MemReadtargetYCoord("4F68FC")
    $diff = sqrt((($x1 - $targetx)^2) + (($y1 - $targety)^2))
    $erg = Round($diff)
Return $erg -3
EndFunc


Func waitForDistmin()
;~ 	Send($atck)				;;;: waits until the mob is in range - Added by kknb 30.10.2009
	do
		sleep(25)
		$abstandmin = GetDistance()
		_toolTip("waiting for target range -"&$abstandmin&"m")

;~ 		send("{w down}")

	Until ($abstandmin  <= $attackdistmin )
	send("{s down}")
	sleep(100)
	send("{s up}")
	Return True
EndFunc

Func waitForDistmax()
;~ 		Send($atck)								;;;: waits until the mob is in range - Added by kknb 30.10.2009
	do
		sleep(25)
		$abstandmax = GetDistance()
;~ 		_toolTip("waiting until target is in max range -"&$abstandmax&"m")

	Until ($abstandmax <= $attackdistmax)
	send("{s down}")
	sleep(400)
	send("{s up}")
	Return True
EndFunc


Func validateAttack()
	if($goodCombat < 1) Then
		if($combatStartTimer < _TimeGetStamp() ) Then
			if(CheckEnemyDead() < 100) Then
				$goodCombat = 1
				$combatFlag = 1
			Elseif($combatAnimaLibera < 2) Then
				if(CheckEnemyDead() < 100) Then
					$goodCombat = 1
					$combatFlag = 1
					return True
				EndIf
				combatFreeMind()
				$combatAnimaLibera = $combatAnimaLibera + 1
			Else
				$combatFlag = 2
				$lastBlackListEnemy = getEnityId()
			EndIf
		EndIf
	EndIf
EndFunc

Func combatFreeMind()
	Send("{s down}")
	Sleep(1500)
	Send("{s up}")
	if($combatAnimaLibera > 0) Then
		Send("{e down}")
		Sleep(1500)
		Send("{e up}")
	Else
		Send("{q down}")
		Sleep(1500)
		Send("{q up}")
	EndIf
	$combatStartTimer = _TimeGetStamp() + 10
EndFunc

Func checkBlackList()
	If getEnityId() == $lastBlackListEnemy And $lastBlackListEnemy <> 0 Then
		Return False
	Else
		Return True
	EndIf
EndFunc

Func checkShutDown()
	if($timeToShutdown > 0) Then
		$sddiff = $timeToShutdown - _TimeGetStamp()
		If $timeToShutdown < _TimeGetStamp() Then
			Send("{w up}")
			$Run = False
			GUICtrlSetData ($buttonRun,"Start Bot")
		Elseif($sddiff <> $timeCache) Then
			$timeCache = $sddiff
			GUICtrlSetData($timeToShutdownOutput ,SecToTime($sddiff))
		EndIf
	EndIf
EndFunc

Func setShutDownTimer()
	if GuiCtrlRead($sdtimerInput) > 0 And GuiCtrlRead($sdtimerInput) <> "" Then
		$timeToShutdown = _TimeGetStamp() + (GuiCtrlRead($sdtimerInput) * 60)
	Else
		$timeToShutdown = 0
		GUICtrlSetData($timeToShutdownOutput ,"-----")
		$Run = false
	EndIf
EndFunc


;################################################
; Action functions
;################################################

Func F_arttack1()
	F_EmCast()
;~ 		$attack1LastCast =  _TimeGetStamp() - $attack1Cd
		if(($attack1LastCast + $attack1Cd) <= _TimeGetStamp()) Then
			return False
		Else
		_toolTip("starting Attack 01")
		if(GuiCtrlRead($attack1_da) == 1) Then
			$attack1LastCast = _TimeGetStamp()
			sleep(300)
			Send($attack1)

				$zufall = Random(1000,1625)
				Sleep($zufall)

			Send($attack1)

				$zufall = Random(1000,1625)
				Sleep($zufall)

			Send($attack1)
				F_EmCast()
			return true
		Else
			$attack1LastCast = _TimeGetStamp()
			Send($attack1)
			$zufall = Random(1,25)
			Sleep($attack1c + $zufall)
			F_EmCast()
			return true
		EndIf
	EndIf
;~ 	if(($attack1LastCast + $attack1Cd) > _TimeGetStamp()) Then
;~ 			return False
;~ 		EndIf
EndFunc

Func F_arttack2()
	F_EmCast()
		if(($attack2LastCast + $attack2Cd) <= _TimeGetStamp()) Then
			Return False
		Else
		_toolTip("starting Attack 2")
		if(GuiCtrlRead($attack2_da) == 1) Then
			$attack2LastCast = _TimeGetStamp()
			Send($attack2)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack2)
			$zufall = Random(390,400)
			Sleep($zufall)
			Send($attack2)
			F_EmCast()
			return true
		Else
			$attack2LastCast = _TimeGetStamp()
			Send($attack2)
			$zufall = Random(1,25)
			Sleep($attack2c + $zufall)
			F_EmCast()
			return true
		EndIf
	EndIf
EndFunc

Func F_arttack3()
	F_EmCast()
		if(($attack3LastCast + $attack3Cd) <= _TimeGetStamp()) Then
			Return False
		Else
		_toolTip("starting Attack 3")
		if(GuiCtrlRead($attack3_da) == 1) Then
			$attack3LastCast = _TimeGetStamp()
			Send($attack3)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack3)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack3)
			F_EmCast()
			return true
		Else
			$attack3LastCast = _TimeGetStamp()
			Send($attack3)
			$zufall = Random(1,25)
			Sleep($attack3c + $zufall)
			F_EmCast()
			return true
		EndIf
	EndIf
EndFunc

Func F_arttack5()
	F_EmCast()
		if(($attack5LastCast + $attack5Cd) <= _TimeGetStamp()) Then
			Return False
		Else
		_toolTip("starting Attack 5")
		if(GuiCtrlRead($attack5_da) == 1) Then
			$attack5LastCast = _TimeGetStamp()
			Send($attack5)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack5)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack5)
			F_EmCast()
			return true
		Else
			$attack5LastCast = _TimeGetStamp()
			Send($attack5)
			$zufall = Random(1,25)
			Sleep($attack5c + $zufall)
			F_EmCast()
			return true
		EndIf
	EndIf
EndFunc

Func F_arttack6()
	F_EmCast()
		if(($attack6LastCast + $attack6Cd) <= _TimeGetStamp()) Then
			Return False
			Else
		_toolTip("starting Attack 6")
		if(GuiCtrlRead($attack6_da) == 1) Then
			$attack6LastCast = _TimeGetStamp()
			Send($attack6)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack6)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack6)
			F_EmCast()
			return true
		Else
			$attack6LastCast = _TimeGetStamp()
			Send($attack6)
			$zufall = Random(1,25)
			Sleep($attack6c + $zufall)
			F_EmCast()
			return true
		EndIf
	EndIf
EndFunc

Func F_buff()
	F_EmCast()
		if(($attack4LastCast + $attack4Cd) <= _TimeGetStamp()) Then

		_toolTip("starting PreCast")
		if(GuiCtrlRead($attack4_da) == 1) Then
			$attack4LastCast = _TimeGetStamp()
			Send($attack4)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack4)
			$zufall = Random(700,1025)
			Sleep($zufall)
			Send($attack4)
			F_EmCast()
			return true
		Else

			$attack4LastCast = _TimeGetStamp()
			Send($attack4)
			$zufall = Random(1,25)
			Sleep($attack4c + $zufall)
			F_EmCast()
			Return True
		EndIf
EndIf


EndFunc

Func F_PostAttack()
		F_EmCast()
		sleep(2000)
		if ( CheckEnemyDead() <> 0 ) Then
			Return False

		Else

			if playerCurrectHpPercent()  > 90 and playerCurrectMpPercent() > 90 then
				F_EmCast()
				Return True
			EndIf
		EndIf
;~ 	else
		if(($attack7LastCast + $attack7Cd) < _TimeGetStamp()) Then
			_toolTip("starting PostCast")
			Send($attack7)
			Sleep($attack7c)
			$attack7LastCast = _TimeGetStamp()
			sleep(300)
				if playerCurrectHpPercent() < 60 Or playerCurrectMpPercent() < 60 then
					toolTip("2nd PostCast needed")
					Sleep($attack7Cooldown)
					sleep(500)
					Send($attack7)
					Sleep($attack7c)
					$attack7LastCast = _TimeGetStamp()
					return True
				EndIf

		else
			do
				Sleep(200)
			Until (($attack7LastCast + $attack7Cd) < _TimeGetStamp())
				sleep(500)
				Send($attack7)
				Sleep($attack7c)
				$attack7LastCast = _TimeGetStamp()
				sleep(300)

			if playerCurrectHpPercent() < 60 Or playerCurrectMpPercent() < 60 then
				toolTip("2nd PostCast needed")
				Sleep($attack7Cooldown)
				sleep(500)
				Send($attack7)
				Sleep($attack7c)
				$attack7LastCast = _TimeGetStamp()
				return True
			EndIf

;~ 			Return True
		EndIf

EndFunc

Func F_EmCast()
	if ($attack8 <> "x") then
		if(($attack8LastCast + $attack8Cd) < _TimeGetStamp() and playerCurrectHpPercent() <= $attack8hp) Then
			_toolTip("starting Emergency Cast")
			Send($attack8)
			Sleep($attack8c)
			$attack8LastCast = _TimeGetStamp()
		EndIf
	EndIf
EndFunc


;#################################################
;waypoint functions
;#################################################

Func _keyboardToWpInterface()
	OpenAionMemory()
	addWP()
EndFunc

Func addWP()

	$playerX = PlayerXPos()
	$playerY = PlayerYPos()
	$playerZ = PlayerZPos()

	$WPFile = "wp"

	$openFile = GuiCtrlRead($wpSaveInput)
	$wpSave = FileOpen($openFile, 1)

	FileWriteLine($wpSave ,Round($playerX,2))
	FileWriteLine($wpSave ,Round($playerY,2))
	FileWriteLine($wpSave ,Round($playerZ,2))
	FileClose($wpSave)
	_toolTip("WayPoint: "&Round($playerX,0)&" - "&Round($playerY,0)&" - "&Round($playerZ,0)&" added")
EndFunc

Func readWP()
	$countMax=0
	$count = 1
	$openFile = GuiCtrlRead($wpFileInput)
	$readWPfile = FileOpen($openFile, 0)

	While 1
		$x1 = FileReadLine($readWPfile,$count)

		if $x1 = "" Then
			$count = 1
			ExitLoop
		EndIf

		If @error = -1 Then	ExitLoop
		$count = $count +1
		$countMax = $countMax +1
		$x2 = FileReadLine($readWPfile,$count)
		$count = $count +1
		$countMax = $countMax +1
		$x3 = FileReadLine($readWPfile,$count)
		$count = $count +1
		$countMax = $countMax +1


	Wend
	FileClose($readWPfile)


	$openFile = GuiCtrlRead($wpFileInput)
	$readWPfile = FileOpen($openFile, 0)

	While 1

		$x1 = FileReadLine($readWPfile,$count)

		if $x1 = "" Then

			$count = 1
			ExitLoop
		EndIf

		If @error = -1 Then	ExitLoop

		$wpField[$count-1] = $x1

		$count = $count +1

		$x2 = FileReadLine($readWPfile,$count)
		$wpField[$count-1] = $x2

		$count = $count +1

		$x3 = FileReadLine($readWPfile,$count)
		$wpField[$count-1] = $x3

		$count = $count +1




	Wend
	_toolTip("Waypoints loaded ... "&$countMax/3&" found" )
	FileClose($readWPfile)

EndFunc

Func getCredits()
	return @LF&"developed by: Plany, Unknown "&@LF &"Logo by: Blun0r"
EndFunc

Func calcTime($nep)
	$ntime = _TimeGetStamp() - $timeDiff
	$tmpMep = PlayerMaxEP()
	$tmpCep = playerCurrectEP()
	$timeToLevelUp =(($tmpMep - $tmpCep) / $nep ) * $ntime
	$newTime = Round(($timeToLevelUp/60)/60,2)
	if($lastTime <> 0) Then
		if($newTime > $lastTime) Then
			$difftime = $newTime - $lastTime
			$avgTime = $difftime + $lastTime
		Elseif($lastTime > $newTime) Then
			$difftime = $lastTime - $newTime
			$avgTime = $difftime + $newTime
		EndIf
		$lastTime = $newTime
	Else
		$lastTime = $newTime
		$avgTime = $newTime;
	EndIf
	GUICtrlSetData($TimeCount, timeToHuman($avgTime))
EndFunc

;#################################################
;navigate functions
;#################################################

Func lookaround()

For $n = 10 to 1 Step -1
Send("{TAB}")
Sleep(200)
	if( CheckEnemyDead() > 99 And enemyInsgid() And  checkBlackList() AND enemydistokmax() ) Then
		Return True
		send($atck)
		KillEnemy()
		ExitLoop			                                                 ;;;: Quickfix Nr. 3  - Added by Chefes78 28.10.2009
	EndIf

	If $Run = False Then
		Send("{w up}")
		Send("{s up}")
		Send("{a up}")
		Send("{d up}")
		ExitLoop
	EndIf

	if $n = 1 Then
		return False
		walkPoints()
	EndIf

Next
send($atck)
EndFunc


Func calcDist($xa,$ya)


	$distCalc = sqrt( ($xa-PlayerXPos())^2 + ($ya-PlayerYPos())^2 )
	if($distCalc > 15) Then
		_jumpPlayer()
	EndIf
	return $distCalc
EndFunc

Func _getRandomJumpTimer()
	return _TimeGetStamp() + Random(0,6,1)
EndFunc

Func _jumpPlayer()
	if($jumper < _TimeGetStamp()) Then
		if( $jumper <> 0) Then
			Send("{SPACE down}")
			Sleep(80)
			Send("{SPACE up}")
		EndIf
		$jumper = _getRandomJumpTimer()
	EndIf
EndFunc

Func _switchRotate($target, $now)
	if($target < $now) Then
		If(($now - $target) > 180) Then
			$rot_down = "a down"
			$rot_up = "a up"
		Else
			$rot_down = "d down"
			$rot_up = "d up"
		EndIf
	Else
		If(($target - $now) > 180) Then
			$rot_down = "d down"
			$rot_up = "d up"
		Else
			$rot_down = "a down"
			$rot_up = "a up"
		EndIf
	EndIf
EndFunc

; rechnet 90 zu 360 hoch
Func getAngle($diffX, $diffY)
	$angle = ATan($diffY/$diffX)
	$angle = ($angle * 180.0 )/ $pi
	if $diffX > 0 and $diffY > 0 Then
		return getThreeSixty((180 -$angle),true)
	ElseIf $diffX > 0 and $diffY < 0 Then
		return getThreeSixty((-180 -$angle),true)
	ElseIf $diffX < 0 and $diffY < 0 Then
		return getThreeSixty((0 -$angle),true)
	ElseIf $diffX < 0 and $diffY > 0 Then
		return getThreeSixty((0 -$angle),true)
	EndIf
EndFunc

; Flag = true  - rechne 180 auf 360 hoch
;Flag = false - calc 360er rotate!
Func getThreeSixty($angle, $flag = false)
	If($flag) Then
		If($angle < 0) Then
			$angle = (360 - ($angle * -1))
		EndIf
	Else
		If($angle > 360)Then
			$angle = $angle - 360
		ElseIf($angle < 0)Then
			$angle = $angle + 360
		EndIf
	EndIf
	Return $angle
EndFunc

Func alignRotaion($x, $y, $move = false)
	$playerXcoord = PlayerXPos()
	$playerYcoord = PlayerYPos()
		;$playerZcoord = PlayerZPos()
	$diffY = Round($y - $playerYcoord,2)
	$diffX = Round($x - $playerXcoord,2)
	$angle = getAngle($diffX, $diffY)
	$nowAng = getThreeSixty(GetPlayerPos(), true)
	_switchRotate($angle, $nowAng)
	While ($angle + 5) < $nowAng OR ($angle - 5) > $nowAng
		if $move Then
			Send("{w down}")
		EndIf
		Send("{"&$rot_down&"}")
		$nowAng = getThreeSixty(GetPlayerPos(), true)
	WEnd
	if $move Then
		if(($angle + 5) < $nowAng AND ($angle - 5) > $nowAng) Then
			Send("{w up}")
		EndIf
	EndIf
	Send("{"&$rot_up&"}")
EndFunc

Func walkPoints()
	while $i < ($countMax-1)
		if $run = False Then
			ExitLoop
		EndIf
		checkShutDown()
		WinActivate("AION Client")
		WinWaitActive("AION Client")
		_toolTip("Move to waypoint "&($i/3)+1)
		$xCoord=$wpField[$i]
		$yCoord=$wpField[$i+1]
		$zCoord=$wpField[$i+2]
		$i=$i+3

		$Distance = calcDist($xCoord,$yCoord)
		while $Distance > 6
			alignRotaion($xCoord, $yCoord, true)
			Send("{Tab}")
			sleep(50)
			send($atck)
			;;;;;;;;;;;;;;;;;;;;;;;;,,.............................................................
			sleep(50)
			$abstand1 = GetDistance()
			if(enemyInsgid() and checkBlackList() and enemydistokmax() and CheckEnemyDead() <> 0 ) Then
				sleep(200)
				send("{s down}")
				sleep(100)
				send("{s up}")
				KillEnemy()
				_toolTip("Move to waypoint "&($i/3)+1)
			Endif

			if( lookaround() = False ) then
				walkPoints()
			Else
				send($atck)
				KillEnemy()
			EndIf

			If $Run = False Then
				Send("{w up}")
				ExitLoop
			EndIf

		WEnd
		If $Run = False Then
			Send("{w up}")
			ExitLoop
		EndIf
		$jumper = _getRandomJumpTimer()
	WEnd
	$i=0

EndFunc



;#################################################
; unix Timestamp / useable Function
;#################################################

Func timeToHuman($time)
	$st = Round($time,0)
	$mi = (Round($time,2) - $st)* 100
	if($mi < 0) Then
		$mi = $mi * -1
	EndIf
	return $st&"H "&Round($mi)&"M"
EndFunc

Func SecToTime($sec)
	$min = $sec / 60
	$hour = $min / 60
	if(Round($min) >= 60)Then
		return Round($hour)&" H"
	ElseIf($sec >= 60) Then
		return Round($min)&" M"
	Else
		return Round($sec)&" S"
	EndIf
EndFunc

Func _TimeGetStamp()
	Local $av_Time
	$av_Time = DllCall('CrtDll.dll', 'long:cdecl', 'time', 'ptr', 0)
	If @error Then
		SetError(99)
		Return False
	EndIf
	Return $av_Time[0]
EndFunc


Func _DecimalToHex($hx_dec, $hx_length = 6)

    If IsInt($hx_dec) = 0 Then
        SetError(1)
        MsgBox(0,"Error","Wrong input, try again ...")
        Return ""
    EndIf
    Local $ret = "", $Ii, $hx_tmp, $hx_max
    If $hx_dec < 4294967296 Then
        If $hx_length < 9 Then Return Hex($hx_dec, $hx_length)
        If $hx_length = 21 Then
            $ret = Hex($hx_dec)
            While StringLeft($ret, 1) = "0"
                $ret = StringMid($ret, 2)
            WEnd
            Return $ret
        EndIf
    EndIf
    For $Ii = $hx_length - 1 To 0 Step -1
        $hx_max = 16 ^ $Ii - 1
        If $ret = "" And $hx_length = 21 And $hx_max > $hx_dec Then ContinueLoop
        $hx_tmp = Int($hx_dec/($hx_max+1))
        If $ret = "" And $hx_length = 21 And $Ii > 0 And $hx_tmp = 0 Then ContinueLoop
        ;$ret &= StringMid($HX_REF, $hx_tmp+1, 1)
        $hx_dec -= $hx_tmp * ($hx_max + 1)
    Next
    $ret=String($ret)
    If $hx_length < 21 And StringLen($ret) < $hx_length Then SetError(1)
    Return $ret
EndFunc  ;==>_DecToHex()



;#################################################
;gui loop
;#################################################


While 1
	$msg = GUIGetMsg()
	Switch $msg
		Case $GUI_EVENT_CLOSE
		Send("{w up}")
		send("{s up}")
		Send("{a up}")
		send("{d up}")
		ExitLoop
			Exit
		Case $buttonSave
			saveKeys()
		Case $buttonAddWayPoint
			OpenAionMemory()
			addWP()
		Case $buttonOpenWayPoint
			readWP()
		Case $buttonRun
			WinActivate("AION Client" )
			sleep(500)
;~ 			$attackdist=InputBox("distance to enemy", "distance to enemys before he start his skills"&@crlf&"distance - caster ~ 20 / melees ~ 3","3")
;~ 			$atck = InputBox("attack key", 'add the "attack key" - like rest, or loot key to your skillbar',"0")
;~ 			$hhp = CheckEnemyDead()
;~ 			msgbox(0, "ddd" , $hhp)
			GUICtrlSetData ($buttonRun,"Bot running")
			setShutDownTimer()
			OpenAionMemory()
			ReadMemValues()
			$Run = True
			while $Run = True
				checkShutDown()
				if  ( lookaround() ) Then
;~ 					send($atck)
					KillEnemy()
				Else
					walkPoints()
				EndIf
			WEnd
	EndSwitch
WEnd

;0 4 8 C hex 4bit jumps
	;For $i = 9361000 To 9369000
	;	GUICtrlSetData($status,"SCAN VAR "&$i)
	;	$var = MemReadDLL(_DecimalToHex($i))
	;	if( Round($var,2) > 1000 And Round($var,2) < 6900000) Then
	;		FileWriteLine("mem.txt",_DecimalToHex($i)&" = "&Round($var,2))
	;	EndIf
	;Next

#cs

THE FUTURE!

#include <ButtonConstants.au3>
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>
$gui = GUICreate("tabs for page options", 500, 400)
$tab = GUICtrlCreateTab(-10, -22, 520, 430)
$tabpage1 = GUICtrlCreateTabItem("page1")
$tab1Btn1 = GUICtrlCreateButton("go to page 2", 60, 60, 100, 30)
$tab1Btn2 = GUICtrlCreateButton("go to page 3", 60, 120, 100, 30)
GUICtrlCreateLabel("This is page 1", 100, 200)
$tabpage2 = GUICtrlCreateTabItem("page2")
$tab2Btn1 = GUICtrlCreateButton("go to page 1", 60, 60, 100, 30)
$tab2Btn2 = GUICtrlCreateButton("go to page 4", 60, 120, 100, 30)
GUICtrlCreateLabel("This is page 2", 100, 220)
$tabpage3 = GUICtrlCreateTabItem("page3")
$tab3Btn1 = GUICtrlCreateButton("go to page 2", 60, 60, 100, 30)
$tab3Btn2 = GUICtrlCreateButton("go to page 4", 60, 120, 100, 30)
GUICtrlCreateLabel("This is page 3", 100, 240)
$tabpage4 = GUICtrlCreateTabItem("page4")
$tab4Btn1 = GUICtrlCreateButton("go to page 1", 60, 60, 100, 30)
$tab4Btn2 = GUICtrlCreateButton("go to page 3", 60, 120, 100, 30)
GUICtrlCreateLabel("This is page 4", 100, 260)
GUICtrlCreateTabItem("")
GUICtrlSetState($tabpage1, $GUI_SHOW)
GUISetState()

While 1
    $Msg = GUIGetMsg()
    Switch $Msg
        Case - 3
            Exit
        Case $tab1Btn1
            GUICtrlSetState($tabpage2, $GUI_SHOW)
        Case $tab1Btn2
            GUICtrlSetState($tabpage3, $GUI_SHOW)
        Case $tab2Btn1
            GUICtrlSetState($tabpage1, $GUI_SHOW)
        Case $tab2Btn2
            GUICtrlSetState($tabpage4, $GUI_SHOW)
        Case $tab3Btn1
            GUICtrlSetState($tabpage2, $GUI_SHOW)
        Case $tab3Btn2
            GUICtrlSetState($tabpage4, $GUI_SHOW)
        Case $tab4Btn1
            GUICtrlSetState($tabpage1, $GUI_SHOW)
        Case $tab4Btn2
            GUICtrlSetState($tabpage3, $GUI_SHOW)

    EndSwitch

WEnd
#ce

oot3 · 11/03/2009, 09:06

Wichtig währe noch, dass er nachm wiederbeleben (nach 30 min xD) nicht weiterläuft, sondern stopt...

Nycon · 11/03/2009, 12:08

also ich nutze die letzte version von plany und bin ziemlich zufrieden! Bei den Timings für die Casts muss man eben ein bischen probieren! Meine Frage: Wirds auch die weiter vorne angesprochene Blacklist geben? Also das man Gegner angeben kann die nicht angegriffen werden sollen?