The case creator: A first look

We’ve said a lot in this space about what’s in store for players in case 2, but one thing that we’ve only touched on in passing each time it’s come up has been the My Little Investigations case creator, which is also in development in tandem with the second case. It’s still nowhere near ready for public consumption yet, but it’s nonetheless coming along quite well, so I thought I’d take a little while to show people what to expect from it.

Anyone who’s either worked on translating the first case, or who has just looked at the case XML file, will know that the format of the case file in its current form is a huge mess. That’s more or less by design – it was never intended to be human-readable – but it still throws up a huge hurdle for people wanting either to edit existing cases for translations, etc., or perhaps even to make their own cases. So, both to facilitate that – and to make my own job easier, too – we’re working on developing a much more user-friendly case creator, which will be able both to read and edit MLI case files and to create new case files from scratch.

NOTE: The user interface displayed in these pictures is still very much in development, so don’t take anything from this other than a very high-level impression of the design direction.

(Click pictures to see the full-size image.)

MLI Case Creator - 1

As said above, this UI is still very early, but the general idea behind the case creator is that people should be able to use it without having any understand of programming or anything like that – to the fullest extent possible, we want the case creator to be intuitive to use. In this case, which is the location editor, everything present in this location is displayed in layers that can be enabled or disabled, and anything in an enabled layer can be dragged to where the creator wants it to be. Selecting an element will also bring up a pane that will let you edit any properties of that element, such as determining its position more granularly, defining what should happen when the player clicks it, conditions that determine the presence of a character or object (not yet implemented), and so forth.

MLI Case Creator - 2

Editing character encounters is necessarily less visual in nature, since there’s nothing to be laid out on screen, but I’m still doing my best to make it as easy to understand as possible. Conversations are organized in a hierarchical format, with new layers of the tree created anytime something branches, like a condition, a loop, a multiple-choice question, and so forth. If you click on a conversation action, you can see what it looks like in the top-right window, and you’ll be able to click to play any given line of dialog to see if the text synchronization or emotional choices look good, or whether you’ve selected the right voice line.

MLI Case Creator - 4

To edit an action, just double-click it to bring up a dialog window that facilitates that functionality:

MLI Case Creator - 3

Or, to insert an action, you can just double-click on one of the separators, which will display a message on mouse-over saying that you can do that.


Editing cutscenes is somewhat a combination of the two, in that you can see the current state of the cutscene visually, including character and camera positions, while also being able to edit the cutscene phases on the right in the same way you can edit conversation actions.

There’s still a lot that has yet to be implemented – for example, you can’t yet edit characters, evidence, or zoomed-in views – but all of that is in the pipeline. This will be the tool that we’ll be internally using to implement case 2, so the tool will get plenty of internal usage that will vet its usability. Once it’s released, we’ll also be releasing a pack containing all of the audio and visual assets used to date in MLI in both case 1 and case 2 (that will include all the mane 6, plus Spike, plus all the other characters seen in those cases), which will give people a good base to build upon if they want to develop their own cases.

That’s all we’ve got so far. Sorry we’ve been a bit lax in terms of posting to this space. I know I say that often, but, well, that’s because it continues to be true. Thanks for your patience as we continue to develop. ‘Til next time!

MLI now supports localization!

(Note: The following requires that players install MLI v1.1 using an installer; the in-process updater won’t work properly. You can get the v1.1 installer here.)

We’ve been in contact with some Russian bronies from Tolma4 Team who were interested in localizing My Little Investigations to Russian, and I’m pleased to announce that that effort has come to fruition – MLI v1.1 has now been released, which supports localization, and which also includes the Russian localization that created the need for these changes. You can grab the new version here! (As above, you’ll need to download the installer; the updater will fail to apply the changes.)

This means that the game is also open for anyone else who might want to localize it into their native language! If you’d like to help out with that process, I’ve put together a how-to here, which I’d encourage anyone interested to check out. If you have any questions, feel free to email me at the address at that page – I’m happy to offer whatever assistance I can!

