Bot Dead Pixel

[joana]

Hola!

Pues estaba interesada en hacer un bot a algún minijuego. Me he encontrado con este juego:

http://www.minijuegos.com/Dead-Pixel/12583

Bien es muy fácil, hay que buscar un rectángulo distinto al resto, en realidad solo con encontrar un pixel de ese rectángulo es suficiente y clickar y pasas al siguiente nivel.

Entonces he pensado usaré PixelSearch! pero no lo he sabido usar puesto que la función te busca un Pixel al cual tu le das un color y si coincide devuelve coordenadas. Sin embargo lo que busco aquí es un pixel distinto al resto.

Bueno lo que me gustaría es encontrar la forma de buscar un pixel distinto al resto, pero que sea una forma sencilla y rápida.

Aquí pongo código para que me entendáis, veréis que es MUUUY lento. Porque he usado como búsqueda para recorrer todos los puntos... Así que imaginaros...

Código: Seleccionar todo

;Game Bot - Dead Pixel
;http://www.minijuegos.com/Dead-Pixel/12583

HotKeySet("{º}", "_start")
HotKeySet("{-}", "_finish")

While 1
	Sleep(500)
WEnd

Func _start()
	;While 1
		$NotFounded = True
		$color = PixelGetColor(344, 282) ;end point 849, 594 !Esto cambiar segun las coordenadas del recuadro a buscar.
		$x = 344+5 
		$y = 282
		$currColor = PixelGetColor($x,$y)
		While ($currColor = $color) & $NotFounded
			ToolTip($x & "." & $y,400,400)
			Mousemove($x,$y) ;Para visualizar en que punto de la busqueda estamos.
			if $currColor = $color Then
				$x = $x+3 ;Le he puesto 3 para agilizar un poco la búsqueda, pero igualmente es lentisima.
				If $x >= 849 Then
					$x = 344
					$y = $y+3 ;Le he puesto 3 para agilizar un poco la búsqueda, pero igualmente es lentisima.
					If $y >= 594 Then
						MsgBox(0, "Not Found","Not Found!")
						Exit
					EndIf
				EndIf
			Else
				$NotFounded = False
				MouseClick("left",$x,$y,1,10) ;Cuando lo encuentra le da click que es lo que pide el juego.
			EndIf
			$currColor = PixelGetColor($x,$y)

		WEnd
	;WEnd
EndFunc

Func _finish()
	Exit
EndFunc

Estoy abierta a cualquier consejo, espero que lo depuréis y comentéis todo lo que se os ocurra!

Gracias

[Chefito]

Mmmmmm....lo he estado mirando y se puede mejorar muchísimo. Vamos, que yo lo escribiría desde cero utilizando la api de windows getpixel (mucho más rápida que pixelgetcolor de autoit), utilizaría un for optimizado para intentar conseguir velocidad (los cuadrados, por lo menos al principio, son de un tamaño 16x16, luego 8x8, y ya no he seguido jugando ), y cambiaría otras cosas, como que insertaría el propio juego en una gui de autoit (_IECreateEmbedded, queda más bonito y profesional), pulsaría con controlclick, etc. Vamos, lo cambiaría casi todo .

Igualmente, aunque hiciese todo esto hay dos problemas, uno evitable y otro inevitable.
El evitable es que el cuadradito se irá reduciendo y cada vez costaría más tiempo encontrarlo. Por tanto, puede que mi primera solución no fuese del todo factible y hubiese que encontrar otra solución alternativa más complicada (se me está ocurriendop tirar de gdiplus.....algo bastante dificil).
La inevitable es que no valdría buscar un pixel distinto al del fondo, ya que al pulsar el cuadradito, se va lentamente dejando una estela de puntos de su mismo color, con lo que se podría encontrar estos colores antes de encontrar el cuadradito siguiente y darte unas coordenadas erroneas. Por esta razón habría que buscar otro método.

Saludos.

[joana]

Ahora me pongo a ojear lo que comentas, concuerdo contigo habrá que cambiar todo xD.

Lo que hay alguna forma de usar el PixelSearch a la inversa? En vez de buscar un pixel buscar justamente el primer pixel distinto?

