Podés utilizar Stable Diffusion en tu propio hardware sin vender tu número de telefono a nadie... Mi avatar de Messi Vegeta fue generado por la variante de openvino.

(stablediffusionopenvino) $ python demo.py --seed 1337 --num-inference-steps 50 --guidance-scale 7 --prompt "An emoji from Guy Fawkes hacking with a laptop, intricate, elegant, highly detailed, digital painting, sharp, focus, by artgerm and greg rutkowski"

14:48 minutos porque mi laptop está perezosa después...

(stablediffusionopenvino) $ python demo.py --seed 1337 --num-inference-steps 50 --guidance-scale 7 --prompt "A man wearing a mask of Guy Fawkes hacking with a laptop, intricate, elegant, highly detailed, digital painting, sharp, focus, by artgerm and greg rutkowski"

15:25 minutos después sigue perezosa...



Mismo prompt y otros 14:51 doritos después, pero con escala de guía a 12 en lugar de 7 para que supuestamente obedezca más...




B#

Bienvenido al foro, en este foro se resuelven y ayudan a las personas en base a lo que muestres lo que tengas ya hecho y se tratará de ayudar en base a tu código.


B#

Quisiera mencionar un par de detalles:

#include <iostream>
#include <ctime>
#include <cstdlib>
#include<stdlib.h>
#include<time.h>

Evitá el uso de las mismas librerías de C++ con C que definan lo mismo...

using namespace std;

Usar el namespace std de manera global tengo entendido que suele ser mala práctica, siempre es mejor considerar escribir la función con su namespace completo, por ejemplo:

std::cout << "Hola" << std::endl

Siempre recordá el uso del nombre de las variables en C++ debe tener notación húngara.

Ahora sí con respecto a tu función:

/* implementa aqui la funcion f_determina_ganador(int p_pc, int p_usuario)
   Esta funcion debe contener la logica para determinar cual de los dos ha ganado.
   Las reglas son: Piedra vence a tijera; Tijera vence a Papel; Papel vence Piedra.
   Devuelve un tipo de datos char que identifica al ganador: "Computadora" o "Jugador".
*/
char f_determina_ganador(int p_pc, int p_usuario)
{
    string ganador;
 
    if (p_pc = 1 && p_usuario = 2)
        ganador = "Jugador";
    else if (p_pc = 1 && p_usuario = 3)
        ganador = "Computadora";
    else if (p_pc = 2 && p_usuario = 1)
        ganador = "Computadora";
    else if (p_pc = 2 && p_usuario = 3)
        ganador = "Jugador";
    else if (p_pc = 3 && p_usuario = 1)
        ganador = "Jugador";
    else if (p_pc = 3 && p_usuario = 2)
        ganador = "Computadora";
    else
        ganador = "Empate";   
}

Recordá que char por si solo es simplemente un número entero con signo de 1 byte y no un string, aparte en cada if estás asignando los valores en lugar de compararlos (un signo igual es asignación, mientras que dos signos iguales es comparación).

enum
{
    WINNER_TYPE_PLAYER,
    WINNER_TYPE_COMPUTER,
    WINNER_TYPE_TIE,
};
 
enum
{
    OPTION_TYPE_STONE = 1,
    OPTION_TYPE_PAPER,
    OPTION_TYPE_SCISSOR,
    OPTION_TYPE_EXIT,
};
 
char f_determina_ganador(int p_pc, int p_usuario)
{
    char cWinner;
 
    if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_COMPUTER;
    else
        cWinner = WINNER_TYPE_TIE;
 
    return cWinner;    
}

Con respecto a la función f_muestra_ganador que te falta se puede usar un simple switch:

/* Implementa aquí la función f_muestra_ganador la misma toma como parámetro un tipo de datos char
   con el identificando el ganador. Debe mostrar la descripción indicando el ganador
*/
void f_muestra_ganador(char p_ganador)
{
    switch(p_ganador)
    {
    	case WINNER_TYPE_PLAYER:
    	    std::cout << "El ganador es: Jugador" << std::endl;
    	    break;
    	case WINNER_TYPE_COMPUTER:
    	    std::cout << "El ganador es: Computer" << std::endl;
    	    break;
    	case WINNER_TYPE_TIE:
    	    std::cout << "El ganador es: Empate" << std::endl;
    	    break;
    }
}

Te dejo el código completo que me funcionó a mi en Linux:

#include <cstdlib>
#include <ctime>
#include <iostream>
#include <random>
#include <string>
 
//Prototipado de las funciones o firma de las funciones
int f_opcion_de_la_pc();
void f_muestra_opciones_menu();
char f_determina_ganador(int pp_pc, int pp_usuario);
void f_muestra_ganador(char p_ganador);
 
enum
{
    WINNER_TYPE_PLAYER,
    WINNER_TYPE_COMPUTER,
    WINNER_TYPE_TIE,
};
 
enum
{
    OPTION_TYPE_STONE = 1,
    OPTION_TYPE_PAPER,
    OPTION_TYPE_SCISSOR,
    OPTION_TYPE_EXIT,
};
 