Thanks to AlexFCS, Alex_Shy, kaze_no_saga, KornyPony, ltybcs, Mad Mix, makc_ar, nogard, Own3df1x, pashok6798, pifon, Skuzl, and Tails Doll for making this possible! It’s super awesome to see our labor of love become accessible to even more bronies than before!

Lastly, this version does also include with it a few other improvements that I put in place since it already required a new installer:

– The updater has been improved to update using a script instead of updating in the executable, which has the benefit of now being able to update everything, including the updater itself and SDL. (This may mean that there may be new bugs to be sorted out, of course – please let me know if you find any!)

– The OS X version now houses everything it needs inside the .app file itself, instead of installing content to /Library/Application Support/, and the DMG file is now just a simple drag-and-drop install instead of a .pkg file installer. (Thanks go to MaddTheSane here for helping me better understand best practices in OS X – I was coming from a Windows background, and my initial implementation of the OS X installation experience put that fact on display.)

(Oh, and yes, we’re still working on case 2, so don’t worry! This is just another thing that we’ve been working on in parallel. We’ll have another interview post with a case 2 character fairly soon.)

Equestrian Dreamers: The Classified Files Part 5


At long last, it’s time to honor another one of the team’s alumni. This is Rautakoura’s final message to the fans of MLI, so I hope you are ready to hear some more insight from the team! I have nothing but praise for his incredible work in the cutscene art, setting the bar high for his successor. As he ventures off to more time in college, I and the rest of the team wish him the best of luck in his endeavors.

The floor is yours, Rautakoura.

Continue reading

Care for a cup of Java?


First, a brief reminder that the deadline for applying for a position in My Little Investigations is December 31 at 11:59 PM PST. We’ll be making final decisions on positions after that time, so if you’re at all interested in applying (and we heartily do encourage you to do so), please make sure you’ve emailed your application by that time.

That aside, you might be wondering what we’re doing while we’re waiting for applications to come in! Well, I can assure you that one of the things we’re not doing is sitting on our thumbs. We’re hard at work getting everything ready for when the recruits come on board, and I’m finally ready to announce one of those items: My Little Investigations is being ported to Java! (Java using the 2D game library Slick, to be exact.) It had previously been written in C# using XNA, but after talking to a very helpful lady named dawnmew (who has since joined the team), I became convinced that this was definitely a good direction for the game and that it was something that should occur sooner rather than later, so it’s something that we’ve been working on during the month of December.

What does this mean for you? Well, if you’re on a Windows machine, it means that the status quo has been maintained – you were able to play the game before, and you’ll still be able to play it now as well. If you’re on a Mac or Linux machine, then you’re in luck, as this means that you’ll be able to play My Little Investigations after all! I had previously said that this wouldn’t be possible since the game was coded in XNA, but this port will change that, and thanks in large part to the help I’ve received from dawnmew to that end, it’s coming along very nicely. We’re just about back up at this point to the level of functionality that we had when the game was coded in XNA.

Exciting stuff, a day late for Christmas, but still in time for the holiday season. 😉 Thanks to everypony for their support thus far!

And then there were two

So, a bit of an update for the folks following this project.  In a previous post, I mentioned that there were three gameplay elements still to be implemented that were unique to My Little Investigations.  The second of those three has been in progress, but we now see why I wanted to managed expectations: after wrangling both with the logistics and with the core motivation for this gameplay feature, and after having discussed the matter with ZeusAssassin, I’ve decided that the best course of action is just to can it.  The reason for this is just that it was difficult to see how it could be structured in an organized yet efficient manner, and that I fundamentally felt that it wasn’t going to materially improve the gameplay experience for the player.

I’m a bit disappointed, since at its initial inception this feature seemed like an improvement, but the more I implemented it, the more I got the sense for why Ace Attorney never bothered with it.  Don’t worry, though – I can assure you that the project definitely is better off and more streamlined without it, and that the remaining element still to be implemented is most certainly rock-solid in my mind and will definitely make the final cut.  So we’ll still have both that and the partner system to give this game its own personal flair.

More details after the break for those interested.

Continue reading

Behind the Scenes – Structure and Cutscenes

