Install:Git:Windows

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 (dl.dropbox.com)
  • This is LateralGM, the
    IDE.
• enigma-dev/plugins/enigma.jar (dl.dropbox.com)
  • This is the plugin that connects enigma to
    the
    IDE.
• enigma-dev/plugins/shared/jna.jar (dl.dropbox.com)
  • 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.