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 email@example.com 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!
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.
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!
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.
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.
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:
- 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.
- 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.
- 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.