Due to somone who couldnt wait for Ultimate Bot release

[evilimprint]

Ultimate bot had craft spy implemented into it weeks ago. Here is a stand alone craft spy brought to you by Atlantica Development



- Make sure you run as administrator -

From now until release, the ultimate bot project will be hush hush...

[mastinovip]

Virus , Keygen .

SCAN FILE !

[evilimprint]

You are funny troll

[Akeriit]

It's not a funny troll, I also have an alert from my anti virus :/

[evilimprint]

lol what anti virus you got I just posted the virustotal report.

[Akeriit]

I have Avast, i saw your virustotal report, i'm surprised :/
I have to disable my anti virus to download your tool lol

For Avast, it's a "Win32:Evo-gen" problem

[evilimprint]

just do a seach on google. vb.net Win32:Evo-gen

it specificly states Avast throws a false positive on .net applications.. and really the program is not big enough for me to send them a report of a false positive to get it fixed in Avast.

[graphitey]

What is a craft spy?

[aonoob]

How to say.. it's a "use....full" tool which lets you see which + your actual personal craft will come out...

Where i don't really see a sense on it since if you cancel a +0/+1 craft you'll loose your mats....

[evilimprint]

troll with a little brain... the smart thing would be to do is burn through spirit equiptment until you see a string of plus's DUR!

[aonoob]

Question is who is trolling in his micro brain right now...

THIS TOOL ONLY SHOWS THE ACTUAL CRAFT you have...

How this would help you to figure out what the next is?

There don't seems to be a crystal ball implemented....

[evilimprint]

funny because using this tool in my bot.... I have not got 1 +0 craft out of ALOT of crafts..

[aonoob]

lucky i would say... or how you want to explain that just READING out ONE BYTE in memory could/would however influence any future crafts? It shows you what you actually have (how your just started craft will come out) and THAT'S IT! nothing else.

[evilimprint]

well then you can leave your narrow troll mind out of my posts?

your just out for the hard core stuff like me being able to dupe +0's to +10's currently in ao... you cant just take a small tool and figure out how to use it to your advantage.. all you do is troll posts... get on with your bad self.

[aonoob]

No... just wanted to say that it's not a miracle.... easy to do, and since you loose your mats when you cancel a personal craft.. where is the sence...

Here the same (with itemid + batchsize + +result) as autoit source:

#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>
#include <WinAPI.au3>

#region ### START Koda GUI section ### Form=
Global $Form1 = GUICreate("AO Personal Craft Teller", 255, 94, 192, 124)
Global $Label1 = GUICtrlCreateLabel("Item ID:", 8, 16, 41, 17)
Global $Label2 = GUICtrlCreateLabel("Batch Size:", 8, 40, 58, 17)
Global $Label3 = GUICtrlCreateLabel("Result:", 8, 64, 37, 17)
Global $Label4 = GUICtrlCreateLabel("Label4", 88, 16, 68, 17)
Global $Label5 = GUICtrlCreateLabel("Label5", 88, 40, 68, 17)
Global $Label6 = GUICtrlCreateLabel("Label6", 88, 64, 68, 17)
GUISetState(@SW_SHOW)
#endregion ### END Koda GUI section ###

Global $C_ARRAY[6][2]
$C_ARRAY[0][0] = 5
$C_ARRAY[1][1] = 0x21CDD90
$C_ARRAY[2][1] = 0x824
$C_ARRAY[3][1] = 0xC
$C_ARRAY[4][1] = 0x30
$C_ARRAY[5][1] = 0xB18

Global $c_id = 0
Global $c_am = 0
Global $c_pl = 0

Global $title = "Atlantica Online"

Global $hWnd = WinGetHandle($title)
If @error Then
	MsgBox(4096, "Error", "Could not find the correct window")
	Exit
EndIf
Global $Process1 = WinGetProcess($title) ;the window to get PID
If $Process1 = -1 Then
	MsgBox(4096, "ERROR", "Failed to detect process.")
	Exit
EndIf
Global $Mem_Open = _MemoryOpen($Process1) ;must open before you can read address

If $Mem_Open = 0 Then
	MsgBox(4096, "ERROR", "Failed to attach to AO-Memory.")
	Exit
EndIf

Global $ao_mem = _readMem_Array($C_ARRAY, 0)

Global $timer = 0

While 1
	$nMsg = GUIGetMsg()
	Switch $nMsg
		Case $GUI_EVENT_CLOSE
			Exit
	EndSwitch
	getcraft()
WEnd

