GFFI is a dll that allows you to call functions from other dlls.
It is much more flexible than external_call, supporting
all the basic data types in C, as well as providing advanced features for
working with structs and arrays. There are no restrictions on the
number of string arguments (or any other argument type for that matter)
other than Game Maker’s 16 argument limit (this can be worked around
in future if the need is there). The functionality provided is similar
to Python’s ctypes module and .NET’s P/Invoke system.

The speed should be comparable to external_call. There is slightly more overhead
due to the dynamic nature of the code, which uses transparent type conversion
and intelligent assembly code. Through the use of Gmapi, all the
functions available for use are inserted as a builtin GM function. There is no
interpreted code involved once you call a GFFI function. Nearly all the scripts
provided are placeholders to avoid syntax errors, they also contain documentation.

I hope people find this DLL useful, I used it as an opportunity to learn some C
(and then hastily tacked on a C++ library).
I’ve included a few basic examples of usage – it’s perfect for making a few
WinAPI calls without writing an ad-hoc wrapper dll.

Update: I released this just before GM8 came out. I just added support for GM8 as well.

GFFI 1.1

Anyway, it does pretty much everything the old one didn’t:

• Decompiles Instant Play games
• Extracts extensions from GM7 games
• Extracts Game Icon, exe info
• Shows a progress dialog rather than freezing
• Fixes a bug that I know at least one person exploited to make their game “undecompilable”

Yes, it’s obfuscated. No, you still can’t have the source, though I’m wondering what would happen if I did release it.

As a final note, at least some good will come of this. The information collected in the making of this tool makes it possible for third party programs to compile exes using the GM runner. No, we haven’t investigated the legality of this exhaustively yet, but it will make programs like LateralGM far more useful if we can do it.

edit: Fixed a bug with extensions, latest version is now 2.1

Gm Decompiler v2.1

GM Gui

This is for educational purposes only, the documentation about the encryption and how its broken can be found on the internets.

GM Decompiler

In celebration, here is the editable to something really neat I wrote a while ago. It’s a ridiculously fast (for what it does) terrain renderer which supports spec highlights and I would bet, beats using tiles on occassion. It’s an extension of my metaballs rendering concept applied across any number of tile layers without involving a second surface.
It’s just a proof of concept for an idea I never got to finish and polish, but hey so is a lot of other stuff I put here. Once again, look, learn, use. Or, attempt to blindly integrate it in your game and hope for the best.

Oh by the way. It was written back in gm6, and gm6 had a stupid bug to do with surfaces, which I had to cheat around. In gm7 it seems to have been dealt with so my workaround actually causes the inverse of the bug to happen. So if you’re using it in gm7, open the startup script and change the values of fx and fy to 1.

Surface Based Terrain

Fireflies

While the thing itself is outdated, it still shows some good things to learn from like drawing smooth outlines around sprites and some uses for luminance scan, which you’ll find in every modern lighting engine.

Realtime Dynamic Light

I thought a while before posting this and decided that I will after all. The main reason this is here is to give Mark and Yoyo a poke towards releasing a new version of gm and spending more money on its development as opposed to YoYo’s… Unusual business strategies. The other reason is that its actually incredibly simple and a lot of people know how to do it anyway. Gm6 can be forced into debug mode with a single winapi call, and gm7 can be forced into an even more dangerous debug more with the switch of a single byte. I kid you not!

What does it mean? It means your resources aren’t safe anywhere. While this is not a full-fledged decompiler, it does allow one to extract scripts, sprites, backgrounds, sounds, etc. It also allows them to inject code into any game which means you can do pretty much anything. The fact that it’s not a full-fledged decompiler is actually nice because it means that at least as far as gm6 is conerned, it doesn’t even break the tacky EULA that comes with GM. I say tacky because its been added to and modified to ‘keep up’ with the evolving ways of exploitiong GM’s obvious weaknesses and its become so messy that it just stumbles all over itself and is so vague that I’ll eat my hat if it ever wins anyone a case in court.

Debug Enabler

You might have seen this as part of an older GUI demo I posted. It’s a really smooth circular progressbar type thing. I just ran into it and thought it’d be nice to share. I still have to figure out what to do with my smaller creations.
Incidentally, I went and found the demo in question and linked it here, even though I’ve lost the source to that particular build and can only offer an exe. I still think its a good little demo to look at as it demonstrates a number of things I takled about working in concert: interface, eyecandy, my object importer (here it is used to fetch content from the web and run it). You’ll find the demo at 64digits.

As for the sample itself… Progress ring.
And don’t fret, the editable for my GUI in it’s latest form is coming.

You create a logic chain by placing links between the ‘input’ and ‘output’ points of actions/conditionals/loops/whatever. The rule is that at least one point of a link must be blue, and you can not link two blue points. Basically, make sure you only connect outputs and inputs, not two of the same kind.
The execution starts from the function entry-point, the tag with only a white output.
Currently you can not break links
Currently you can link two outputs to the same input as a legal operation. Do you think this should be kept that way?
Currently there is no checking for infinite loops (such as an output of a function linking straight back to it’s own input)
On an IF, the green output links to what’s executed if the IF returned true, red for false, and white for whatever happens afterwards.

Once you’re done with the diagram, hit Return, and it will compile a script which will be saved to the same path as the program as ‘out.txt’
If it freezes or throws an error, you created an infinite loop or other non-logical thing in the diagram.

It’s limited to random IFs and one function right now, but that can now easily grow.

The editable to this was lost with my hdd in 2006 so this is an exe.

Visual Logic Editor