maexchen rust

main.rs

use std::net::UdpSocket;
use std::str;

pub fn receive(socket: &UdpSocket) -> String {
    let mut buf = [0; 200];
    let (amt, src) = socket.recv_from(&mut buf).expect("error");

    let filled_buffer = &mut buf[..amt];

    return String::from_utf8(Vec::from(filled_buffer)).expect("error");
}

fn main() {
    let dice_order = [
        "2,1", "6,6", "5,5", "4,4", "3,3", "2,2", "1,1", "6,5", "6,4", "6,3", "6,2", "6,1", "5,4", "5,3", "5,2", "5,1", "4,3", "4,2", "4,1", "3,2", "3,1"
    ];
    let server_ip = "192.168.179.27";
    let server_port = 9000;
    let server = format!("{server_ip}:{server_port}", server_ip = server_ip, server_port = server_port);


    let socket = UdpSocket::bind("0.0.0.0:9999").expect("could not connec");
    println!("server: {} bound", server);

    //socket.send_to(b"UNREGISTER;WoMo", &server).expect("registration could not be sent");
    //println!("registration sent");

    //let response = receive(&socket);
    //println!("response: {:?}", response);

    //if ! response.eq("UNREGISTERED") {
        //panic!(format!("register did not work: {}", response));
    //}


    socket.send_to(b"REGISTER;WoMo", &server).expect("registration could not be sent");
    println!("registration sent");

    let response = receive(&socket);
    println!("response: {:?}", response);

    if ! response.eq("REGISTERED") {
        panic!(format!("register did not work: {}", response));
    }

    let mut last_roll = "3,1".to_string();
    loop {
        let response = receive(&socket);

        //println!("response: {:?}", response);

        if response.eq("HEARTBEAT") {
            continue;
        }

        if response.starts_with("ROUND STARTING;") {
            println!("ROUND STARTING {}", response);

            last_roll = "1,1".to_string();
            println!("trying to join: {}", response);
            let token = response.split(";").collect::<Vec<&str>>()[1];

            socket.send_to(format!("JOIN;{}", token).as_bytes(), &server).expect("join error");

            let response = receive(&socket);
            println!("JOIN response: {:?}", response);

            continue;
        }

        if response.starts_with("ROLLED;") {
            let rolled = response.split(";").collect::<Vec<&str>>()[1];
            let token = response.split(";").collect::<Vec<&str>>()[2];
            let my_position = dice_order.iter().position(|&x| x == rolled).expect("could not find");
            let last_position = dice_order.iter().position(|&x| x == last_roll).expect("could not find");

            let mut roll_announce = dice_order[last_position - 1];
            if my_position < last_position {
                roll_announce = rolled;
            }

            println!("rolled {} position {} last {} position {} next best {}", rolled, my_position, last_roll, last_position, dice_order[last_position - 1]);

            println!("ROLLED;{}", rolled);
            println!("ANNOUNCE;{};{}", roll_announce, token);
            socket.send_to(format!("ANNOUNCE;{};{}", roll_announce, token).as_bytes(), &server).expect("join error");

            continue;
        }

        if response.starts_with("YOUR TURN;") {
            let token = response.split(";").collect::<Vec<&str>>()[1];
            let last_position = dice_order.iter().position(|&x| x == last_roll).expect("could not find");

            if last_position < 6 {
                socket.send_to(format!("SEE;{}", token).as_bytes(), &server).expect("join error");
                continue;
            }

            socket.send_to(format!("ROLL;{}", token).as_bytes(), &server).expect("join error");

            continue;
        }

        if response.starts_with("ANNOUNCED;") {
            let vector = response.split(";").collect::<Vec<&str>>();
            let user = vector[1];
            last_roll = vector[2].to_string();

            println!("ANNOUNCED {} by {}", last_roll, user);

            continue;
        }

        println!("response: {:?}", &response);
    }
}