← Back to branch summary

~ubuntu-branches/ubuntu/raring/mumble/raring

« back to all changes in this revision

Viewing changes to plugins/arma2/arma2.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Thorvald Natvig, Patrick Matthäi, Thorvald Natvig
  • Date: 2011-02-19 22:58:58 UTC
  • mfrom: (9.1.15 sid)
  • Revision ID: james.westby@ubuntu.com-20110219225858-0xlftrf4z1z4jt9e
Tags: 1.2.3-1
[ Patrick Matthäi ]
* Do not build with non existant libpulse-dev on hurd-i386.

[ Thorvald Natvig ]
* New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/arma2/arma2.cpp
29
29
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
30
*/
31
31
 
32
 
#include <stdio.h>
33
 
#include <stdlib.h>
34
 
#include <windows.h>
35
 
#include <tlhelp32.h>
36
 
#include <math.h>
37
 
 
38
 
#include "../mumble_plugin.h"
39
 
 
40
 
HANDLE h;
 
32
#include "../mumble_plugin_win32.h"
41
33
 
42
34
BYTE *posptr;
43
 
 
44
 
static DWORD getProcess(const wchar_t *exename) {
45
 
        PROCESSENTRY32 pe;
46
 
        DWORD pid = 0;
47
 
 
48
 
        pe.dwSize = sizeof(pe);
49
 
        HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
50
 
        if (hSnap != INVALID_HANDLE_VALUE) {
51
 
                BOOL ok = Process32First(hSnap, &pe);
52
 
 
53
 
                while (ok) {
54
 
                        if (wcscmp(pe.szExeFile, exename)==0) {
55
 
                                pid = pe.th32ProcessID;
56
 
                                break;
57
 
                        }
58
 
                        ok = Process32Next(hSnap, &pe);
59
 
                }
60
 
                CloseHandle(hSnap);
61
 
        }
62
 
        return pid;
63
 
}
64
 
 
65
 
static BYTE *getModuleAddr(DWORD pid, const wchar_t *modname) {
66
 
        MODULEENTRY32 me;
67
 
        BYTE *addr = NULL;
68
 
        me.dwSize = sizeof(me);
69
 
        HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
70
 
        if (hSnap != INVALID_HANDLE_VALUE) {
71
 
                BOOL ok = Module32First(hSnap, &me);
72
 
 
73
 
                while (ok) {
74
 
                        if (wcscmp(me.szModule, modname)==0) {
75
 
                                addr = me.modBaseAddr;
76
 
                                break;
77
 
                        }
78
 
                        ok = Module32Next(hSnap, &me);
79
 
                }
80
 
                CloseHandle(hSnap);
81
 
        }
82
 
        return addr;
83
 
}
84
 
 
85
 
 
86
 
static bool peekProc(VOID *base, VOID *dest, SIZE_T len) {
87
 
        SIZE_T r;
88
 
        BOOL ok=ReadProcessMemory(h, base, dest, len, &r);
89
 
        return (ok && (r == len));
90
 
}
91
 
 
92
 
static DWORD peekProc(VOID *base) {
93
 
        DWORD v = 0;
94
 
        peekProc(base, reinterpret_cast<BYTE *>(&v), sizeof(DWORD));
95
 
        return v;
96
 
}
97
 
 
98
 
static BYTE *peekProcPtr(VOID *base) {
99
 
        DWORD v = peekProc(base);
100
 
        return reinterpret_cast<BYTE *>(v);
101
 
}
102
 
 
103
 
static void about(HWND h) {
104
 
        ::MessageBox(h, L"Reads audio position information from Armed Assault 2 v1.05", L"Mumble ArmA2 Plugin", MB_OK);
105
 
}
106
 
 
107
 
