Mensajes

Bueno, estoy tratando de obtener lo que sería la nueva posición del jugador en base a la posición del mouse relativa a la ventana.

Es decir: quiero que la posición X e Y de un jugador sea ajustada hacia su nueva posición en el mapa/mundo, la cual sería la posición señalada por el mouse sobre la ventana.

Yo actualmente poseeo los siguientes datos:

• Las dimenciones de la ventana.
• La posición X e Y del mouse en base a la ventana.
• La dimensión del mapa.
• La posición del jugador relativa a la dimensión del mapa.
• La velocidad de movimiento del jugador.

Código [Seleccionar] Expandir

local WINDOW_WIDTH = 597
local WINDOW_HEIGHT = 383
local MOUSE_X = 0
local MOUSE_Y = 0
local USER_X = 34.0
local USER_Y = 63.0
local MAP_WIDTH = 71.0
local MAP_HEIGHT = 43.0
local USER_SPEED = 8

-- Mi vano intento por obtener las nuevas coordenadas X e Y.
-- Hice cualquiera xd
local angle = math.atan2(MOUSE_Y - USER_Y,MOUSE_X - USER_X)
local dx,dy = USER_SPEED * math.cos(angle),USER_SPEED * math.sin(angle)
local x,y = dx,dy
print(x,y)

También me encuentro con el dilema de que el mapa y la posición del jugador están en valores flotantes y no sé que dimensión en pixeles representa, aunque creo que es:

Código [Seleccionar] Expandir

WIDTH = MAP_WIDTH * USER_SPEED
HEIGHT = MAP_HEIGHT * USER_SPEED

La verdad no tengo la menor idea de como proceder en este caso. ¿alguna sugerencia?

Está bueno el planteo, yo siempre creí que

Código (asm) [Seleccionar] Expandir

xor ebx,ebx
inc ebx

sería más rápido que:

Código (asm) [Seleccionar] Expandir

mov ebx,1

Lo ideal siempre es optimizar la velocidad y el tamaño juntos, pero si el primero es más lento que el segundo no creo que tenga mucho sentido ahorrar 2 bytes.

Es verdad que siguen sobrando líneas, no se porqué no me dí cuenta

Es un código de ejemplo, lo escribí de esta manera para el foro

Y si te molesta mi código, te recomiendo que veas el de SpyNET, uno de los rats más respetados... su código es un total desastre  te va a agarrar una embolia cuando lo leas

Lo decía jugando, no es de mala manera

Dejo el código que yo considero optimizado a continuación:

Código (asm) [Seleccionar] Expandir

format ELF executable 3
entry start

segment readable executable

SYS_SOCKET = 1
SYS_SOCKETCALL = 102
SYS_WRITE = 4

start:
        mov ecx,sockparams
        mov ebx,SYS_SOCKET
        mov eax,SYS_SOCKETCALL
        int 0x80

        test eax,eax
        jz .ZERO
        js .BELOW_ZERO
        jnz .ABOVE_ZERO
.ZERO:
        mov edx,7
        mov ecx,cero_mensaje
        jmp .WRITE
.ABOVE_ZERO:
        mov edx,19
        mov ecx,nocero_mensaje
        jmp .WRITE
.BELOW_ZERO:
        mov edx,15
        mov ecx,menorcero_mensaje
.WRITE:
        xor ebx,ebx ; Dos opcode menos
        inc ebx     ;
        mov eax,SYS_WRITE
        int 0x80

        xor eax,eax ; Dos opcode menos
        inc eax     ;
        xor ebx,ebx
        int 0x80

segment readable writeable

        sockparams        dd 2,1,0
        menorcero_mensaje db 'Menor a cero...',0
        cero_mensaje      db 'Cero...',0
        nocero_mensaje    db 'Es mayor a cero! :0',0

Si se puede optimizar más avisenme, por ahí necesito mejorar mis códigos. Aunque en realidad ya no uso el sistema SYS_CALL, sino que uso la librería de C para los sockets.

Es un código de ejemplo, lo escribí de esta manera para el foro

Y si te molesta mi código, te recomiendo que veas el de SpyNET, uno de los rats más respetados... su código es un total desastre  te va a agarrar una embolia cuando lo leas