Gracias por coments,

[BasicOs]

Realmente Pixelsearch tiene un parámetro para ajustar la sensibilidad, y que la diferencia entre pixeles sea regulada para ejecutar un "encontrado". No obstante siempre puedes comparar pixeles con otros pixeles grabados, y por otro lado con un color con un valor, por ejemplo si el pixel es rojo, y si el siguiente es blanco puedes hacer que salte un aviso o de un valor,
ejemplo para pixeles consecutivos de manera muy por encima:
if un pixel es blanco
if el siguiente a la derecha es rojo

No se si te refieres a esto¿? No obstante hay muchos tópicos estos dias de las funciones pixel, que te permiten dar inteligencia o reconocimiento de colores, matices, textos, dibujos etc, parecido al OCR.
Salu22:)

[joana]

Lo de buscar un pixel y una vez encontrado buscar otro es buena idea. Ha sido revelador del plan "Ya sé taichí!"

Pero sabéis si existe alguna función que en vez de buscar la coordenada de un Pixel de color "Negro", le digas búscame la coordenada del primer Pixel NO "Blanco".

Gracheee

[BasicOs]

Ok.
Hay que hacer un if
Algo como
Rastrear todos los pixeles de la pantalla
While
$elpixelencontrado=BuscaSiguientecoordenadadepixelenlapantalla()
If not $elpixelencontrado=$elpixelblanco then
Encontrado!!!!!!! Con msgbox()
Endif
Salu22:)

[Chefito]

Mmmmm, que interés por el bot .
Como he visto interés por el tema, y no os voy a mentir, me es interesante el tema de captar un color/objeto que no conoces, me he puesto a programar un poquito.
No es tan fácil como parece.
Mi primer intento fue con la api getpixel como dice anteriormente, pero iba demasiado lento el recorrido de la imagen (objeto). Como el cuadrado es grande (he puesto el juego para que el primer cuadrado sea de 16x16 pixeles), decidí ganar velocidad pegando saltos en el for de 15 en 15 (Ejemplo: for $x=0 to 600 step 15). Lo hice en los dos for (ancho y largo). Así gané mucha velocidad, pero aun era insuficiente. Además, cuando llegas al nivel 50 el cuadrado se reduce a 8x8. Con los saltos gano menos velocidad en este caso.
Pero ese no es el mayor problema chicos. Lo peor es que cuando aciertas al cliquear un cuadrado, este sale hacía arriba con una estela de cuadraditos muy pequeños. Que ocurre con esto? Que en el siguiente nivel ya hay más de 2 colores en el dibujo. Y si cliqueas de nuevo rapidamente (ese es el objetivo del bot no?) pues aparece otro cuadrado en movimiento con otra estela. Así hasta mucho. Vamos, un problemón de los gordos .

Por eso tuve que cambiar de rumbo la programación y empezar de 0. Ahora estoy utilizando gdiplus. Lo que hago es capturar el trozo de pantalla que me interesa y tratar los pixeles directamente en memoria. Es muchiiiiiiiiiiiiiiiiiiiiiisimo más rápido. Pero como reconozco el verdadero cuadrado, y no los que se han cliqueado ya y están en movimiento? Pues cuando detecto un color distinto de el de fondo, analizo sus píxeles próximos, y veo si es verdaderamente un cuadrado 16x16. En definitiva, hago una especie de detección de formas.

El primer intento me salió bastante bien. Casi todos los cuadrados los conseguía cliquear con 100 puntos. Pero algunos se me escapaban. No se si por la forma en que hice la detección del cuadrado, el modo de procesar de autoit, etc . Volví a pensar y quise reducir un poco la detección del cuadrado para ganar algo de velocidad, pero me está dando algunos problemas. Primeramente hacía dos for de 0 a 15 para detectar todo el cuadrado, pero pensé, porque revisar todos los píxeles? Casi seguro que es el cuadrado que busco si coincide con los píxeles de las 4 esquinas interiores (16x16), y los píxeles de las 4 esquinas exteriores debían coincidir con el color de fondo.

