Skip to content

Latest commit

 

History

History
69 lines (52 loc) · 2.83 KB

README.md

File metadata and controls

69 lines (52 loc) · 2.83 KB
Raw

sfgml

Quick links: itch.io page (donations, discussions) · GitHub wiki · original documentation

This library allows you to write code for GameMaker games in Haxe.

It is primarily intended for writing complex systems that are otherwise trickier to write in a language without compile-time checks.

You can find a list of things I have used it for in this blog post.

Setting up

haxelib git sfhx https://github.com/YellowAfterlife/sfhx
haxelib git sfgml https://github.com/YellowAfterlife/sfgml

Per-project setup

This implies that you have at least a very basic degree of understanding of how Haxe works.

haxe -debug -dce full -lib sfhx -lib sfgml -cp src -main Main -js targetPath._

(note: ._ suffix on the path is necessary to prevent Haxe compiler from overwriting non-code GameMaker files)

targetPath is decided as following: GMS1:

  1. Create an empty extension
  2. Add a an empty GML file to it via "add placeholder"
  3. targetPath is the path to .extension.gmx

GMS2 (<2.3):

  1. Create an empty extension
  2. Add a an empty GML file to it via "add placeholder"
  3. targetPath is the path to the extension's YY file

GMS2 (≥2.3):

  1. Create a new script
  2. targetPath is the path to the script's YY file

So you might have

haxe -debug -dce full -lib sfhx -lib sfgml -cp src -main Main -js myProject/scripts/scr_haxe/scr_haxe.yy._

For FlashDevelop/HaxeDevelop, create a Haxe-JS project and use menu:Project➜Properties to

  • Set target path in the first tab
  • Add -dce full to Additional Compiler Options on the third tab
  • Add sfhx and sfgml to library list on the third tab

Supported features

For GameMaker Studio ≥ 2.3, things are pretty good as the language now has reflection, anonymous objects, exception handling, and overall is pretty much a beefier JS. There are a few caveats:

  • GML still doesn't have regular expressions so sfgml doesn't either.
  • Bit operations are 64-bit because GML integers are 64-bit.
  • Local variables are not auto-shared into closures.

For older versions, the language was more limited so there are more limitations:

  • No exception handling (except for -D sfgml_catch_error, which utilizes catch_error).
  • No reflection (apart of a few selected tricks in Type API).
  • No anonymous structures (except when result is a typedef with known fields).
  • No function closures.
  • Normal and dynamic methods work like normal/virtual methods in C# - if you are calling a non-dynamic method, it will be compiled to a static reference to the target type's method implementation for performance.
  • Type checking for a lot of GML externs is nonexistent since they are referenced by index.