static int fetch(float *avatar_pos, float *avatar_front, float *avatar_top, float *camera_pos, float *camera_front, float *camera_top, std::string &context, std::wstring &identity) {
 
35
BYTE *frontptr;
 
36
BYTE *topptr;
 
37
 
 
38
static int fetch(float *avatar_pos, float *avatar_front, float *avatar_top, float *camera_pos, float *camera_front, float *camera_top, std::string &, std::wstring &) {
108
39
        for (int i=0;i<3;i++)
109
40
                avatar_pos[i] = avatar_front[i] = avatar_top[i] = camera_pos[i] = camera_front[i] = camera_top[i] = 0.0f;
110
41
 
111
42
        // char state;
112
43
        bool ok;
113
44
 
 
45
        /*
114
46
        float front_corrector1;
115
47
        float front_corrector2;
116
48
        float front_corrector3;
118
50
        float top_corrector1;
119
51
        float top_corrector2;
120
52
        float top_corrector3;
 
53
        */
121
54
 
122
55
        /*
123
56
                value is 0 when one is not in a game, 4 when one is
 
57
 
 
58
           ok = peekProc((BYTE *) 0x, &state, 1); // Magical state value
 
59
           if (! ok)
 
60
                return false;
 
61
 
 
62
           if (state == 0)
 
63
                  return true; // This results in all vectors beeing zero which tells Mumble to ignore them.
124
64
        */
125
 
        // ok = peekProc((BYTE *) 0x, &state, 1); // Magical state value
126
 
        // if (! ok)
127
 
        //      return false;
128
 
 
129
 
        // if (state == 0)
130
 
        //          return true; // This results in all vectors beeing zero which tells Mumble to ignore them.
131
65
 
132
66
        ok = peekProc(posptr, avatar_pos, 12) &&
133
 
             peekProc((BYTE *) 0x016CE6F8, &front_corrector1, 4) &&
134
 
             peekProc((BYTE *) 0x016CE704, &front_corrector2, 4) &&
135
 
             peekProc((BYTE *) 0x016CE710, &front_corrector3, 4) &&
136
 
             peekProc((BYTE *) 0x016CE6F4, &top_corrector1, 4) &&
137
 
             peekProc((BYTE *) 0x016CE700, &top_corrector2, 4) &&
138
 
             peekProc((BYTE *) 0x016CE70C, &top_corrector3, 4);
 
67
             peekProc(frontptr, avatar_front, 12) &&
 
68
             peekProc(topptr, avatar_top, 12);
 
69
 
 
70
        if (avatar_pos[1] > 999000000.0)
 
71
                return false;
 
72
 
 
73
        /*
 
74
        peekProc(frontptr, &front_corrector1, 4) &&
 
75
        peekProc(frontptr + 0xC, &front_corrector2, 4) &&
 
76
        peekProc(frontptr + 0x18, &front_corrector3, 4) &&
 
77
        peekProc(topptr, &top_corrector1, 4) &&
 
78
        peekProc(topptr + 0xC, &top_corrector2, 4) &&
 
79
        peekProc(topptr + 0x18, &top_corrector3, 4);
 
80
        */
139
81
 
140
82
        if (! ok)
141
83
                return false;
142
84
 
 
85
        /*
143
86
        avatar_front[0] = front_corrector1;
144
87
        avatar_front[1] = front_corrector2;
145
88
        avatar_front[2] = front_corrector3;
147
90
        avatar_top[0] = top_corrector1;
148
91
        avatar_top[1] = top_corrector2;
149
92
        avatar_top[2] = top_corrector3;
 
93
        */
150
94
 
151
95
        for (int i=0;i<3;i++) {
152
96
                camera_pos[i] = avatar_pos[i];
157
101
        return true;
158
102
}
159
103
 
160
 
static int trylock() {
161
 
        h = NULL;
 
104
static int trylock(const std::multimap<std::wstring, unsigned long long int> &pids) {
162
105
        posptr = NULL;
163
106
 
164
 
        DWORD pid=getProcess(L"arma2.exe");
165
 
        if (!pid)
166
 
                return false;
167
 
        // Comment out code we don't need
168
 
        // BYTE *mod=getModuleAddr(pid, L"<module name, if you need it>.dll");
169
 
        // if (!mod)
170
 
        //      return false;
171
 
 
172
 
        h=OpenProcess(PROCESS_VM_READ, false, pid);
173
 
        if (!h)
174
 
                return false;
175
 
 
176
 
        BYTE *ptr1 = peekProcPtr((BYTE *) 0x00C10F80);
177
 
        BYTE *ptr2 = peekProcPtr(ptr1 + 0x280);
178
 
 
179
 
        posptr = ptr2 + 0x40;
 
107
        if (! initialize(pids, L"arma2.exe"))
 
108
                return false;
 
109
 
 
110
        /*
 
111
        BYTE bState;
 
112
        peekProc((BYTE *) 0x00BF64D0, &bState, 1);
 
113
        if (bState == 0)
 
114
                return false;
 
115
        */
 
116
 
 
117
        /*
 
118
           Comment out code we don't need
 
119
           BYTE *pModule=getModuleAddr(L"<module name, if you need it>.dll");
 
120
           if (!pModule)
 
121
        */
 
122
 
 
123
        BYTE *ptr1 = peekProc<BYTE *>((BYTE *) 0x00C500FC);
 
124
 
 
125
        BYTE *ptr2 = peekProc<BYTE *>(ptr1 + 0x88);
 
126
 
 
127
        BYTE *base = ptr2 + 0x10;
 
128
 
 
129
        posptr = base + 0x18;
 
130
        frontptr = base;
 
131
        topptr = base + 0xC;
180
132
 
181
133
        float apos[3], afront[3], atop[3], cpos[3], cfront[3], ctop[3];
182
134
        std::string context;
183
135
        std::wstring identity;
184
136
 
185
 
        if (fetch(apos, afront, atop, cpos, cfront, ctop, context, identity))
 
137
        if (fetch(apos, afront, atop, cpos, cfront, ctop, context, identity)) {
186
138
                return true;
187
 
 
188
 
        CloseHandle(h);
189
 
        h = NULL;
190
 
        return false;
191
 
}
192
 
 
193
 
static void unlock() {
194
 
        if (h) {
195
 
                CloseHandle(h);
196
 
                h = NULL;
 
139
        } else {
 
140
                generic_unlock();
 
141
                return false;
197
142
        }
198
 
        return;
199
143
}
200
144
 
201
145
static const std::wstring longdesc() {
202
 
        return std::wstring(L"Supports Armed Assault 2 v1.05. No identity or context support yet.");
 
146
        return std::wstring(L"Supports Armed Assault 2 v1.08. No identity or context support yet.");
203
147
}
204
148
 
205
 
static std::wstring description(L"ArmA 2 v1.05");
 
149
static std::wstring description(L"ArmA 2 v1.08");
206
150
static std::wstring shortname(L"ArmA 2");
207
151
 
 
152
static int trylock1() {
 
153
        return trylock(std::multimap<std::wstring, unsigned long long int>());
 
154
}
 
155
 
208
156
static MumblePlugin arma2plug = {
209
157
        MUMBLE_PLUGIN_MAGIC,
210
158
        description,
211
159
        shortname,
212
 
        about,
213
 
        NULL,
214
 
        trylock,
215
 
        unlock,
 
160
        NULL,
 
161
        NULL,
 
162
        trylock1,
 
163
        generic_unlock,
216
164
        longdesc,
217
165
        fetch
218
166
};
219
167
 
 
168
static MumblePlugin2 arma2plug2 = {
 
169
        MUMBLE_PLUGIN_MAGIC_2,
 
170
        MUMBLE_PLUGIN_VERSION,
 
171
        trylock
 
172
};
 
173
 
220
174
extern "C" __declspec(dllexport) MumblePlugin *getMumblePlugin() {
221
175
        return &arma2plug;
222
 
}
 
 
b'\\ No newline at end of file'
 
176
}
 
177
 
 
178
extern "C" __declspec(dllexport) MumblePlugin2 *getMumblePlugin2() {
 
179
        return &arma2plug2;
 
180
}