ENIGMA Development Environment

If you happen to want/need OpenAL or FreeType for anything, here's a zip with the required DLL's. Note some of the dependencies of both are licensed under LGPL meaning you cannot statically link with them and release your game closed source, even with a linking exception (while I know this for certain with OpenAL, I'd have to double check with FreeType). Both have missing required static libraries from the MSYS2 pacman packages anyway, so you couldn't easily do it even if you wanted to release your game open source.

TL;DR to use OpenAL/FreeType distribute these DLL's with your game:
https://drive.google.com/file/d/1gagR9bycmIQKRCKQyhMpTvwEk5mXezcE/view?usp=sharing

The "win32" folder for 32-bit games. The "win64" is for 64-bit games.

I will try to update the above link to make sure the DLL's remain up-to-date with the latest versions available intermittently. If they stop working after packages have been updated I recommend letting me know in this topic so I can update the download to have the latest versions.

I won't be updating the DLL's at all until pacman's shipped versions of gRPC/abseil/protobuff are no longer breaking the Windows build.

In the meantime you can use older versions of the Windows installer which actually work.

Technically not sure if you even need libffi but I included it in the download anyway just in case. I added that in case any of the requred DLL's use that to call other dependency functions.

Samuel

I wrote a function for Windows and Xlib platforms which works in ENIGMA. It should also work with SDL minus Mac and Android.

You can use execute_shell() or execute_program() to have a launcher executable launch a game executable. The launcher could serve as a "choose a game" menu or even an updater application.

You can save window_identifier() since it is already a string and make it an environment variable which gets passed down to the child. The child can then plug in the environment variable it inherited as the parentWindowId and its own window_identifier() can be the child windowId parameter passed to these two functions:

// embed window identifier into parent window identifier (called once)
void WindowIdSetParentWindowId(wid_t windowId, wid_t parentWindowId) {
  #if defined(_WIN32)
  HWND child  = (HWND)(void *)(uintptr_t)strtoull(windowId.c_str(), nullptr, 10);
  HWND parent = (HWND)(void *)(uintptr_t)strtoull(parentWindowId.c_str(), nullptr, 10);
  RECT wrect; GetWindowRect(parent, &wrect); RECT crect; GetClientRect(parent, &crect);
  POINT lefttop     = { crect.left,  crect.top    }; ClientToScreen(parent, &lefttop);
  POINT bottomright = { crect.right, crect.bottom }; ClientToScreen(parent, &bottomright);
  MoveWindow(child, -(lefttop.x - wrect.left), -(lefttop.y - wrect.top), crect.right + bottomright.x, crect.bottom + bottomright.y, true);
  SetWindowLongPtr(child, GWL_STYLE, GetWindowLongPtr(child, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU | WS_POPUP | WS_SIZEBOX) | WS_CHILD);
  SetWindowLongPtr(child, GWL_EXSTYLE, GetWindowLongPtr(child, GWL_EXSTYLE) | WS_EX_TOOLWINDOW);
  SetWindowLongPtr(parent, GWL_STYLE, GetWindowLongPtr(parent, GWL_STYLE) | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  SetParent(child, parent); ShowWindow(child, SW_MAXIMIZE);
  #elif (defined(__linux__) && !defined(__ANDROID__)) || (defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__))
  Window child  = (Window)(uintptr_t)strtoull(windowId.c_str(), nullptr, 10);
  Window parent = (Window)(uintptr_t)strtoull(parentWindowId.c_str(), nullptr, 10);
  Display *display = XOpenDisplay(nullptr); XMapWindow(display, child);
  Window root = 0, rparent = 0, *children = nullptr; unsigned int nchildren = 0;
  XQueryTree(display, child, &root, &rparent, &children, &nchildren);
  XReparentWindow(display, child, parent, 0, 0); if (nchildren > 0) { XFree(children); }
  XFlush(display); std::this_thread::sleep_for(std::chrono::milliseconds(5));
  while (parent != rparent) {
    XSynchronize(display, true);
    XQueryTree(display, child, &root, &rparent, &children, &nchildren);
    XReparentWindow(display, child, parent, 0, 0); if (nchildren > 0) { XFree(children); }
    XFlush(display); std::this_thread::sleep_for(std::chrono::milliseconds(5));
  }
  XCloseDisplay(display);
  #else
  DEBUG_MESSAGE("Unsupported platform for function!", MESSAGE_TYPE::M_INFO);
  #endif
}

// update embed area of window identifier to fill parent window identifier client area
// (must be called every step once a window is embedded inside another to function)
void WindowIdFillParentWindowId(wid_t windowId, wid_t parentWindowId) {
  if (strtoull(parentWindowId.c_str(), nullptr, 10) == 0) return;
  #if defined(_WIN32)
  HWND child  = (HWND)(void *)(uintptr_t)strtoull(windowId.c_str(), nullptr, 10);
  HWND parent = (HWND)(void *)(uintptr_t)strtoull(parentWindowId.c_str(), nullptr, 10);
  RECT crect; GetClientRect(parent, &crect);
  MoveWindow(child, 0, 0, crect.right, crect.bottom, true);
  SetWindowLongPtr(child, GWL_STYLE, GetWindowLongPtr(child, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU | WS_POPUP | WS_SIZEBOX) | WS_CHILD);
  SetWindowLongPtr(child, GWL_EXSTYLE, GetWindowLongPtr(child, GWL_EXSTYLE) | WS_EX_TOOLWINDOW);
  SetWindowLongPtr(parent, GWL_STYLE, GetWindowLongPtr(parent, GWL_STYLE) | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  #elif (defined(__linux__) && !defined(__ANDROID__)) || (defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__))
  Window child  = (Window)(uintptr_t)strtoull(windowId.c_str(), nullptr, 10);
  Window parent = (Window)(uintptr_t)strtoull(parentWindowId.c_str(), nullptr, 10);
  Display *display = XOpenDisplay(nullptr); XMapWindow(display, child);
  Window r = 0; int x = 0, y = 0; unsigned w = 0, h = 0, b = 0, d = 0;
  XGetGeometry(display, parent, &r, &x, &y, &w, &h, &b, &d);
  XMoveResizeWindow(display, child, 0, 0, w, h);
  XCloseDisplay(display);
  #else
  DEBUG_MESSAGE("Unsupported platform for function!", MESSAGE_TYPE::M_INFO);
  #endif
}

It's relatively seamless, especially on Windows. It will embed the game window to fill the launcher's client area. I have a means to close the child process when the launcher exits so you don't have the game continuing to run in the background. You can borrow code from my repository to have that automated in enigma internally so you don't risk people writing stuff wrong and terminating the wrong process id which can be avoided if you let enigma handle that for them. You can also make the step event code fire every step automatically too if you want, that will save the user from having to call it manually.

Please note embedding windows is a very popular extension feature that a lot people want on the GMC and have wanted in their projects ever since even pre-GM6 era to the present.  Over time various existing DLL's either lost their compatibility with the newer versions of GM, links to download them went dead, or the solution was closed source and not written with cross-platform in mind. I was paid $275 USD to write the above code, to put it into perspective, they knew it wasn't much work to write, but insisted to pay me that much because that's how much they wanted it. I think you would make a lot of your users happy for adding this.

It's not broken, you just need to distribute dll's with your game and OpenAL will work again.

Here's the files you need:

https://drive.google.com/file/d/1gagR9bycmIQKRCKQyhMpTvwEk5mXezcE/view?usp=sharing

put them in the working directory of your game.

Thank you all the hard work. I know it may not seem like it, but i really do appreciate what you have done to keep this site secure, and for warning everyone to not use the same passwords everywhere. Safety first is a good policy. I'm sorry I haven't been as much of a help around here as I'd like to be. A lot of that is my fault for not prioritizing the right things and being a bit of a hindrance and I hope things get better for you all. Maybe if i post more free-to-use (and free-to-relicense) code snippets I write i could at least help out that way with no access to your repository.

This topic was a painful read.

No - you don't need to install manjaro. It will work with any Linux distro if you actually know what you are doing.

To top it all off, if you know how to copy and paste a script from our Ubuntu/Debian wiki, that should work just fine on Raspbian.

I did that just now. My pi came in the mail today. Instructions didn't need to be modified. It 'just works'.

ENIGMA port of this GameMaker asset: https://marketplace.yoyogames.com/assets/9730/virtual-visit-maker





Requires installing ENIGMA with a custom script so you may use third-party extensions not included in ENIGMA base. You can get the curstom script for your platform here: https://github.com/time-killer-games/enigma-dev be sure to read the ReadMe first at that link. On top of whatever dependencies your game uses, Ubnntu/Linux users will also need:

sudo apt-get install libsdl2-dev libglu1-mesa-dev freeglut3-dev mesa-common-dev libpthread-stubs0-dev libx11-dev libprocps-dev
Ubuntu/Linux users will need to run the build64.sh script in the cmdline folder of the downloadable *.tar.gz on this page. If you run Ubuntu 20.04 LTS binary compatiblity specifically, no build needed. Windows/Mac users don't need extra deps nor should you need to build from source code on those platforms, instead, download and extract the exe in the release zip from and here: https://github.com/time-killer-games/panoview/releases/tag/v1.0.0.0 and put that file directly into the cmdline folder found in the *.tar.gz file.

Designed for games to run in headless mode, Windows users need to set the window invisible and Liuux/Mac can simply set the platform to None. Download *.tar.gz: https://drive.google.com/file/d/1FsPONo1jrNHvzdlZHyq46Gf0107_yXb-/view?usp=sharing

i cast 3 votes, 1 to each of them

Running NGINX Server in GameMaker and ENIGMA

ENIGMA | GM Version: GameMaker Sudio 2.x or later (ENIGMA and GMS 1.4.x too but w/ different string handling)
Target Platform: Windows, (macOS and Linux/Ubuntu need slightly modified instructions)
Links:  CLICK HERE FOR PROCESS INFO'S EXTENSION DOCUMENTATION
Downloads (Required): NGINX, FILE MANAGER, PROCESS INFO

Introduction:

ENIGMA users can ignore the download links for File Manager and Process Info above. Server and client interaction is very common in games and my Process Info extension allows you to do much more with that. For the time being, these extensions are not available in ENIGMA's main repository. File Manager is virtually the same as the upcoming official support for std::filesystem in ENIGMA, however I have several bells and whistles added in my repository such as the ability to pass environment variables directly to string arguments when in the form of, for example, ${VARIABLE}.

TL;DR ENIGMA users have to install ENIGMA from the instructions on my own repository instead to get the required extensions:

https://github.com/time-killer-games/enigma-dev

Then you may proceed with this tutorial.

Summary:

Someone added me on Discord asking me how to do this with my Execute Shell extension, so I used that as an excuse to educate everyone here on a practical use case for my much more powerful extension called Process Info, hoping more people switch to using that extension instead of my Execute Shell and Evaluate Shell extensions, which are much less powerful and deprecated in favor of Process Info. They are also no longer actively developed and won't receive any feature updates. Use Process Info instead, it has a learning curve that is steeper, but you will learn to appreciate it with time as you learn what it can do.

Here I am explaining how to use Process Info more specifically on the topic of how to properly run your own NGINX server.

Tutorial:

Download NGINX and extract the ZIP archive. Drag and drop all the files in the extracted contents, (if extracted to a new folder, the contents of that folder), into your GameMaker Studio 2.x window to add them as included files for your project to make use of them. Not just the nginx executable, but also the folders it depends on which are also included in the ZIP you extracted. Create a controller object obj_conttroller, create a blank room with a black background, and then drag your controller object from the resource tree into your room. Now your body is ready.



In the Create Event of your controller object...

General Initialization and copying all your files to where they need to be is the first thing we need to take care of before we can do anything else.

1) First, choose a process index, similar to a resource id like for a sprite or other stuff, but this will represent a unique instance of a running application so we can later get various information from it such as output that would show in the terminal or command prompt if something goes wrong you can further debug it with ease. I chose the variable name to be nginx because that is the name of the executable we are running here, and a value of 0 stored in the variable to uniquely identify the process index:globalvar nginx; nginx = 0;
2) Next, we create the sandbox directory, using the game_save_id constant, which is a writable directory, the working directory won't always be writable, thus we are using the sandbox directory for that reason alone: directory_create(game_save_id);
3) Then, copy the included files we have in our project (nginx and its associated files and folders) using my File Manager extension's directory_copy function: directory_copy(working_directory, game_save_id + "files");
4) We need to set a new working directory to where we copied the included files to, using File Manager's set_working_directory(dname) function, like so:set_working_directory(game_save_id + "files");and that will set the new working directory to the "files" subdirectory we copied into the sandbox folder game_save_id from the working_directory in step 3. It will also copy everything else the game depends on, not just the included files you previously drag and dropped onto the GameMaker Studio 2 IDE window.

