Auf dll Funktionen zugreifen

BenBaron · 3. April 2010, 19:10

Hallo Leute,

ich weiß nicht ob sich jemand damit auskennt, aber ich würde gerne mit dem game maker auf Variablen eines anderen Programms zugreifen (genauer: MS Flightsimulator). Da dies von Haus aus nicht geht, hat jemand eine dll (FSUIPC) geschrieben, über die es möglich ist alles mögliche aus dem Flugsimulator auszulesen. Dafür muss man nur eine entsprechende header datei und .lib datei zu seinem projekt (zB mit MS Visual Studio, das ich bisher dafür benutzt habe) includieren bzw. linken und dann kann man auf die Funktionen dieser dll zugreifen. Nun würde ich dies gern mit dem game maker verbinden bin mir aber ein wenig unschlüssig, inwiefern man das hinbekommen könnte...hat da vielleicht jemand einen Tip? Habe schon ein wenig mit Extensions experimentiert, komme da aber nicht richtig weiter.

Gruß, Benny

henrik1235 · 3. April 2010, 19:14

Wenn die DLL nicht für den Game Maker geschrieben ist, dann wird es wohl nicht gehen.
Du/Jemand könnte da aber versuchen eine DLL zu schreiben die die Funktion an diese DLL weiterleitet.
Alles was du wissen willst steht hier: gm-d.de/help/hh_start.htm?414_00_dlls.html .

BenBaron · 3. April 2010, 19:36

Hmm...okay...der für die .lib Datei verwendete Source Code ist öffentlich verfügbar und müsste dementsprechend dann wohl umgewandelt werden, wobei das glaub ich mein Können im Moment noch überschreitet :rolleyes:

. Hier mal der c code für die Bibliothek:

C-Quellcode