Explicación de lo último anterior:
Si el cuadrado que busco es 16x16, va a ir del (0,0) , (0,15) , (15,0) , (15,15). Estas serían las cuatro esquinas interiores del cuadrado.
Y las cuatro esquinas exteriores, pegadas a las interiores (las que tienen que tener el color de fondo), podrían ser por ejemplo (-1,-1) , (-1, 16) , (16, -1), (16,16).
Espero haber explicado más o menos la idea.

No se si será el método más adecuado (supongo que habrá mejores), pero más o menos debería de valer.

Pero no acaban ahí los problemas . Resulta que el cuadrado puede estar pegado al marco de la imagen. Por lo que uno o dos de los lados exteriores ya no son del color de fondo, sino del marco. Pufffffff.
Solución. Más condiciones dentro de la revisión de los píxeles. Podemos decir que en vez de el color exterior sea igual al de fondo, ponemos que sea distinto al del cuadrado (la más fácil a mi parecer). Otra sería ver en que posiciones está el cuadrado una vez detectado, y no comparar los lados que estén pegados al marco, o compararlos con el color del marco, o yo que se .

Pero no contentos con ese último problema, resulta que justo al lado del marco gris, hay dos filas en dos de los lados con el color de fondo sobreado, que cambia el color del cuadrado cuando está ahí. Oooootraaaa cosa a tener en cuenta.

Bueno, una vez que se superen todos estos problemas, analizaría los cuadrados 8x8, pero eso sería adaptar los valores ya hechos.

Si hago algo decente, aunque tenga algún fallo lo cuelgo.

Saludos.

[joana]

Ok.
Hay que hacer un if
Algo como
Rastrear todos los pixeles de la pantalla
While
$elpixelencontrado=BuscaSiguientecoordenadadepixelenlapantalla()
If not $elpixelencontrado=$elpixelblanco then
Encontrado!!!!!!! Con msgbox()
Endif
Salu22:)

xD pero esto debe ser muy lento, no?

Aunque si es la solución

Mmmmm, que interés por el bot .
Como he visto interés por el tema, y no os voy a mentir, me es interesante el tema de captar un color/objeto que no conoces, me he puesto a programar un poquito.
No es tan fácil como parece.
Mi primer intento fue con la api getpixel como dice anteriormente, pero iba demasiado lento el recorrido de la imagen (objeto). Como el cuadrado es grande (he puesto el juego para que el primer cuadrado sea de 16x16 pixeles), decidí ganar velocidad pegando saltos en el for de 15 en 15 (Ejemplo: for $x=0 to 600 step 15). Lo hice en los dos for (ancho y largo). Así gané mucha velocidad, pero aun era insuficiente. Además, cuando llegas al nivel 50 el cuadrado se reduce a 8x8. Con los saltos gano menos velocidad en este caso.
Pero ese no es el mayor problema chicos. Lo peor es que cuando aciertas al cliquear un cuadrado, este sale hacía arriba con una estela de cuadraditos muy pequeños. Que ocurre con esto? Que en el siguiente nivel ya hay más de 2 colores en el dibujo. Y si cliqueas de nuevo rapidamente (ese es el objetivo del bot no?) pues aparece otro cuadrado en movimiento con otra estela. Así hasta mucho. Vamos, un problemón de los gordos .

Por eso tuve que cambiar de rumbo la programación y empezar de 0. Ahora estoy utilizando gdiplus. Lo que hago es capturar el trozo de pantalla que me interesa y tratar los pixeles directamente en memoria. Es muchiiiiiiiiiiiiiiiiiiiiiisimo más rápido. Pero como reconozco el verdadero cuadrado, y no los que se han cliqueado ya y están en movimiento? Pues cuando detecto un color distinto de el de fondo, analizo sus píxeles próximos, y veo si es verdaderamente un cuadrado 16x16. En definitiva, hago una especie de detección de formas.