Now we can write a batch file that will run nginx and we will write it directly to our sandbox, (not to be confused with what we set the working _directory to, which is the "files" subfolder within the sandbox folder game_save_id):
f = file_text_open_write(game_save_id + "nginx.bat");
file_text_write_string(f, @'cd "' + working_directory + @'" & "' + working_directory + @'nginx.exe"');
file_text_close(f);
Notice above I also set the working directory of the batch file using the cd command, which is necessary to get this stuff working. Now for the good part; we are going to execute asynchronously an instance of a nginx web server process, but first, please notice I created a temp folder:
directory_create(working_directory + "temp");
process_execute_async(nginx, @'cmd /c @ECHO OFF & "' + game_save_id + @'nginx.bat"');
That temp folder is needed by nginx, otherwise it will complain in the process standard output that the folder doesn't exist. Notice there are two arguments to our process creation function, the second argument is the command itself, not the first. In the second argument we are running the batch file we created earlier found in our sandbox directory game_save_id.

The first argument of process_execute_asnyc(ind, command), on-the-other-hand, should be the global variable we set in the very first step of this tutorial, nginx as the variable's name and zero as its value to represent an index for the specific running application instance, which will be used to get process output for debugging purposes like mentioned earlier. That leads to our next step major step in this tutorial.