int main() {
 
    int iUserOption;
    int iPCOption;
 
    std::cout << " \t Bienvenidos al juego Piedra, papel y Tijera" << std::endl << std::endl;
    f_muestra_opciones_menu();
 
    /*  Captura la opcion seleccionada por el usuario.
    Valida que la opcion sea valida. Si es una entre 1 y 3, llama a la funcion
    f_iPCOption() captura el resultado y pasalo como parametro junto con la
    opcion tomada por el usuario a la funcion f_determina_ganador.
    Si el usuario elige la opcion 4, termina el programa.
*/
 
    std::cin >> iUserOption;
    if (iUserOption == OPTION_TYPE_EXIT)
        return 0;
 
    while (iUserOption < OPTION_TYPE_STONE || iUserOption > OPTION_TYPE_EXIT)
    {
        std::cout << "Esa opcion no esta disponible, intentelo otra vez." << std::endl;
 
        f_muestra_opciones_menu();
        std::cin >> iUserOption;
        if (iUserOption == OPTION_TYPE_EXIT)
            return 0;
    }
 
    iPCOption = f_opcion_de_la_pc();
 
    /* En la función f_muestra_ganador captura ganador que devuelve
       la funcion f_determina_ganador(int p_pc, int p_usuario)
       Muestra el mensaje: "El ganador es: " + ganador.
       Como un plus, pregunta si quiere seguir jugando y continua el juego
    */
    f_muestra_ganador(f_determina_ganador(iPCOption, iUserOption));
 
    return 0;
}
 
//Definicion de las funciones
void f_muestra_opciones_menu() {
    std::cout << "\t 1 - Piedra" << std::endl;
    std::cout << "\t 2 - Papel" << std::endl;
    std::cout << "\t 3 - Tijera" << std::endl;
    std::cout << "\t 4 - Salir" << std::endl;
 
    std::cout << "Elige tu opcion: ";
}
 
//Implementar aqui la funcion f_opcion_de_la_pc()
//Este funcion generara un numero aleatorio entre 1 y 3 y lo devolvera
int f_opcion_de_la_pc()
{
    std::default_random_engine generator;
    std::uniform_int_distribution<int> distribution(1,3);
 
    return distribution(generator);
}
 
/* implementa aqui la funcion f_determina_ganador(int p_pc, int p_usuario)
   Esta funcion debe contener la logica para determinar cual de los dos ha ganado.
   Las reglas son: Piedra vence a tijera; Tijera vence a Papel; Papel vence Piedra.
   Devuelve un tipo de datos char que identifica al ganador: "Computadora" o "Jugador".
*/
char f_determina_ganador(int p_pc, int p_usuario)
{
    char cWinner;
 
    if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_STONE && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_COMPUTER;
    else if (p_pc == OPTION_TYPE_PAPER && p_usuario == OPTION_TYPE_SCISSOR)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_STONE)
        cWinner = WINNER_TYPE_PLAYER;
    else if (p_pc == OPTION_TYPE_SCISSOR && p_usuario == OPTION_TYPE_PAPER)
        cWinner = WINNER_TYPE_COMPUTER;
    else
        cWinner = WINNER_TYPE_TIE;
 
    return cWinner;    
}
 
 
/* Implementa aquí la función f_muestra_ganador la misma toma como parámetro un tipo de datos char
   con el identificando el ganador. Debe mostrar la descripción indicando el ganador
*/
void f_muestra_ganador(char p_ganador)
{
    switch(p_ganador)
    {
    	case WINNER_TYPE_PLAYER:
    	    std::cout << "El ganador es: Jugador" << std::endl;
    	    break;
    	case WINNER_TYPE_COMPUTER:
    	    std::cout << "El ganador es: Computer" << std::endl;
    	    break;
    	case WINNER_TYPE_TIE:
    	    std::cout << "El ganador es: Empate" << std::endl;
    	    break;
    }
}

B#

Habría que ver cuál es el backend del juego, si es Mono o IL2CPP y reversear el juego tomaría algo de tiempo para ver como funciona internamente.


B#

En C puro no tengo idea, pero sé que en el estandar de C++11 se agregó la posibilidad de utilizar funciones lambda.

https://learn.microsoft.com/en-us/cpp/cpp/lambda-expressions-in-cpp


B#

Hola, en el servidor de descargas del foro hay un par de ISOs de Windows, incluyendo una de Windows 7 de 64 bits.


B#

También podés especificarle al compilador GCC que compile en sintáxis tipo intel...

https://stackoverflow.com/questions/199966/how-do-you-use-gcc-to-generate-assembly-code-in-intel-syntax


B#

Al menos a mi me funciono lo siguiente:

shellcode.asm:

.section .text
.globl _start;
_start:
xor %eax, %eax
mov $1337,%eax
ret

Compilar a elf (opcional el --32 para 32 bits)

as --32 shellcode.asm -o shellcode.elf

Mirar el contenido del assembler:

objdump -d shellcode.elf

Exportar el contenido a secuencia de bytes:

objcopy -v -O binary shellcode.elf shellcode.bin

Comparar el contenido de los bytes con los bytes ensamblados:

xxd shellcode.bin

B#

¿Probaste objdump y GNU Assembler? Si mal no recuerdo ambos son parte de GNU Binutils...

Metasploit te ofrece el código fuente de sus payloads, algunos están bien documentados con comentarios (como los de Linux) y otros no.


B#

Fijate este video:
https://youtu.be/01mw0oTHwxg?t=716

Ahí utilizan un analizador lógico para calcular el baud rate y luego con la calculadora hacen una operación simple y obtienen el rate... Espero que te sea de utilidad.


B#