Install:Git:Windows - hpgDesigns/hpgdesigns-dev.io GitHub Wiki

Herein we will attempt to document the steps that we have taken to get a working ENIGMA install on Windows from the Git repository. This process will probably largely be a big hack, just to get it working first. Then, we'll work on revising this process to make it more elegant in the future. This process will probably still be kept around for the down-and-dirty people who make the elegant solution possible.

Generally, a git install of ENIGMA follows the following steps:

  1. Install Git (if you don't have it already)
  2. Git enigma-dev
  3. Obtain dependencies
  4. Plug in binaries
  5. (Optional) Compile Enigma
  6. Run
  7. Compile First Game

Currently, we're stuck at step 4, because of some internal library that has gone missing.

Git

You may install any of the git clients available to you. See Git for details on obtaining one.

Next, point your client to our repository and clone it to a directory of your choosing. From command line, this is done with the following command:

git clone

If you want to clone to a different named folder than the default 'enigma-dev', you may simply add a space, and then the folder name to the command, like such:

git clone `` enigma

Dependencies

This step is largely the same as a normal install.

  • MinGW - Must be a newer version. Steps are provided below for how to install it.
  • Java - Needed to run the user interface, LateralGM.

MinGW

We will need a newer version of some MinGW tools. As of 2012-02-01, the normal MinGW install did not include tools updated enough for us, so we have to grab their development install instead.

  1. Download http://sourceforge.net/projects/mingw/files/latest/download?source=files and launch the installer.
  2. It shouldn't matter if you use the packaged catalogs or update the catalogs. I opted to update them.
  3. It is preferred that you install to the default location - usually C:\MinGW.
  4. When asked which tools to install, choose the following (the rest are unneeded):
    • C compiler
    • C++ compiler
    • ObjC compiler
    • MSYS Basic System

Uh

At this point, I got stuck.

Binaries

Each of these must be placed in a specific place relative to the enigma directory.

  • enigma-dev/ENIGMA.exe - Technically optional, although recommended. It will try and find/install additional dependencies, set up the compiler configuration (gcc.ey), and launch the user interface. Without it, you will need to do these tasks manually.
  • enigma-dev/lgm16b4.jar
  • enigma-dev/plugins/enigma.jar
    • This is the plugin that connects enigma to the IDE.
  • enigma-dev/plugins/shared/jna.jar
    • This is JNA, a lower-level library that connects the backend of the plugin to the backend of enigma and allows Java to call the DLL.

Ensure that each file ends up in its respective directory. If you are an active git-privileged developer, you should not need to worry about these files accidentally ending up in the repository, because the .gitignore file has rules to ignore jar files.

I'm probably missing a couple.

Go

As an optional step prior to launching, you may wish to compile ENIGMA. Note that if you just run without compiling, it will attempt to compile itself, which is why this step is usually completely unnecessary.

Launch ENIGMA.exe, if you opted for that route. If not, ensure that you installed the necessary dependencies and set up gcc.ey, and then launch lgm16b4.jar. As mentioned, it will try to compile ENIGMA itself. The exact mechanics behind this, for those who are curious on how enigma can build itself, are as follows:

  1. ENIGMA.exe launches lgm16b4.jar, which is LateralGM.
  2. LateralGM launches valid plugin jars in the plugins/ folder. This includes enigma.jar.
  3. enigma.jar invokes `make`.
  4. make interprets the Makefile
    1. The Makefile tells make to recurse through the directories, invoking the appropriate toolchain executables on the appropriate sources in the appropriate order, creating binary objects.
    2. The Makefile then links all the binaries together and creates the compileEGMf DLL/SO/DyLib and returns success. ENIGMA is built.

Assuming everything went well (which is a big assumption), LateralGM and ENIGMA should be able to communicate freely, so you can create/load your game.

Game

Before compiling/loading your game, it is important to ensure that the game-specific compiler settings are appropriate for your game.

Notably, at your current hacked-together stage of ENIGMA, you will want to change the sound system, because Alure (the sound library) is currently not hooked in properly:

  1. Open ENIGMA Settings. Either access this from the ENIGMA menu, or by double clicking the tree node.
  2. Open the API tab.
  3. Change the Sound system from OpenAL to None.
  4. Save

Now you're ready to compile/run from the ENIGMA menu.