Done with Create Event. Now Draw Event / Draw GUI.

Now we are going to draw the process output to our game window in case something went wrong. If you followed this tutorial perfectly as described, no text should be drawn. In the code below you'll see I am setting a custom font named fnt_example, you will either need to create a font yourself that has this name or omit that line completely. The key thing is the text needs to not be cropped when drawn, so make the text small enough it is readable but will still fit in your game window or view-port for easy viewing. If you want to program a camera system to view the output text more power to you but that I won't be covering and it is a lot of unnecessary extra effort. The second line is where we actually draw the process output, should you have messed up following any steps thus far, text will draw and you will need to go back and review this tutorial to debug what the issue is based on what info is drawn.
draw_set_font(fnt_example);
draw_text(0, 0, process_output(nginx));
process_output(ind) will return the process output for the specified process index, that is, the running application process that was started using the exact same process index ind argument. To clear process output when you no longer need it and wish to free memory, call process_clear_out(ind) on the same exact process index value, in this case the value we have stored in the nginx global variable.

Done with Draw Event / Draw GUI. Now for Game End Event.

Now, create a Game End event in your controller object, and give it the following code to execute when triggered:
process_execute(999, @'"' + working_directory + @'nginx.exe" -s stop');
This will cause the nginx server to shut down automatically when you close the game, to prevent it running in the background after you are done with it. Notice I used process_execute(ind, command) which will run synchronously, unlike process_execute_async(ind, command) which is what we used earlier. For the process index ind argument I used 999 as the reserved value to represent this process to make room for other process indexes to be used throughout your program should you ever have the need to run 999 other processes (counting zero) simultaneously, this allows for that many if you count up without skipping a reserved value for each process you create. Though 999 is not required, you may use any ridiculously high number if you wish that is less than ULONG_MAX(=4294967295). The key thing is that every process you have running from your game or application must have a unique index when run and held in memory simultaneously. A process index also can not be negative nor can it have a decimal value.