/* IPCUSER.C User interface library for FSUIPC
*******************************************************************************
Started: 28th November 2000
With acknowledgements to Adam Szofran (author of original FS6IPC).
******************************************************************************/
#define LIB_VERSION 2002 // 2.002
#define MAX_SIZE 0x7F00 // Largest data (kept below 32k to avoid
// any possible 16-bit sign problems)
#include "IPCuser.h"
/******************************************************************************
IPC client stuff
******************************************************************************/
DWORD FSUIPC_Version = 0;
DWORD FSUIPC_FS_Version = 0;
DWORD FSUIPC_Lib_Version = LIB_VERSION;
static HWND m_hWnd = 0; // FS6 window handle
static UINT m_msg = 0; // id of registered window message
static ATOM m_atom = 0; // global atom containing name of file-mapping object
static HANDLE m_hMap = 0; // handle of file-mapping object
static BYTE* m_pView = 0; // pointer to view of file-mapping object
static BYTE* m_pNext = 0;
/******************************************************************************
FSUIPC_Close
******************************************************************************/
// Stop the client
void FSUIPC_Close(void)
{ m_hWnd = 0;
m_msg = 0;
if (m_atom)
{ GlobalDeleteAtom(m_atom);
m_atom = 0;
}
if (m_pView)
{ UnmapViewOfFile((LPVOID)m_pView);
m_pView = 0;
}
if (m_hMap)
{ CloseHandle(m_hMap);
m_hMap = 0;
}
}
/******************************************************************************
FSUIPC_Open
******************************************************************************/
// Start the client
// return: TRUE if successful, FALSE otherwise
BOOL FSUIPC_Open(DWORD dwFSReq, DWORD *pdwResult)
{ char szName[MAX_PATH];
static int nTry = 0;
BOOL fWideFS = FALSE;
int i = 0;
// abort if already started
if (m_pView)
{ *pdwResult = FSUIPC_ERR_OPEN;
return FALSE;
}
// Clear version information, so know when connected
FSUIPC_Version = FSUIPC_FS_Version = 0;
// Connect via FSUIPC, which is known to be FSUIPC's own
// and isn't subject to user modificiation
m_hWnd = FindWindowEx(NULL, NULL, "UIPCMAIN", NULL);
if (!m_hWnd)
{ // If there's no UIPCMAIN, we may be using WideClient
// which only simulates FS98
m_hWnd = FindWindowEx(NULL, NULL, "FS98MAIN", NULL);
fWideFS = TRUE;
if (!m_hWnd)
{ *pdwResult = FSUIPC_ERR_NOFS;
return FALSE;
}
}
// register the window message
m_msg = RegisterWindowMessage(FS6IPC_MSGNAME1);
if (m_msg == 0)
{ *pdwResult = FSUIPC_ERR_REGMSG;
return FALSE;
}
// create the name of our file-mapping object
nTry++; // Ensures a unique string is used in case user closes and reopens
wsprintf(szName, FS6IPC_MSGNAME1 ":%X:%X", GetCurrentProcessId(), nTry);
// stuff the name into a global atom
m_atom = GlobalAddAtom(szName);
if (m_atom == 0)
{ *pdwResult = FSUIPC_ERR_ATOM;
FSUIPC_Close();
return FALSE;
}
// create the file-mapping object
m_hMap = CreateFileMapping(
(HANDLE)0xFFFFFFFF, // use system paging file
NULL, // security
PAGE_READWRITE, // protection
0, MAX_SIZE+256, // size
szName); // name
if ((m_hMap == 0) || (GetLastError() == ERROR_ALREADY_EXISTS))
{ *pdwResult = FSUIPC_ERR_MAP;
FSUIPC_Close();
return FALSE;
}
// get a view of the file-mapping object
m_pView = (BYTE*)MapViewOfFile(m_hMap, FILE_MAP_WRITE, 0, 0, 0);
if (m_pView == NULL)
{ *pdwResult = FSUIPC_ERR_VIEW;
FSUIPC_Close();
return FALSE;
}
// Okay, now determine FSUIPC version AND FS type
m_pNext = m_pView;
// Try up to 5 times with a 100mSec rest between each
// Note that WideClient returns zeroes initially, whilst waiting
// for the Server to get the data
while ((i++ < 5) && ((FSUIPC_Version == 0) || (FSUIPC_FS_Version == 0)))
{ // Read FSUIPC version
if (!FSUIPC_Read(0x3304, 4, &FSUIPC_Version, pdwResult))
{ FSUIPC_Close();
return FALSE;
}
// and FS version and validity check pattern
if (!FSUIPC_Read(0x3308, 4, &FSUIPC_FS_Version, pdwResult))
{ FSUIPC_Close();
return FALSE;
}
// Write our Library version number to a special read-only offset
// This is to assist diagnosis from FSUIPC logging
// But only do this on first try
if ((i < 2) && !FSUIPC_Write(0x330a, 2, &FSUIPC_Lib_Version, pdwResult))
{ FSUIPC_Close();
return FALSE;
}
// Actually send the requests and get the responses ("process")
if (!FSUIPC_Process(pdwResult))
{ FSUIPC_Close();
return FALSE;
}
// Maybe running on WideClient, and need another try
Sleep(100); // Give it a chance
}
// Only allow running on FSUIPC 1.998e or later
// with correct check pattern 0xFADE
if ((FSUIPC_Version < 0x19980005) || ((FSUIPC_FS_Version & 0xFFFF0000L) != 0xFADE0000))
{ *pdwResult = fWideFS ? FSUIPC_ERR_RUNNING : FSUIPC_ERR_VERSION;
FSUIPC_Close();
return FALSE;
}
FSUIPC_FS_Version &= 0xffff; // Isolates the FS version number
if (dwFSReq && (dwFSReq != FSUIPC_FS_Version)) // Optional user specific FS request
{ *pdwResult = FSUIPC_ERR_WRONGFS;
FSUIPC_Close();
return FALSE;
}
*pdwResult = FSUIPC_ERR_OK;
return TRUE;
}
/******************************************************************************
FSUIPC_Process
******************************************************************************/
BOOL FSUIPC_Process(DWORD *pdwResult)
{ DWORD dwError;
DWORD *pdw;
FS6IPC_READSTATEDATA_HDR *pHdrR;
FS6IPC_WRITESTATEDATA_HDR *pHdrW;
int i = 0;
if (!m_pView)
{ *pdwResult = FSUIPC_ERR_NOTOPEN;
return FALSE;
}
if (m_pView == m_pNext)
{ *pdwResult = FSUIPC_ERR_NODATA;
return FALSE;
}
ZeroMemory(m_pNext, 4); // Terminator
m_pNext = m_pView;
// send the request (allow up to 9 tries)
while ((++i < 10) && !SendMessageTimeout(
m_hWnd, // FS6 window handle
m_msg, // our registered message id
m_atom, // wParam: name of file-mapping object
0, // lParam: offset of request into file-mapping obj
SMTO_BLOCK, // halt this thread until we get a response
2000, // time out interval
&dwError)) // return value
{ Sleep(100); // Allow for things to happen
}
if (i >= 10) // Failed all tries?
{ *pdwResult = GetLastError() == 0 ? FSUIPC_ERR_TIMEOUT : FSUIPC_ERR_SENDMSG;
return FALSE;
}
if (dwError != FS6IPC_MESSAGE_SUCCESS)
{ *pdwResult = FSUIPC_ERR_DATA; // FSUIPC didn't like something in the data!
return FALSE;
}
// Decode and store results of Read requests
pdw = (DWORD *) m_pView;
while (*pdw)
{ switch (*pdw)
{ case FS6IPC_READSTATEDATA_ID:
pHdrR = (FS6IPC_READSTATEDATA_HDR *) pdw;
m_pNext += sizeof(FS6IPC_READSTATEDATA_HDR);
if (pHdrR->pDest && pHdrR->nBytes)
CopyMemory(pHdrR->pDest, m_pNext, pHdrR->nBytes);
m_pNext += pHdrR->nBytes;
break;
case FS6IPC_WRITESTATEDATA_ID:
// This is a write, so there's no returned data to store
pHdrW = (FS6IPC_WRITESTATEDATA_HDR *) pdw;
m_pNext += sizeof(FS6IPC_WRITESTATEDATA_HDR) + pHdrW->nBytes;
break;
default:
// Error! So terminate the scan
*pdw = 0;
break;
}
pdw = (DWORD *) m_pNext;
}
m_pNext = m_pView;
*pdwResult = FSUIPC_ERR_OK;
return TRUE;
}
/******************************************************************************
FSUIPC_Read
******************************************************************************/
BOOL FSUIPC_Read(DWORD dwOffset, DWORD dwSize, void *pDest, DWORD *pdwResult)
{ FS6IPC_READSTATEDATA_HDR *pHdr = (FS6IPC_READSTATEDATA_HDR *) m_pNext;
// Check link is open
if (!m_pView)
{ *pdwResult = FSUIPC_ERR_NOTOPEN;
return FALSE;
}
// Check have space for this request (including terminator)
if (((m_pNext - m_pView) + 4 + (dwSize + sizeof(FS6IPC_READSTATEDATA_HDR))) > MAX_SIZE)
{ *pdwResult = FSUIPC_ERR_SIZE;
return FALSE;
}
// Initialise header for read request
pHdr->dwId = FS6IPC_READSTATEDATA_ID;
pHdr->dwOffset = dwOffset;
pHdr->nBytes = dwSize;
pHdr->pDest = (BYTE *) pDest;
// Zero the reception area, so rubbish won't be returned
if (dwSize) ZeroMemory(&m_pNext[sizeof(FS6IPC_READSTATEDATA_HDR)], dwSize);
// Update the pointer ready for more data
m_pNext += sizeof(FS6IPC_READSTATEDATA_HDR) + dwSize;
*pdwResult = FSUIPC_ERR_OK;
return TRUE;
}
/******************************************************************************
FSUIPC_Write
******************************************************************************/
BOOL FSUIPC_Write(DWORD dwOffset, DWORD dwSize, void *pSrce, DWORD *pdwResult)
{ FS6IPC_WRITESTATEDATA_HDR *pHdr = (FS6IPC_WRITESTATEDATA_HDR *) m_pNext;
// check link is open
if (!m_pView)
{ *pdwResult = FSUIPC_ERR_NOTOPEN;
return FALSE;
}
// Check have spce for this request (including terminator)
if (((m_pNext - m_pView) + 4 + (dwSize + sizeof(FS6IPC_WRITESTATEDATA_HDR))) > MAX_SIZE)
{ *pdwResult = FSUIPC_ERR_SIZE;
return FALSE;
}
// Initialise header for write request
pHdr->dwId = FS6IPC_WRITESTATEDATA_ID;
pHdr->dwOffset = dwOffset;
pHdr->nBytes = dwSize;
// Copy in the data to be written
if (dwSize) CopyMemory(&m_pNext[sizeof(FS6IPC_WRITESTATEDATA_HDR)], pSrce, dwSize);
// Update the pointer ready for more data
m_pNext += sizeof(FS6IPC_WRITESTATEDATA_HDR) + dwSize;
*pdwResult = FSUIPC_ERR_OK;
return TRUE;
}
/******************************************************************************
End of IPCuser module
******************************************************************************/