Func getcraft()
	If $timer = 0 Then
		$timer = TimerInit()
	EndIf
	If TimerDiff($timer) > 1000 Then
		$c_id = _MemoryRead($ao_mem, $Mem_Open, "word")
		$c_am = _MemoryRead($ao_mem + 0x2, $Mem_Open, "word")
		$c_pl = (_MemoryRead($ao_mem + 0x1D, $Mem_Open, "byte")) - 5
		GUICtrlSetData($Label4, $c_id)
		GUICtrlSetData($Label5, $c_am)
		GUICtrlSetData($Label6, $c_pl)
		$timer = 0
	EndIf
EndFunc   ;==>getcraft

#include-once


Opt('MustDeclareVars', 1)
#region _Memory
;==================================================================================
; AutoIt Version:	3.1.127 (beta)
; Language:			English
; Platform:			All Windows
; Author:			Nomad
; Requirements:		These functions will only work with beta.
; ALL RIGHTS RESERVED ON THIS FILE BY THE ORIGINAL AUTHOR !!! NOT NEURONET !!!
;==================================================================================
; Credits:	wOuter - These functions are based on his original _Mem() functions.
;			But they are easier to comprehend and more reliable.  These
;			functions are in no way a direct copy of his functions.  His
;			functions only provided a foundation from which these evolved.
;==================================================================================
;
; Functions:
;
;==================================================================================
; Function:			_MemoryOpen($iv_Pid[, $iv_DesiredAccess[, $iv_InheritHandle]])
; Description:		Opens a process and enables all possible access rights to the
;					process.  The Process ID of the process is used to specify which
;					process to open.  You must call this function before calling
;					_MemoryClose(), _MemoryRead(), or _MemoryWrite().
; Parameter(s):		$iv_Pid - The Process ID of the program you want to open.
;					$iv_DesiredAccess - (optional) Set to 0x1F0FFF by default, which
;										enables all possible access rights to the
;										process specified by the Process ID.
;					$iv_InheritHandle - (optional) If this value is TRUE, all processes
;										created by this process will inherit the access
;										handle.  Set to 1 (TRUE) by default.  Set to 0
;										if you want it FALSE.
; Requirement(s):	None.
; Return Value(s): 	On Success - Returns an array containing the Dll handle and an
;								 open handle to the specified process.
;					On Failure - Returns 0
;					@Error - 0 = No error.
;							 1 = Invalid $iv_Pid.
;							 2 = Failed to open Kernel32.dll.
;							 3 = Failed to open the specified process.
; Author(s):		Nomad
; Note(s):
;==================================================================================
Func _MemoryOpen($iv_Pid, $iv_DesiredAccess = 0x1F0FFF, $iv_InheritHandle = 1)

	If Not ProcessExists($iv_Pid) Then
		SetError(1)
		Return 0
	EndIf

	Local $ah_Handle[2] = [DllOpen('kernel32.dll')]

	If @error Then
		SetError(2)
		Return 0
	EndIf

	Local $av_OpenProcess = DllCall($ah_Handle[0], 'int', 'OpenProcess', 'int', $iv_DesiredAccess, 'int', $iv_InheritHandle, 'int', $iv_Pid)

	If @error Then
		DllClose($ah_Handle[0])
		SetError(3)
		Return 0
	EndIf

	$ah_Handle[1] = $av_OpenProcess[0]

	Return $ah_Handle

EndFunc   ;==>_MemoryOpen

;==================================================================================
; Function:			_MemoryRead($iv_Address, $ah_Handle[, $sv_Type])
; Description:		Reads the value located in the memory address specified.
; Parameter(s):		$iv_Address - The memory address you want to read from. It must
;								  be in hex format (0x00000000).
;					$ah_Handle - An array containing the Dll handle and the handle
;								 of the open process as returned by _MemoryOpen().
;					$sv_Type - (optional) The "Type" of value you intend to read.
;								This is set to 'dword'(32bit(4byte) signed integer)
;								by default.  See the help file for DllStructCreate
;								for all types.  An example: If you want to read a
;								word that is 15 characters in length, you would use
;								'char[16]' since a 'char' is 8 bits (1 byte) in size.
; Return Value(s):	On Success - Returns the value located at the specified address.
;					On Failure - Returns 0
;					@Error - 0 = No error.
;							 1 = Invalid $ah_Handle.
;							 2 = $sv_Type was not a string.
;							 3 = $sv_Type is an unknown data type.
;							 4 = Failed to allocate the memory needed for the DllStructure.
;							 5 = Error allocating memory for $sv_Type.
;							 6 = Failed to read from the specified process.
; Author(s):		Nomad
; Note(s):			Values returned are in Decimal format, unless specified as a
;					'char' type, then they are returned in ASCII format.  Also note
;					that size ('char[size]') for all 'char' types should be 1
;					greater than the actual size.
;==================================================================================
Func _MemoryRead($iv_Address, $ah_Handle, $sv_Type = 'dword')

	If Not IsArray($ah_Handle) Then
		SetError(1)
		Return 0
	EndIf

	Local $v_Buffer = DllStructCreate($sv_Type)

	If @error Then
		SetError(@error + 1)
		Return 0
	EndIf

	DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')

	If Not @error Then
		Local $v_Value = DllStructGetData($v_Buffer, 1)
		Return $v_Value
	Else
		SetError(6)
		Return 0
	EndIf