El primer intento me salió bastante bien. Casi todos los cuadrados los conseguía cliquear con 100 puntos. Pero algunos se me escapaban. No se si por la forma en que hice la detección del cuadrado, el modo de procesar de autoit, etc . Volví a pensar y quise reducir un poco la detección del cuadrado para ganar algo de velocidad, pero me está dando algunos problemas. Primeramente hacía dos for de 0 a 15 para detectar todo el cuadrado, pero pensé, porque revisar todos los píxeles? Casi seguro que es el cuadrado que busco si coincide con los píxeles de las 4 esquinas interiores (16x16), y los píxeles de las 4 esquinas exteriores debían coincidir con el color de fondo.

Explicación de lo último anterior:
Si el cuadrado que busco es 16x16, va a ir del (0,0) , (0,15) , (15,0) , (15,15). Estas serían las cuatro esquinas interiores del cuadrado.
Y las cuatro esquinas exteriores, pegadas a las interiores (las que tienen que tener el color de fondo), podrían ser por ejemplo (-1,-1) , (-1, 16) , (16, -1), (16,16).
Espero haber explicado más o menos la idea.

No se si será el método más adecuado (supongo que habrá mejores), pero más o menos debería de valer.

Pero no acaban ahí los problemas . Resulta que el cuadrado puede estar pegado al marco de la imagen. Por lo que uno o dos de los lados exteriores ya no son del color de fondo, sino del marco. Pufffffff.
Solución. Más condiciones dentro de la revisión de los píxeles. Podemos decir que en vez de el color exterior sea igual al de fondo, ponemos que sea distinto al del cuadrado (la más fácil a mi parecer). Otra sería ver en que posiciones está el cuadrado una vez detectado, y no comparar los lados que estén pegados al marco, o compararlos con el color del marco, o yo que se .

Pero no contentos con ese último problema, resulta que justo al lado del marco gris, hay dos filas en dos de los lados con el color de fondo sobreado, que cambia el color del cuadrado cuando está ahí. Oooootraaaa cosa a tener en cuenta.

Bueno, una vez que se superen todos estos problemas, analizaría los cuadrados 8x8, pero eso sería adaptar los valores ya hechos.

Si hago algo decente, aunque tenga algún fallo lo cuelgo.

Saludos.

Pues, tengo ganas de ver el código como te va quedando. Ya sé que es una chorrada de bot. Pero estoy muy interesada en aprender. Sé que es difícil, pero hay poco material y prácticamente solo os tengo a vosotros (foro).

Un saludo y gracias a los dos, por cierto os habéis puesto de acuerdo con el número de mensajes 1744. :O

[Chefito]

AUTOIT VS DEAD PIXEL - MEDALLA DE PLATA PARA AUTOIT (APROXIMADAMENTE ENTRE 9800 Y 9850 PUNTOS DE 10000)

Bueno, más o menos he hecho un código operativo digamos....... al 80%? . El código funciona casi siempre bien, lo que pasa que tiene algunos fallos que no he investigado (no se muy bien por que pasan), y otros que paso de corregir, ya que tendría que seguir escribiendo más código y calentándome la cabeza........y paso .

Vamos a ver los fallos raros:
Uno es que a veces pega como un pequeño frenazo que hace que el programa no funcione al 100%. No se si será por algo del gdiplus o del modo que he programado esto . O porque en ese momento hay muchos colores que analizar y se relentiza el script. Quien sabe.
Otro es que a veces (muy pocas veces) el programa no cliquea el recuadro que debe y falla (le cuesta una vida). Al ocurrir esto puede pasar varias cosas, que se pare totalmente o que no vaya bien a causa de que el contador de niveles se descuadre. Esta última causa no se por que ocurre. Puede que falle por culpa de algún recuadro de los que se mueven y se equivoque. Esto se corregiría tratando mejor el algoritmo de detección de formas.

Y los fallos evitables son:

Como ya dije en el post anterior, tendríamos que tratar los cuadrados que salen pegados a los bordes de una forma distinta, ya que el modo que he ideado no vale. Se podría hacer, pero como he dicho antes, no me apetece meterme más a fondo con el asunto. Si a alguien le interesa le puedo explicar lo que yo haría para solucionar este problema.

No explico lo que hace el programa, ya que está comentado en mi post anterior y también he comentado algo el programa. A quien le interese que lea el post anterior.
Si no entendéis algo preguntar, que si puedo os lo explico.