Huh boy.  Location implementation is taking much longer than I was expecting it to – every time I implement something I realize I need to implement something else too before I’ll be satisfied enough to record another demo video.  Already I’ve got locations themselves implemented along with transitions between them, initiation of conversations with characters in locations, cutscenes, and environment examination, but I’ve still got more to do.  On the plus side, this is going to be a pretty huge update when it finally goes live.  Hopefully you folks can wait a little while longer.

While we wait, though, since the last blog entry was pretty well-received, I thought I’d write another one, this time dealing with game structure and cutscenes.  …But first, more screenshots!  Just for fun.

Much more after the break!

Continue reading

Behind the Scenes – Storage/Loading

There are quite a few things in the underlying infrastructure of video games that are caught in a bit of an unfortunate predicament: the only time someone actually even notices them is when they were designed poorly. The field of content storage and loading in video games is definitely one of those areas. So, while you wait for me to finish implementing locations in the game (it’s coming along, I promise), I thought I’d talk a little bit about it for your interest’s sake.

Discussion after the break, for those who are interested.

Continue reading

All hard-coded values removed

Dear Princess Celestia,

Today I learned an important lesson on the value of good coding design.  If you’re writing a piece of software that you intend to be modular, it’s always a good idea to plan out the design to actually function this way before you start writing any code.  Otherwise, a sudden realization of a fundamental design flaw might require you to rewrite the whole content storage system in your application.  And that wouldn’t be so good.

Your faithful student,


OK, so I know that I said in my last blog entry that the next thing I’d be working on was character encounters, but as you probably gleaned from the above, I suddenly realized shortly after writing that that there was a fundamental design flaw in the way in which content was stored in my application that made it impossible to load content (images, audio, etc.) from an external source.  This was a Very Bad Thing, because that obviously meant that the entire idea I had behind cases being modular and separate from the executable was not going to work.  So unfortunately I had to spent the last two days effectively tearing down and rewriting the content storage system in the game to properly accommodate the loading of external content.

However, I’m pleased to report that that speed bump is now behind us, and the game is now looking better than ever.  I’ve now broken off the case source compiler from the executable itself, and have gotten it to successfully compile all the case data plus all required images into a single binary file that can then be loaded into the executable.  In other words, I’ve already got a very, very rudimentary version of a case editor up and running.  <fluttershy>yay!</fluttershy>

As such, now I can finally begin work on character encounters.  Sorry to anyone who was expecting that work sooner.  I promise that when that’s done, I’ll finally actually have some more gameplay footage for you to look at, rather than just this technical mumbo jumbo. 🙂

More details for those interested after the break.

Continue reading

Interrogation parser is done

I unfortunately don’t have much to actually show for this bit of work that I just completed, but it’s important all the same.  Essentially, as I alluded to in my last post, I’ve been building a rudimentary parser for a conversation declaration language that I’ve put together, which allows me to quickly define conversations in an intuitive and sequential fashion.  That parser is now complete – I’ve successfully gotten a text file to compile into a conversation object that can then be loaded into the game engine and interacted with.  As work progresses and I implement other aspects of the game engine, this parser will need to be upgraded to also compile text files into objects for those parts as well, but this is a good start.

If you’re currently wondering why you would care about this – isn’t this just an internal implementation detail? – enabling the ability to define the case data in this fashion separates the game data from the game engine, which carries with it a number of tangible benefits:

  1. It enables cases to be defined in a modular fashion – in other words, cases aren’t built directly into the executable file. This makes it so that players will be able to install the executable file once, and then just download and open separate case files to play future cases, instead of requiring an update to the executable file itself.
  2. It enables the creation of a case editor separate from the game itself, which can be used to create, edit, and save these case source files, which can then be compiled and loaded into the game itself.
  3. It enables cases to be defined in a platform-agnostic fashion – the game I’m implementing is built in XNA, meaning that it won’t run within the context of an operating system other than Windows, but because the cases are defined in this fashion, porting the game to another operating system would only require the re-implementation of the game engine and the case source parser, not a re-implementation of the actual cases themselves.

For those who are really interested, the definition of the conversation seen in the video in the last post, along with an explanation of the different actions defined within it, appear after the break.

Continue reading