Alles anzeigen

blubberblub · 3. April 2010, 20:25

Hmm.. kannst du mir vl die Links dazu schicken mit header files libs usw? evtl könnt ich ja was machen, müsste nicht unbedingt so ein riesen aufwand sein... hab zwar keine ahnung von c, aber gerade deswegen würd ich mir das mal gern anschaun..

BenBaron · 3. April 2010, 20:34

Hey...danke schonmal fürs anschauen...das ganze SDK für verschiedene Programmiersprachen bekommst du hier: schiratti.com/files/dowson/FSUIPC_SDK.zip?timestamp=010309

blubberblub · 3. April 2010, 21:58

Ok, habs mir jetzt n bissl angeschaut.
Prinzipiell kann die library 2 dinge machen: lesen und schreiben.
Dazu gibst du eine Adresse im Speicher vom Flightsim an(Dazu musst du erstmal nachschauen, wo was abgespeichert ist im Memory) und liest bzw schreibst dann.
Die Library definiert aber nirgendswo Konstanten oder ähnliches, mithilfe deren man wüsste, wo welche Variablen im Memory vom Flightsim zu finden sind.
Im Sdk Zip File liegt ja auch noch so ein Pdf Dok bei, in dem die ganzen Adressen beschrieben werden.
Man müsste also selber ein Mapping von Adressen mit ansprechenden Namen und den Datenstrukturen an den Adressen machen, und das ist einerseits zeitaufwändig, und andererseits müsste man auch testen können(hab kein Flightsim, kann also nicht testen).
Es wäre sehr unschön, das direkt mit dem Gamemaker anzusprechen( du müsstest ne hexadezimale adresse angeben und die daten(die einzelnen bytes) in einer liste oder sowas abspeichern müssen...).
Mit dabei im Sdk ist ja noch dieses Programm: FSInterrogate2std.exe
mit dem sich n haufen Variablen managen lassen.
Ich kanns nicht testen, da ich keinen Flightsim hab, aber wieso benutzt du nicht einfach dieses Programm?
Gibts was spezielles, was du im GM anstellen willst?