IMPORTANTE: Este flash inicialmente carga un anuncio. Os lo podéis saltar dando al botón saltar anuncio. CUANDO APAREZCA LA PANTALLA QUE PONE PLAY EN COLOR BLANCO Y DEAD PIXEL EN AZUL, DARLE AL BOTÓN DE ABAJO QUE PONE "PLAY (JUGAR)". En ese momento el script jugará solo. Veréis que velocidad .

Código: Seleccionar todo

;Game Bot - Dead Pixel
;http://www.minijuegosgratis.com/flash1234/no_hotlink/deadpixel.swf

#include <GDIPlus.au3>
#include <GDIPlusConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <IE.au3>
#include <ScreenCapture.au3>

Opt("PixelCoordMode", 0) ;1=absolute, 0=relative, 2=client

Local $colorAnterior=0
Local $oIE = _IECreateEmbedded()	;creo el control insertado IE.
Local $Gui=GUICreate("Juego Dead Pixel", 665, 580, _
        (@DesktopWidth - 640) / 2, (@DesktopHeight - 580) / 2, _
        $WS_OVERLAPPEDWINDOW + $WS_VISIBLE + $WS_CLIPSIBLINGS + $WS_CLIPCHILDREN)
GUICtrlCreateObj($oIE, 10, 10, 644, 485)	;creo el control insertado IE.
Local $GUI_Button_Back = GUICtrlCreateButton("PLAY (JUGAR)", 250, 540, 100, 30)

GUISetState() ;Show GUI

_IENavigate($oIE, "http://www.minijuegosgratis.com/flash1234/no_hotlink/deadpixel.swf")