To free a process index from memory, call process_clear_pid(ind) to get rid of the pid's (process identifer, not the same thing as an index) held in memory, as well as call process_clear_out(ind) to get rid of the process index's standard output strings held in memory.

In other words, for example:
process_clear_pid(nginx);
process_clear_out(nginx);
process_clear_pid(999);
process_clear_out(999);
The above can be put in your Game End event after the process_execute(ind, command) call for general code cleanup.

If you followed everything correctly, you should have the following code in your controller object:

Create Event:
globalvar nginx; nginx = 0;
directory_create(game_save_id);
directory_copy(working_directory, game_save_id + "files");
set_working_directory(game_save_id + "files");
f = file_text_open_write(game_save_id + "nginx.bat");
file_text_write_string(f, @'cd "' + working_directory + @'" & "' + working_directory + @'nginx.exe"');
file_text_close(f);
directory_create(working_directory + "temp");
process_execute_async(nginx, @'cmd /c @ECHO OFF & "' + game_save_id + @'nginx.bat"');Draw Event (or Draw GUI, either one):
draw_set_font(fnt_example); // optional line
draw_text(0, 0, process_output(nginx));Game End Event:
process_execute(999, @'"' + working_directory + @'nginx.exe" -s stop');
process_clear_pid(nginx);
process_clear_out(nginx);
process_clear_pid(999);
process_clear_out(999);
Like normal when running the NGINX server executable, it will ask you for permission to access your local network, and which you will need to accept. You can view the server by typing in "localhost" in your favorite internet browser.

Happy Coding!
Samuel