EndFunc   ;==>_MemoryRead

;==================================================================================
; Function:			_MemoryWrite($iv_Address, $ah_Handle, $v_Data[, $sv_Type])
; Description:		Writes data to the specified memory address.
; Parameter(s):		$iv_Address - The memory address which you want to write to.
;								  It must be in hex format (0x00000000).
;					$ah_Handle - An array containing the Dll handle and the handle
;								 of the open process as returned by _MemoryOpen().
;					$v_Data - The data to be written.
;					$sv_Type - (optional) The "Type" of value you intend to write.
;								This is set to 'dword'(32bit(4byte) signed integer)
;								by default.  See the help file for DllStructCreate
;								for all types.  An example: If you want to write a
;								word that is 15 characters in length, you would use
;								'char[16]' since a 'char' is 8 bits (1 byte) in size.
; Return Value(s):	On Success - Returns 1
;					On Failure - Returns 0
;					@Error - 0 = No error.
;							 1 = Invalid $ah_Handle.
;							 2 = $sv_Type was not a string.
;							 3 = $sv_Type is an unknown data type.
;							 4 = Failed to allocate the memory needed for the DllStructure.
;							 5 = Error allocating memory for $sv_Type.
;							 6 = $v_Data is not in the proper format to be used with the
;								 "Type" selected for $sv_Type, or it is out of range.
;							 7 = Failed to write to the specified process.
; Author(s):		Nomad
; Note(s):			Values sent must be in Decimal format, unless specified as a
;					'char' type, then they must be in ASCII format.  Also note
;					that size ('char[size]') for all 'char' types should be 1
;					greater than the actual size.
;==================================================================================
Func _MemoryWrite($iv_Address, $ah_Handle, $v_Data, $sv_Type = 'dword')

	If Not IsArray($ah_Handle) Then
		SetError(1)
		Return 0
	EndIf

	Local $v_Buffer = DllStructCreate($sv_Type)

	If @error Then
		SetError(@error + 1)
		Return 0
	Else
		DllStructSetData($v_Buffer, 1, $v_Data)
		If @error Then
			SetError(6)
			Return 0
		EndIf
	EndIf

	DllCall($ah_Handle[0], 'int', 'WriteProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')

	If Not @error Then
		Return 1
	Else
		SetError(7)
		Return 0
	EndIf

EndFunc   ;==>_MemoryWrite

;==================================================================================
; Function:			_MemoryClose($ah_Handle)
; Description:		Closes the process handle opened by using _MemoryOpen().
; Parameter(s):		$ah_Handle - An array containing the Dll handle and the handle
;								 of the open process as returned by _MemoryOpen().
; Return Value(s):	On Success - Returns 1
;					On Failure - Returns 0
;					@Error - 0 = No error.
;							 1 = Invalid $ah_Handle.
;							 2 = Unable to close the process handle.
; Author(s):		Nomad
; Note(s):
;==================================================================================
Func _MemoryClose($ah_Handle)

	If Not IsArray($ah_Handle) Then
		SetError(1)
		Return 0
	EndIf

	DllCall($ah_Handle[0], 'int', 'CloseHandle', 'int', $ah_Handle[1])
	If Not @error Then
		DllClose($ah_Handle[0])
		Return 1
	Else
		DllClose($ah_Handle[0])
		SetError(2)
		Return 0
	EndIf

EndFunc   ;==>_MemoryClose