While 1
    Local $msg = GUIGetMsg()
    Select
        Case $msg = $GUI_EVENT_CLOSE
            ExitLoop
        Case $msg = $GUI_Button_Back
			$hwndJuego=ControlGetHandle($Gui,"","MacromediaFlashPlayerActiveX1")	;obtengo el handle del control flash del juego
			_GDIPlus_Startup()
			$contador=1			;contador de los niveles. Hay 100 en total, 50 de cuadrados 16x16 y 50 de 8x8.
			$maxLadosIn=15		;máximo de los lados interiores del cuadrado. Son de 16 pixeles. Van del 0 al 15.
			$maxLadosOut=16		;máximo de los lados exteriores del cuadrado. Es justo cuando empieza el fondo.
			
			;Comprueba dos pixeles, uno perteneciente a la palabra "PLAY" y otro a "DEAD PIXEL".
			$play=PixelGetColor(321,240,$hwndJuego)
			$DeadPixel=PixelGetColor(290,78,$hwndJuego)
			If $play=16711422 And $deadpixel=39578 Then	;si los pixeles son los de la palabra podeis darle al botón "PLAY" y empezar la partida.
				ControlClick($Gui,"","MacromediaFlashPlayerActiveX1","left",1,321,240)
				Sleep(20)
				while 1
					$hBitmap=_ScreenCapture_CaptureWnd("",$hwndJuego,0,0,-1,-1,False)	;capturo la imagen del control flash (el juego)
					$pBitmap=_GDIPlus_BitmapCreateFromHBITMAP($hBitmap)
					;bloqueo los bits con los que voy a trabajar en modo lectura.
					$BitmapData = _GDIPlus_BitmapLockBits($pBitmap, 0, 0, _GDIPlus_ImageGetWidth($pBitmap), _GDIPlus_ImageGetHeight($pBitmap), $GDIP_ILMREAD, $GDIP_PXF32RGB)
					;cojo datos de la estructura anterior que nos facilitarán el poder trabajar con las posiciones exactas de los píxeles en memoria.
					$stride = DllStructGetData($BitmapData, "Stride") 
					$ptr = DllStructGetData($BitmapData, "Scan0") 
					
					;miro cual es el color de fondo.
					$struct = DllStructCreate("dword", $ptr + $stride * 50 + 4 * 70) ; 4 bytes BBGGRRXX
					$colorFondo = DllStructGetData($struct, 1) 
					$struct = DllStructCreate("dword", $ptr + $stride * 50 + 4 * 570) ; 4 bytes BBGGRRXX
					$colorAux = DllStructGetData($struct, 1) 
		;~ 			ConsoleWrite($colorFondo & " " & $colorAux & @CR)
					If $colorFondo<>$colorAux Then
						$struct = DllStructCreate("dword", $ptr + $stride * 360 + 4 * 70) ; 4 bytes BBGGRRXX
						$color = DllStructGetData($struct, 1) 
						If $color=$colorAux Then
							$colorFondo=$color
						EndIf
					EndIf
					;realizo dos bucles que recorren toda la pantalla donde puede estar el cuadrado a encontrar. Salto de 8 en 8 para hacerlo más rápido.
					For $x=65 To 574 Step 8;$maxLadosOut
						For $y=46 To 363 Step 8;$maxLadosOut

							$struct = DllStructCreate("dword", $ptr + $stride * $y + 4 * $x) ; 4 bytes BBGGRRXX
							$color = DllStructGetData($struct, 1) 
							If $color<>$colorFondo Then		;si encuentro un color distinto al color de fondo entro en la condición.
		;~ 						ConsoleWrite($x & "," & $y & " " & $color & @CR)
								$x1=$x
								Do		;miro cual puede ser el primer pixel en la posición x del cuadrado.
									$x1-=1
									$struct = DllStructCreate("dword", $ptr + $stride * $y + 4 * $x1) ; 4 bytes BBGGRRXX
									$colorCuadrado = DllStructGetData($struct, 1) 
								Until $colorCuadrado<>$color

								$x1+=1
								$struct = DllStructCreate("dword", $ptr + $stride * $y + 4 * ($x1+$maxLadosIn)) ; 4 bytes BBGGRRXX
								$colorCuadrado = DllStructGetData($struct, 1) 
		;~ 								MsgBox(0,"",$colorCuadrado2=$colorCuadrado)
								If $colorCuadrado=$color Then
									$y1=$y
									Do		;miro cual puede ser el primer pixel en la posición y del cuadrado.
										$y1-=1
										$struct = DllStructCreate("dword", $ptr + $stride * $y1 + 4 * $x) ; 4 bytes BBGGRRXX
										$colorCuadrado = DllStructGetData($struct, 1) 
									Until $colorCuadrado<>$color

									$y1+=1

									$clickCuadrado=True
		;~ 							ConsoleWrite($colorCuadrado &","&$color&@cr)
		
									;compruebo los cuadrados vecinos (las cuatro esquinas) para ver si tienen el mismo color que el encontrado, y así puede que sea ese el cuadrado.
									For $n1=0 To $maxLadosIn Step $maxLadosIn
										For $n2=0 To $maxLadosIn Step $maxLadosIn
											$struct = DllStructCreate("dword", $ptr + $stride * ($y1+$n2) + 4 * ($x1+$n1)) ; 4 bytes BBGGRRXX
											$colorCuadrado = DllStructGetData($struct, 1) 
		;~ 									ConsoleWrite("lados"&@cr)
											If $colorCuadrado<>$color Then
		;~ 										ConsoleWrite($color&@cr)
												$clickCuadrado=False
												ExitLoop(2)
											EndIf
										Next
									Next

									;me aseguro que es un cuadrado con la medida exacta mirando los pixeles exteriores (justos los fronterizos)
									If $clickCuadrado Then
										For $n2=-1 To $maxLadosOut Step $maxLadosOut+1
											$struct = DllStructCreate("dword", $ptr + $stride * ($y1+$n2) + 4 * ($x1+$maxLadosOut)) ; 4 bytes BBGGRRXX
											$colorCuadrado = DllStructGetData($struct, 1) ;color 
											If $colorCuadrado<>$colorFondo Then
												$clickCuadrado=False
												ExitLoop(2)
											EndIf
										Next
										If $clickCuadrado Then		;si se ha encontrado el cuadrado, cliqueo la posición inicial encontrada (x1,y1) más 4.
											$contador+=1
											ControlClick($Gui,"","MacromediaFlashPlayerActiveX1","left",1,$x1+4,$y1+4)
											If $contador=50 Then	;si el contador llega a 50 (nivel 50) cambio los valores para trabajar con los cuadrados de tamaño 8x8.
												ConsoleWrite(">>50"&@cr)
												$maxLadosIn=7
												$maxLadosOut=8
											ElseIf $contador=100 Then		;Si llega al nivel 100 paro de buscar cuadrados.
												ConsoleWrite(">>100"&@cr)
												ExitLoop(3)
											EndIf
			;~ 								ConsoleWrite($x1+66 &"," & $y1+44 & @CR)
			;~ MsgBox(0,"",$x1+65&","&$y1+46)
											ExitLoop(2)
										EndIf
									EndIf

								EndIf


							EndIf
						Next
					Next
					_GDIPlus_BitmapUnlockBits($pBitmap, $BitmapData)
					_WinAPI_DeleteObject($hBitmap)
					_GDIPlus_ImageDispose($pBitmap)
			;~ 		Sleep(1)
				WEnd
				_GDIPlus_BitmapUnlockBits($pBitmap, $BitmapData)
				_WinAPI_DeleteObject($hBitmap)
				_GDIPlus_ImageDispose($pBitmap)

				_GDIPlus_Shutdown()
			EndIf
	EndSelect