BenBaron · 3. April 2010, 22:16

Hi...danke nochmal fürs ansehen...soweit ich es verstanden (und auch verwendet habe) ist dieses FS Interrogate nur dazu da, um die ganzen grafisch Adressen auszulessen und anzeigen zu lassen. Damit kann man dann beispielsweise per drag and drop ganz einfach Adressen suchen, die man im eigenen Programm ansprechen muss, um bestimmte Variablen auszulesen. Ich glaube sonst kann man das für nix anderes verwenden...ich habe mir aber schon gedacht, dass alles andere recht schwierig werden könnte.

Ich habe da schon bestimmte Ideen, was ich vielleicht machen wollen würde, nur leider impliziert das, dass ich Daten aus dem Flusi auslesen müsste. Wie gesagt, ich habe ja auch schon diverse Sachen mit Visual Studio gemacht, wo alles nach includieren der im SDK enthaltenen library und ansprechen der entsprechenden hex adressen gefunzt hat, nur gerade der grafische Teil wäre mit GameMaker weitaus einfacher zu handeln, zumal man dann vielleicht sogar eine Action Library erstellen könnte und somit ganz leicht per drag and drop bestimmte Sachen auslesen/schreiben könnte

. Aber ohne das Testen zu können ist das natürlich Mist. Hab ich mir vielleicht auch einfach zu leicht vorgestellt :rolleyes:

.

Gruß, Benny

blubberblub · 3. April 2010, 22:35

Naja, es gibt ja auch zb für C# eine Library bzw du könntest auch C++/CLI mit Windows Forms nutzen und ziemlich einfach ein GUI erstellen... im GM müsstest du erstmal Buttons und Textboxen & co programmieren...
So wie ich gelesen hab, lassen sich mit dem Tool auch Variablen verändern.

Grüssle

BenBaron · 4. April 2010, 13:35

Danke erstmal für deine Bemühungen...unter Umständen werde ich versuchen in C++ eine kleine App zu schreiben und damit dann Daten zwischen GameMaker und der dll auszutauschen. Mal sehen ob das klappt...hab mir da letzte Nacht was überlegt

.
Gruß, Benny

Spellmaker · 4. April 2010, 18:49

Eine App ist unnötig, im Prinzip müssen nur die extern aufrufbaren Funktionen
in Hinsicht auf Rückgabetypen und Parameter (Game Maker kann nur mit
*char[] und double was anfangen bzw übergibt so alles) angepasst werden.
Dann kann die dll mit den external_ Funktionen im Game Maker benutzt
werden.