Bueno, como estoy creando un malware para Linux tengo que escribir y probar código, tuve (y tengo) bastantes problemas con los sockets, no por su complejidad de uso (que es nula), sino por el simple hecho de que no obtengo los resultados deseados.

Escribí este código para encontrar el error de manera más sencilla, pero no pude hacerlo debido a que milagrosamente el código decidió funcionar sin problemas (o eso creo).


Para FASM:

Código (asm) [Seleccionar] Expandir

format ELF executable 3
entry start

segment readable executable

SYS_SOCKET = 1
SYS_SOCKETCALL = 102
SYS_WRITE = 4

start:
        mov DWORD[sockparams+4*0],2 ; PF_INET - AF_INET (2)
        mov DWORD[sockparams+4*1],1 ; SOCK_STREAM (1)
        mov DWORD[sockparams+4*2],0 ; 0, También probé con IPPROTO_TCP (6)

        lea ecx,DWORD[sockparams]
        mov ebx,SYS_SOCKET
        mov eax,SYS_SOCKETCALL
        int 0x80
        cmp eax,0
        je .MOSTRAR_MENSAJE_CERO
        js .MOSTRAR_MENSAJE_MENOR_CERO
        jb .MOSTRAR_MENSAJE_MENOR_CERO
        ja .MOSTRAR_MENSAJE_NO_CERO
        jmp .CONTINUAR
.MOSTRAR_MENSAJE_CERO:
        mov edx,7
        mov ecx,cero_mensaje
        mov ebx,1
        mov eax,SYS_WRITE
        int 0x80
        jmp .CONTINUAR
.MOSTRAR_MENSAJE_NO_CERO:
        mov edx,19
        mov ecx,nocero_mensaje
        mov ebx,1
        mov eax,SYS_WRITE
        int 0x80
        jmp .CONTINUAR
.MOSTRAR_MENSAJE_MENOR_CERO:
        mov edx,15
        mov ecx,menorcero_mensaje
        mov ebx,1
        mov eax,SYS_WRITE
        int 0x80
.CONTINUAR:
        mov eax,1
        xor ebx,ebx
        int 0x80

segment readable writeable

        sockparams rd 10

        menorcero_mensaje db 'Menor a cero...',0
        cero_mensaje db 'Cero...',0
        nocero_mensaje db 'Es mayor a cero! :0',0

Considero que está muy claro, pero si no se entiende no duden en decirme. Espero que les sirva a aquellas personas interesadas en la programación de bajo nivel para Linux.

Testeado en TinyCore Linux emulado mediante QEMU.

No creo que sea inaudito, y ese tipo de idea puede implementarse fácilmente en Lua. Es más, yo hace unos meses escribí una función que permitía almacenar una tabla (tipo de estructura/array en otros lenguajes) en un fichero de texto, con todos los nombres y valores de sus miembros. Básicamente lo que explicas.

Me gusta la idea, funcionaría muy bien al momento de inyectar funciones externas también.

Me interesó bastante tu comentario B#, estoy buscando en Internet métodos de evasión avanzada, pero veo que cada uno es específico para el anti-trampas del momento ¿hay algún método estandar para implementar en un módulo específico?

La generación de licencias también me gustó, pero al igual que el anterior, los métodos de creación de keys/licencias es específico para la aplicación.

El obfuscador lo puedo escribir sin problemas.

Estoy creando una variante de Lua 5.3 que permite la automatización de Windows (vease: AutoIT y AutoHotKey) pero mejor orientado al hacking de juegos (vease: edición de memoria, hooks, etc).

No vengo a pedir ayuda con el desarrollo del proyecto, tengo en mente la base del lenguaje; solo me gustaría (realmente!) tener algunas ideas en la mesa antes de terminar con la primera liberación.

¿Qué te gustaría ver implementado en Lua?, también busco sugerencias para el nombre.

¡Saludos!

No tiene porque ser tan malo, lee el libro y pásalo a un archivo PDF en tu computador (tecleado a mano, obviamente) tal vez se te haga mas interesante así...

Yo no confiaría, las cripto-divisas tienen pocas cualidades con respecto al dinero real, una de ellas es el anonimato... Si fuera cierto (y no creo) para algo usarán tu información personal, no te la han de pedir por nada.