aoaddons 0.2.0

Simple library for creating addons for albion online game in multiple programing languages.
Documentation 
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use clap::{App, Arg};
use std::sync::mpsc::{channel, Receiver, Sender};

extern crate serde_json;

mod packet_sniffer;
mod photon_decode;
use packet_sniffer::UdpPacket;

use aoaddons::game::World;
use aoaddons::photon_decode::Photon;
use aoaddons::translate::raw_to_photon_messages;

fn main() {
    let matches = App::new("Testing utility")
        .about("Debug and develop new features")
        .subcommand(
            App::new("sniff")
            .arg(
                Arg::with_name("MODE")
                    .help("What mode to run the program in")
                    .index(1)
                    .possible_values(&["raw", "decoding", "messages", "events"])
                    .default_value("raw")
                    .required(true),
            )
            .arg(
                Arg::with_name("port")
                    .short("p")
                    .long("port")
                    .takes_value(true)
                    .help("UDP packets port")
            )
        )
        .subcommand(
            App::new("test")
            .about("Returns list of decoded game events from given payload")
            .arg(
                Arg::with_name("payload")
                    .help("Byte array payload")
                    .index(1)
                    .default_value("[[58, 3, 0, 1, 0, 78, 158, 217, 96, 40, 29, 110, 6, 0, 1, 4, 0, 0, 0, 28, 0, 0, 0, 89, 243, 2, 1, 0, 2, 0, 115, 0, 3, 97, 97, 97, 253, 107, 0, 188]]")
                    .required(true)
            )
        )
        .get_matches();

    if let Some(ref matches) = matches.subcommand_matches("sniff") {
        sniff(
            matches.value_of("MODE").unwrap(),
            if let Some(port) = matches.value_of("port") {
                Some(port.parse::<u16>().unwrap())
            } else {
                None
            },
        );
    }

    if let Some(ref matches) = matches.subcommand_matches("test") {
        let payloads: Vec<Vec<u8>> =
            serde_json::from_str(matches.value_of("payload").unwrap()).unwrap();
        game_events(&payloads);
    }
}

fn sniff(mode: &str, port: Option<u16>) {
    if let Ok(interfaces) = packet_sniffer::network_interfaces() {
        let (tx, rx): (Sender<UdpPacket>, Receiver<UdpPacket>) = channel();
        packet_sniffer::receive(interfaces, tx);

        loop {
            if let Ok(packet) = rx.recv() {
                if let Some(port) = port {
                    if packet.destination_port != port && packet.source_port != port {
                        continue;
                    }
                };

                match mode {
                    "raw" => {
                        println!("[RAW] {:?}", packet);
                    }
                    "decoding" => {
                        let mut photon = photon_decode::Photon::new();
                        println!("[RAW] {:?}", packet);
                        photon
                            .try_decode(&packet.payload)
                            .into_iter()
                            .for_each(|p| println!("[DECODING] {:?}", p));
                    }
                    "messages" => {
                        let mut photon = Photon::new();
                        
                        raw_to_photon_messages(&mut photon, &packet.payload)
                            .into_iter()
                            .for_each(|i| {
                                println!("[RAW] {:?}", packet);
                                println!("[GameMessage] {:?}", i) 
                            });
                    },
                    "events" => {
                        let mut photon = Photon::new();
                        let mut world = World::new();
                        
                        raw_to_photon_messages(&mut photon, &packet.payload)
                            .into_iter()
                            .inspect(|i| {
                                println!("[RAW] {:?}", packet);
                                println!("[GameMessage] {:?}", i)
                            })
                            .map(|message| world.transform(message))
                            .flatten()
                            .flatten()
                            .for_each(|e| println!("[GameEvent] {:?}", e));
                    }
                    _ => unreachable!(),
                }
            }
        }
    }
}

fn game_events(payloads: &Vec<Vec<u8>>) {
    let mut photon = Photon::new();
    let mut world = World::new();

    for payload in payloads {
        println!("[PAYLOAD] {:?}", payload);

        photon
            .try_decode(&payload)
            .into_iter()
            .for_each(|p| println!("[DECODING] {:?}", p));

        raw_to_photon_messages(&mut photon, &payload)
            .into_iter()
            .inspect(|i| println!("[GameMessage] {:?}", i))
            .map(|message| world.transform(message))
            .flatten()
            .flatten()
            .for_each(|e| println!("[GameEvent] {:?}", e));
    }
}