;==================================================================================
; Function:			SetPrivilege( $privilege, $bEnable )
; Description:		Enables (or disables) the $privilege on the current process
;                   (Probably) requires administrator privileges to run
;
; Author(s):		Larry (from autoitscript.com's Forum)
; Notes(s):
; http://www.autoitscript.com/forum/index.php?s=&showtopic=31248&view=findpost&p=223999
;==================================================================================

Func SetPrivilege($privilege, $bEnable)
;~     Const $TOKEN_ADJUST_PRIVILEGES = 0x0020
;~     Const $TOKEN_QUERY = 0x0008
;~     Const $SE_PRIVILEGE_ENABLED = 0x0002
	Local $hToken, $SP_auxret, $SP_ret, $hCurrProcess, $nTokens, $nTokenIndex, $priv
	$nTokens = 1
	Local $LUID = DllStructCreate("dword;int")
	If IsArray($privilege) Then $nTokens = UBound($privilege)
	Local $TOKEN_PRIVILEGES = DllStructCreate("dword;dword[" & (3 * $nTokens) & "]")
	Local $NEWTOKEN_PRIVILEGES = DllStructCreate("dword;dword[" & (3 * $nTokens) & "]")
	Local $hCurrProcess = DllCall("kernel32.dll", "hwnd", "GetCurrentProcess")
	Local $SP_auxret = DllCall("advapi32.dll", "int", "OpenProcessToken", "hwnd", $hCurrProcess[0], _
			"int", BitOR($TOKEN_ADJUST_PRIVILEGES, $TOKEN_QUERY), "int_ptr", 0)
	If $SP_auxret[0] Then
		$hToken = $SP_auxret[3]
		DllStructSetData($TOKEN_PRIVILEGES, 1, 1)
		$nTokenIndex = 1
		While $nTokenIndex <= $nTokens
			If IsArray($privilege) Then
				$priv = $privilege[$nTokenIndex - 1]
			Else
				$priv = $privilege
			EndIf
			Local $ret = DllCall("advapi32.dll", "int", "LookupPrivilegeValue", "str", "", "str", $priv, _
					"ptr", DllStructGetPtr($LUID))
			If $ret[0] Then
				If $bEnable Then
					DllStructSetData($TOKEN_PRIVILEGES, 2, $SE_PRIVILEGE_ENABLED, (3 * $nTokenIndex))
				Else
					DllStructSetData($TOKEN_PRIVILEGES, 2, 0, (3 * $nTokenIndex))
				EndIf
				DllStructSetData($TOKEN_PRIVILEGES, 2, DllStructGetData($LUID, 1), (3 * ($nTokenIndex - 1)) + 1)
				DllStructSetData($TOKEN_PRIVILEGES, 2, DllStructGetData($LUID, 2), (3 * ($nTokenIndex - 1)) + 2)
				DllStructSetData($LUID, 1, 0)
				DllStructSetData($LUID, 2, 0)
			EndIf
			$nTokenIndex += 1
		WEnd
		$ret = DllCall("advapi32.dll", "int", "AdjustTokenPrivileges", "hwnd", $hToken, "int", 0, _
				"ptr", DllStructGetPtr($TOKEN_PRIVILEGES), "int", DllStructGetSize($NEWTOKEN_PRIVILEGES), _
				"ptr", DllStructGetPtr($NEWTOKEN_PRIVILEGES), "int_ptr", 0)
		Local $f = DllCall("kernel32.dll", "int", "GetLastError")
	EndIf
	$NEWTOKEN_PRIVILEGES = 0
	$TOKEN_PRIVILEGES = 0
	$LUID = 0
	If $SP_auxret[0] = 0 Then Return 0
	$SP_auxret = DllCall("kernel32.dll", "int", "CloseHandle", "hwnd", $hToken)
	If Not $ret[0] And Not $SP_auxret[0] Then Return 0
	Return $ret[0]
EndFunc   ;==>SetPrivilege

Func _readMem_Array($MemArray, $value = 1, $type = "dword")
	Local $LastRead

	If $MemArray[1][0] <> "$Static" And $value = 1 Then
		;Use the saved LastRead Address to skip for Loop
		$LastRead = $MemArray[1][0]
	Else
		For $i = 1 To $MemArray[0][0]
			$LastRead = _MemoryRead($LastRead, $Mem_Open)
			;If $i isnt the last Element in the Array
			If $i <= $MemArray[0][0] Then
				;Add Offset to $LastRead
				$LastRead = $LastRead + $MemArray[$i][1]
			EndIf
		Next
		;Save the last Address so the next readMem can simply use it
		;The Static key will be overwriten by the Address
		$MemArray[1][0] = $LastRead
	EndIf
	If $value = 1 Then
		;Read the Value out of the LastRead
		$LastRead = _MemoryRead($LastRead, $Mem_Open, $type)
		;otherwise the LastRead Address is returned
	EndIf

	Return $LastRead
EndFunc   ;==>_readMem_Array
#endregion _Memory