domingo, 7 de abril de 2019

Creando videojuegos en Rust lang (Parte 14)

Programa 8. "pre_hello_ggez8" Definiendo funciones y llamando funciones: "fn" y "->"
En Rust también podemos definir funciones y llamarlas. Al definir funciones lo hacemos con la palabra clave "fn" seguido por un espacio y el nombre de la función, luego en paréntesis ponemos las variables de entrada, y finalmente ponemos "->" seguido por el tipo de dato que queremos en las salidas. Las funciones las encerramos entre llaves "{ ... }" entre las cuales hacemos las operaciones que queramos dentro de estas. 

Hablando sobre las entradas de funciones. Las funciones que hagamos pueden tomar un número variado de entradas o argumentos: 0, 1, 2, etc. Para no tomar entradas basta con dejar los paréntesis vacíos "mi_funcion()" y para poner entradas hay que definir el nombre y los tipos de variables que vamos a usar.

Hablando sobre las salidas de las funciones. Las funciones pueden regresar un número variado de argumentos o salidas, pero sólo podemos regresar una variable. Es decir para mandar varias salidas debemos de agruparlos en una tupla o otro objecto y así podremos regresar varias salidas. Por otra parte cuando no hay salida la función regresará "()", la unidad o tupla vacía. En Rust todas las líneas son expresiones así que si ponemos punto y coma ";" al final entonces la función intentará regresar la unidad "()", es decir la tupla vacía. Así que para que regrese la última expresión tenemos que dejar esa última línea sin punto y coma.

Los siguientes ejemplos muestran diferentes funciones:
  • Función "holamundo" que no tiene entradas ni salidas (regresa "()" implícitamente). Imprime "Hola mundo". Notar como pusimos un punto y coma ";" en la última línea de la función.
  • Función "sumar" que suma dos números enteros y regresa un número entero. Notar como en este caso no pusimos un punto y coma ";" en la última línea de la función.
  • Función "mensaje" que toma como entrada un "enum" y usa un "match" para imprimirlo.
  • Función "calcular" que toma como entrada una tupla de 3 elementos y regresa una tupla de 3 elementos. Es decir tiene 3 salidas que luego podemos asignar a variables diferentes.
  • Función "crear_estado_del_juego" que toma como entradas diferentes tipos de variables, construye un "struct" de EstadoDelJuego y lo regresa. 
  • Función "imprimir_estado_del_juego" que imprime una estructura EstadoDelJuego. Recordemos que no podemos imprimirla directamente  sin derivar "Debug" y usar "{:?}". Estes es un ejemplo de como podemos generar una función para imprimir una estructura de datos.
Este es el código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
fn holamundo() {
    println!("Hola mundo");
}

fn sumar(numero1: i64, numero2: i64) -> i64 {
    numero1 + numero2
}

enum Direccion {
    Avanzar,
    Detenido(char),
    Click { x: i64, y: i64 }
}

fn mensaje(direccion_entrada: Direccion) {
    match direccion_entrada {
        Direccion::Avanzar => println!("¡Avanzar!"),
        Direccion::Detenido(mi_char) => println!("¡{}!", mi_char),
        Direccion::Click { x, y } => println!("¡x={} y={}!", x, y)
    };
}

fn calcular(entrada: (i32, i32, i32)) -> (i32, i32, i32) {
    let salida1 = entrada.0 + entrada.1 + entrada.2;
    let salida2 = entrada.0 - entrada.1 - entrada.2;
    let salida3 = entrada.0 * entrada.1 * entrada.2;
    (salida1, salida2, salida3)
}

struct EstadoDelJuego {
    id_jugador: u32,
    nombre_jugador: String,
    x: i32,
    y: i32,
    id_char: char
}

fn crear_estado_del_juego(id: u32, 
    nombre: String, v_x: i32, v_y:i32, 
    v_char: char) -> EstadoDelJuego {
    EstadoDelJuego{id_jugador: id,
        nombre_jugador: nombre,
        x: v_x, y: v_y, id_char: v_char}
}

fn imprimir_estado_del_juego(estado: EstadoDelJuego) {
    println!("J{} {} ({},{}) id {}", 
        estado.id_jugador, estado.nombre_jugador,
        estado.x, estado.y, estado.id_char);
}

fn main() {
    holamundo();
    holamundo();
    holamundo();
    println!("Suma 1: {}", sumar(9,6));
    println!("Suma 2: {}", sumar(3,5));
    println!("Suma 3: {}", sumar(4,2));
    let direccion_j1 = Direccion::Avanzar;
    let direccion_j2 = Direccion::Click{x: 6, y: 3};
    let direccion_j3 = Direccion::Detenido('p');
    mensaje(direccion_j1);
    mensaje(direccion_j2);
    mensaje(direccion_j3);
    let t1 = (1,2,1);
    let (suma, resta, multi) = calcular(t1);
    println!("suma = {}",suma);
    println!("resta = {}",resta);
    println!("multiplicacion = {}",multi);
    let mi_juego = crear_estado_del_juego(1,
        String::from("Jugador 1"),
        10, 5, 'a');
    imprimir_estado_del_juego(mi_juego);
    println!("¡Fin del juego!");
}

Y este es el resultado de correrlo:

Navegación:
Primera parte
Siguiente parte
Parte anterior

Fuente (inglés):
Publicadas por a la/s

No hay comentarios.:

Publicar un comentario

Suscribirse a: Comentarios de la entrada (Atom)