brickworks 0.0.1

Brick Rigs mod loader
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
144
145
146
147
148
149
150
151
152
153
154
155

use crate::{br_print, win32::*};
use crate::BrickRust_print;

#[derive(Debug)]
pub struct Signature {
    pub bytes: &'static [u8],
    pub mask: &'static [bool],
}

#[derive(Debug)]
pub struct ExternalFunction
{
    pub signature: Signature,
    pub ptr_fn: *mut usize
}

/**
 * Searches array of bytes for specific signature
 * */
pub unsafe fn lookup_data( data: *const u8, data_len: usize, sign: Signature ) -> *const u8
{


    let data_len = data_len - sign.bytes.len();
    for i in 0..=data_len
    {
        let mut found = true;
        for j in 0..sign.bytes.len()
        {
            if sign.mask[j] && (*data.add(i+j) != sign.bytes[j])
            {
                found = false;
                break;
            }

        }
        if found {
            return data.add(i);
        }

    }

    return core::ptr::null();
}

/**
 * Searches game for specifc signature
 * */
pub unsafe fn lookup_unsafe( sign: Signature ) -> *const u8
{
    let data_len: usize = get_base_size();
    let data: *const u8 = get_base_address() as *const u8;
    lookup_data(data, data_len, sign)
}

/**
 * Searches game for specifc signature
 * Panics when not found
 * */
pub fn lookup( note: &'static str, sign: Signature ) -> *const u8
{
    let sig = unsafe { lookup_unsafe(sign) };
    if sig.is_null()
    {
        br_print!("{}: {:p}", note, sig);
        panic!("Failed to find {}", note)
    }
    else
    {
        br_print!("{}: {:p}", note, sig);
    }
    sig
}

#[cfg(test)]
mod test
{
    use super::*;
    use brickrust_macros::sig;

    #[test]
    fn lookup_byte()
    {
        const DATA: Signature = sig!("1F 2F 3F FF 1F 2F 4F AB CD EF");
        
        let mut r: *const u8;
        unsafe {
            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("1F"));
            assert_eq!(DATA.bytes.as_ptr(), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("2F"));
            assert_eq!(DATA.bytes.as_ptr().add(1), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("AB"));
            assert_eq!(DATA.bytes.as_ptr().add(7), r);
        }
    }

    #[test]
    fn lookup_bytes()
    {
        const DATA: Signature = sig!("1F 2F 3F FF 1F 2F 4F AB CD EF");
        
        let mut r: *const u8;
        unsafe {
            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("1F 2F 3F FF"));
            assert_eq!(DATA.bytes.as_ptr(), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("2F 3F"));
            assert_eq!(DATA.bytes.as_ptr().add(1), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("AB CD"));
            assert_eq!(DATA.bytes.as_ptr().add(7), r);
        }
    }

    #[test]
    fn lookup_bytes_not_found()
    {
        const DATA: Signature = sig!("1F 2F 3F FF 1F 2F 4F AB CD EF");
        
        let mut r: *const u8;
        unsafe {
            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("1F 2F 3F 4F"));
            assert_eq!(core::ptr::null(), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("3F 3F"));
            assert_eq!(core::ptr::null(), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("AB CD EF 00"));
            assert_eq!(core::ptr::null(), r);
        }
    }

    #[test]
    fn lookup_unknown()
    {
        const DATA: Signature = sig!("1F 2F 3F FF 1F 2F 4F AB CD EF");
        
        let mut r: *const u8;
        unsafe {
            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("1F ?? 3F"));
            assert_eq!(DATA.bytes.as_ptr(), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("1F ?? 4F"));
            assert_eq!(DATA.bytes.as_ptr().add(4), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("?? ?? 1F 2F"));
            assert_eq!(DATA.bytes.as_ptr().add(2), r);

            r = lookup_data(DATA.bytes.as_ptr(), DATA.bytes.len(), sig!("AB ?? ??"));
            assert_eq!(DATA.bytes.as_ptr().add(7), r);
        }
    }
}