WEnd

GUIDelete()

Como podéis comprobar no me he matado en el gui (ni en nada del código). He hecho esto porque es interesante que veáis como se puede trabajar con imágenes en memoria a gran velocidad.
Por supuesto creo que se puede conseguir más velocidad con apis que trabajan directamente con la tarjeta gráfica, como directx, opengl, etc, pero éstas son bastante complicadas, además de que las tienes que tener instaladas.

Con todo, añadir que seguramente hay alguna otra forma mejor de realizar esto. Es cuestión de buscar, leer, molestarse e interesarse.

En definitiva, autoit se defiende bastante bien en todo esto, pero pienso que para tratamientos gráficos y grandes operaciones serias, utilizaría otro lenguaje más rápido y estable, como por ejemplo java o .net.

Saludos.

[joana]

esto me lo imprimo y lo estudio!

¡Muchas Gracias Chefito!

PD: No me funciona . Le doy a PLAY y debe ser fallo de mi pc, quizá alguna librería no se, estoy mirando... Quina pena... Creo que lo tengo. Tengo el interfaz de windows cambiado. El programa requiere tener el pixel del botón y del Dead Pixel de un color concreto que el mío no. Cambiaré y probaré.

¡Ya está!

Sencillamente... Chefito eres un genio . Dame un poco de tu sabiduría! Yo aquí estaba orgullosa de haber hecho un minibot y vas tu y me dejas en ridículo jajaja.

Gracias hoy me miro el código y vuelvo a comentar.

[Chefito]

¡Muchas Gracias Chefito!

De nada. Lo hice porque me pareció un tema interesante, ya que nunca he hecho un bot...no me gustan. Además, nunca había trabajado de este modo con imágenes en memoria y pensé que sería un buen momento .

Sencillamente... Chefito eres un genio . Dame un poco de tu sabiduría! Yo aquí estaba orgullosa de haber hecho un minibot y vas tu y me dejas en ridículo jajaja.

Jajajaja, un genio no. Por desgracia soy bastante torpe. Simplemente la práctica y los años con windows.
Siempre que pueda intentaré daros algo de lo que se . En el foro hay muchos códigos y explicaciones mías. Aquí prácticamente está todo lo que se .

Debes estar orgullosa de todo lo que hagas. Piensa que tú le has puesto empeño y tiempo, y al final lo has conseguido, aunque el resultado no sea el ideal, funcionaba a su manera . Además, llevas muy poco tiempo. Verás que dentro de nada harás cosas muy interesantes. Lo que pasa que te has metido en cosas muy complicadas...sin saberlo??. Porque el código que hice lleva algunas cosas complicadas de entender. Incluso los métodos que utilicé para resolución de formas, si no se explican, pueden ser algo liosos.

Saludos.