Press Release: Announcing the Completion of Level Upstate Accelerator Program

Download: docx | pdf

Omiya Games announces today it has completed the Level Upstate Program at Rensselaer Polytechnic Institute on August 2nd, 2019. The Level Upstate Final Pitch Showcase has provide insight and opportunities from a collective of local independent game studios for business investors and entrepreneurs alike.

The Upstate New York indie game studio operated by a single developer, Omiya Games, will announce their completion of a seven-week accelerator program on August 2nd, 2019.  All teams from the Level Upstate accelerator presented their project and pitch at the Troy Innovation Garage for business investors, professionals, and entrepreneurs on August 1st, 2019.  The networking opportunity provided the audience an insight on the growing indie game movement in the Troy, NY region, as well as make business connections with the budding studios. During this showcase, Omiya Games revealed their latest project: a fast-paced, competitive arcade game titled, Air Flip Drive.

For the competitive speed demon in you, Air Flip Drive provides a fast-paced, score-based arcade game for everyone, 10 and up.  Imagine a world where speed is the name of the game, and gravity is just a suggestion.  In this reckless universe, players compete by driving as far as possible on a high-velocity, anti-gravity vehicle.  But there’s a catch: the vehicle has limited fuel, and it’s always draining! Players must steal fuel from other rivals by attacking them.  Race through an ever-changing, infinitely long track; dodge obstacles, soar through the skies, collect power-ups and destroy other vehicles.  How far can YOU go before running out of fuel?

I want the player to experience the thrill of going fast, and discover something new every time they play.

Taro Omiya, Solo Indie Game Developer

Get ready to hit the pedal when Air Flip Drive releases on PC and mobile on 2020.  For a sneak preview, click on the link to download and play the demo: airflipdrive.com

Link to Omiya Game’s press kit: omiyagames.com/presskit

New Web Design!

After sticking with an old and aging web layout for quite a long time (as well as being completely silent online), we’ve finally did a quick renewal of the web layout. For reference, here’s the old site:

So 2016!

And here’s the latest redesign:

Now with more moving pictures!

Why the redesign (outside of the fact that it looks much nicer)? The old site attempted to give more focus to the latest development news of long-term game projects we were working on. Now that we have quite a large library of games out there (almost 30!), we wanted to give a stronger focus to the games themselves.

With the stronger focus on games comes a more up-to-date site…literally. As seen between the two screenshots alone, three more games has been added already. The new interface now utilizes a new framework that updates the homepage dynamically as new games are added into the site. In addition, if the game is available to play online, it will now open a new page with the game embedded in the site. That’s right, you can now play many of our games directly from our site!

Hopefully all of these changes are positive. We’re still tweaking a few things here and there, so let us know if there are anything we need to fix. Happy gaming, everyone!

The incredible art of over-engineering: Everybody Plays Golf Post-Mortem

Over-engineering: a plan where one adds unnecessary complexity in implementing a simple feature for a technical project. In the same way it’s dangerous to plan a game with too many features in a game jam, over-engineering sinks a lot of projects, personal or otherwise. While we’ve set out to make a satirical game about energy systems, thus providing us an excuse to make a terrible game, we admit that over-engineering has made our latest Ludum Dare game worse than we originally planned. Here’s our post-mortem of Everybody Plays Golf, an overly complex game with an ironically simple premise.

What is Everybody Plays Golf?

Everybody Plays Golf is a tongue-in-cheek riff on the Twitch Plays genre. In this online game, anyone with an internet connection fights over the control of a single golf ball, as they attempt to putt it into the hole at the upper-right hand corner of the stage. The catch is that there is an energy system, à la Farmville and other free-to-play social games, that prevents the player from putting more than 7 times. While the game claims one can recover energy over time, this is actually a bit of a white lie: every player’s energy does not recover until the golf ball falls into the hole. Once it does, everyone recovers all 7 units of energy, and the ball resets its position back to the bottom-left corner of the map.

It’s simultaneously an experimental game about cooperation, a satire on social games, and a technical nightmare for the sole programmer who put all the pieces together.

What went right

Using game jams as an opportunity to learn something new

We’ve always used game jams to learn something new, such as Blender modifiers, Unity path-finding, story-writingprocedural generation, and so forth. This time was no different: we decided to take what we learned on hack.source.net to make a networked game where everyone controls the same object. In this case, we’ve taken the time to learn all the moving parts necessary to create an asynchronous networked system: making a server that simulates the physics of the golf ball, using a free trial of Google Cloud to host said server, creating a client that calculates the direction the user wants to putt the golf ball, setting up a MySQL database to store all the players’ putting directions, and code a few PHP scripts to get access to MySQL databases. It’s a strange framework that gets the job done and forces us to learn and re-learn some critical professional skills, such as SQL, Get and Post requests, networking, etc.

A goofy tutorial

We also took a stab at looking into TextMesh Pro assets from the Unity asset store. While playing around with it, it came to us this asset can be used to create a 90s advert like tutorial. Thus, our cheesy tutorial was born: a ridiculously positive and verbose set of instructions on how to play the game…even though the game is simple enough for one to figure out how to play with enough experimentation. Putting this tutorial in was a bit of a risk at the time because the server wasn’t working. We’re glad we put the time in to improve the presentation of the game.

Making incremental builds

As usual, we started with building the basic models and scripts to create a prototype where one controls a golf ball with a mouse click. By starting very small, it was easy for us to detect problems early before building new features on top of this game. This vital process kept all the moving parts manageable by keeping the project simple and stable.

Not letting non-working parts prevent us from progressing

For the longest time, the server part of the game was not working: despite having it uploaded and running on a static IP address to a Google Cloud virtual machine, the server would not start listening to a port. While this did delay the development by a significant factor, it didn’t keep us from improving other parts of the game that needed attention, including graphics and information sent and stored into the database. Even though the game was unplayable for the grand majority of the development (at least in the way that was intended), we’ve still managed to find workarounds or working on portions of the game we’re more well-informed of while we’re trying to figure out what went wrong.

What needs improvement

Overly complex design

The full details of how Everybody Plays Golf works goes as follows:

  1. The client: the PC/Mac/Linux build that the user downloads. It does the following:
    1. Connect to the server. Once connected…
    2. Sync the position of the golf ball in real-time,
    3. Syncs and stores how many times the server has recorded the golf ball fell into the hole. This is used to check if the player’s energy needs to be refilled when they open the application again.
    4. Locally how much energy the player has. A unit of energy is depleted each time the player clicks.
    5. Send a Post request to a PHP script, sending information about the name of the player, and the direction they’ve putted.
  2. The server: a Unity headless Linux build running in a Google Cloud server. It does the following:
    1. Spawn the golf ball, and monitor its movement and physics.
    2. Send a Get request every 0.2 seconds to a PHP script, receiving information on the last set of putts it hasn’t read yet.
    3. Uses all the putt directions it receives, and applies them to the golf ball. That’s right: only the server moves the golf ball directly!
    4. Sends a Post request once the golf ball has been putted to indicate which directions should be marked as read.
  3. The database: a MySQL database and a set of PHP scripts hosted off of our own website. It does the following:
    1. Store a list of directions, names, and a flag on whether the entry has been read or not.
    2. Provide 3 PHP scripts:
      1. One for recording directions into the database, and automatically flagging them as unread.
      2. One for retrieving all the directions that are flagged as unread from the database.
      3. And one for marking specific directions to mark as read (each direction has a unique ID).

To be clear, each of these parts were either a separate build of the game, or using a completely different scripting language. That meant that often, there were many portions of the code that only applied to one part of the game. Making sure each of these parts were working in harmony took the most amount of time and energy.

Naturally, there are way too many parts for a game jam game, and one that in hindsight, could have been simplified even further had we known how Unity’s UNET networking framework worked better.

RemoteSettings not working

The dreaded, “it works on my computer” occurred when we tried to make a server build of our game, and hosted it up to the Google Cloud server. The client would not connect to the server, even through it worked fine in our local setup. After a ton of online research, we soon realized the server simply wasn’t listening to the port it was programmed to. For the longest time, we could not figure out why; we’ve instead moved on to other parts of the game while mulling over it. It was only when we were nearing the submission deadline did we realize through logs that Unity’s RemoteSettings, which we were checking its status before retrieving a port number, was not working. Baffled, we’ve removed the status check before grabbing the port-number (i.e. the equivalent of hardcoding the port number), and the server finally worked.  After that, we only had minor bugs to fix on the client before submission. Still, it was very stressful during the time we had no idea what was broken with the server.

Poor feedback

The game provides no feedback on how many people are playing, making it incredibly confusing to figure out why the golf ball may be moving on its own. Additionally, since the server receives from the database every 0.2 seconds and is the only part responsible for moving the golf ball, there is almost always delay between clicking the mouse and observing the golf ball moving. And for additional pain, the client could fail to send to the database the direction the player putted for any technical reason, yet they’ll still lose energy for it. All of this leads to poor feedback to the player, providing some confusing information as to why the ball might be moving on its own, or conversely, why it’s not moving when the player clicked.

Legacy UI

There was a pause screen we left in the game, in case we added any audio to the game, so that one can use it to access the options screen as well as the credits. Unfortunately, we didn’t have time to fix the text labels on that screen, or had the time to test whether options or credits worked. With such broken features left in the game, it might have been better to remove it entirely.

No audio

If it wasn’t obvious, we ran out of time adding audio. Sigh.

What to do next

From the beginning, we knew we were taking major risks working on this game within the Ludum Dare deadline. That said, we probably could have taken a refresher, or made a simple library of codes that would help us accelerate the development than the approach we took for this jam. We should also strive to make a simpler model, removing the database portion entirely. Finally, never use RemoteSettings until we know how it works.

Combining the unusual with the familiar: The Recursive Dollhouse Post-Mortem

“I have a present for you,” announced the father as he walks into his family home with a big wrapped package. Excited, his daughter hastily unwraps the box. Her face opens into a big smile: it’s a dollhouse. “Take a look inside,” encourages the father. The small girl lifts the roof of the dollhouse to reveal its content. From the single doll sitting next to the tea table, to the miniature tea-set set on top of it, the detailed content made the girl ecstatic. “Wow, it’s beautiful,” she exclaims.

Suddenly, their house rumbles. Startled, both the father and the daughter looks up to the ceiling. Or the sudden disappearance of it. Instead, as the sunlight seeps into their living room, a girl taller than skyscrapers looks down with a big grin. Holding their house’s now-detached rooftop while looking down on the family, she booms, “Wow, this is beautiful!”

The commercial-length episode described above from the Japanese TV show, Tales of the Unusual (which is basically the Twilight Zone) became the main inspiration for our Ludum Dare 37 entry, The Recursive Dollhouse. Like most game jams, the development process of this game was a stressful experience perfecting the core mechanic of the game: traveling into and out of smaller dollhouses. Despite having a relatively unexplored central mechanic, though, it’s quite surprising to realize how much of the game is derived from previous conventions.

What is The Recursive Dollhouse?

The Recursive Dollhouse is a first-person puzzle game that involves jumping into and out of dollhouses, shrinking or expanding the player to fit into the dollhouse comfortably. The game utilizes various different methods to provide unusual puzzles, such as ones that involves changing the sizes of objects, or using the recursive nature of the dollhouses to repeat rooms without backtracking.

What went right

Getting the “jump”right

Initially when we pitched the game, all we had as a game design document was these scribbled notes on our list of many game ideas based in one-room:

Dollhouse -> reflective of actual room -> recursive

To translate this in proper English, we had a game idea about a house you can enter that’s already in another house, which in turn is in another house. Needless to say, we really haven’t thought through this idea at all, which made us fairly cautious of whether it’ll work or not. Still, we took a couple hours to make this idea and see what it feels like:

At the point we made this GIF, it was clear to us this was all we needed to continue with this idea to a full game. It felt pretty magical at the time, and opened to a lot of detail-hunting gameplay opportunities.

Building the puzzle components first

We tend to follow the Nintendo mentality of designing games around mechanics. Once we had the prototype ready, a lot of important questions emerged, such as: why would one want to dive into a house? Once they dived into a house, do they want to return back to the house they were in before? If so, why? And what makes diving into a house unique, that can’t be done with mere doors and switches like in Zelda games?

The solutions we came up with were, while not extensive at addressing all these questions, attempts to solve some of them. For having a reason in diving into a house, we resolved it with the classic key-door mechanic; it gates your progress, thus incentivizing your exploration. Since at least one path is going to be blocked by the locked door meant that the game would need split paths and recursive loops for creating complexity.

The emphasis on exploration inevitably answers the question of whether we want to return to our previous residence: yes! While a few different ideas were offered to to us by other jammers on returning the player, the method we chose was a spring to reverse the diving action. This decision was made largely out of practicality: it was the easiest action to implement, since it didn’t require creating a new model and animations.

Finally, what makes this mechanic unique from normal dungeons? After all, the act of diving into a house is a lot like entering a puzzle room from the middle. To differentiate this game, we went to our favorite surrealist artist for reference:

The Listening Room, by Rene Magritte

“The Listening Room,” by René Magritte was what inspired us to design puzzles that involves dropping a variety of items into smaller dollhouses (though only keys made it in due to lack of time). From there, we had a new question: why would one want to drop anything in the house? We resolved this by adding a code on the items that are initially too small to read. By using this mechanic to make the item larger, they can make the code legible, and thus, progress in the game. Clearly, this meant we needed to create coded doors, and that’s what we did.

Thanks to the initial prototype, it helped us summarize our thoughts on which puzzles were needed in the game to make it stand out, and which weren’t. We didn’t add any block puzzles, for example, since those puzzles are often self-contained in a single room, and do not provide a good reason to hop between different rooms. With these tools available, we were able to start constructing levels that helped emphasize the core mechanic of the game.

Easy level design interface

Incidentally, a lot of features listed above required re-writing the first prototype on how the player shrinking and growing was achieved. Originally, we had just 3 dollhouses–each smaller than the other–embedded into each other. When the player jumped within the trigger area of each dollhouse, all the houses will grow in size. This rather round-about method of creating an illusion that the player was growing or shrinking was due to keeping the physics consistent, as larger objects fall slower in the Unity game engine, and faster for smaller objects.

While growing and shrinking the visible houses remains the same, the new version of the game required dynamically embedding and removing the dollhouse from the grow/shrink list so that recursion and split paths can be achieved. This was quite a significant effort to keep the illusion of houses being embedded into one another intact. A subtle fog was added to create a logical reason as to why larger houses disappears from view as they’re being removed from the list and being cleaned up. Springs had to now retain a history of dollhouses you’ve traveled in, so it knows which house to return the player to. And each table that held a dollhouse now merely holds a reference to it. When they’re needed, the table dynamically resize and position the dollhouse on top of itself.

This costed a lot of time, but it had a huge plus side beyond making many of the mechanics listed in the previous section above possible: the new change made it a lot easier to design levels. The original prototype required shrinking the embedded houses smaller and smaller, which which already tested Unity’s ability to be able to render the dollhouse and their content. Since the tables now dynamically resize the houses to the proper size, every dollhouse can be designed with exactly the same size. No need to tediously resize each gameplay element to the proper size!

This also helped create a visually more understandable level design diagram in Unity itself. As seen in the screenshot below, dollhouse-holding tables are connected to their respective house with a magenta-colored line. With this visual, it helped us create a graph-like diagram that indicated how each house is connected with each other. As a consequence, it made it easy to verify that our development matched our own level design sketches.

Always testing your own puzzle designs

Fun fact: while designing the last few stages, one thing that became clear was that a sketched puzzle had a hole in it, causing the player to go through a loop of houses infinitely. Our regular habit of testing what’s been implemented as early as possible helped us discover these kind of problems sooner, allowing us to quickly correct mistakes. In this case, we created a shortcut to the proper solution so that the player would not be stuck in an infinite loop. While this unfortunately made the last part filled with switches that served no purpose, we were still able to provide a solvable experience.

Practicing Blender

In every game jam game, we try to learn a new technique. This is largely so that we end the game jam with at least something new in our hands, preferably a good game, but at minimum with a new skill. This Ludum Dare helped us improve our Blender skill by utilizing the boolean modifier. While we probably abused this feature when simpler methods existed for combining or subtracting meshes, it helped us create a lot of low-poly models quickly enough for our beginner skills to create the elements in the game.

What needs improvement

Too many codes!

In The Recursive Dollhouse, nearly everything has a code associated with it. From the key doors that has a code matching keys to the corresponding door, to the switches that has a code matching the doors it opens or closes. While these identifications adds complexity for keys-only or switches-only puzzles, they become a huge source of confusion when code doors are involved. Are the codes written on the key doors the answer to the code doors? This ambiguity forced us to make passcodes appear nearby the door they correspond to.

In fact, code doors themselves probably needs to be revisited. They’re currently implemented quite poorly: in a game that locks and hides the cursor, the only way we could get the Unity GUI system to allow button pushing was to unlock and expose the cursor. This means the player’s position is locked, and unable to move while entering the code, sometimes leaving the player in camera angles that doesn’t expose the entire keypad (this can be escaped with ESC pause menu, but it’s a work-around). Besides, codes requires significant memorization, creating a rather immersion-breaking experience.

Linear puzzle design

Despite having the name, “recursion” in the title, there’s only one part in the game where the dollhouses actually loop into each other. There are also very few places that the paths split in the game. This resulted in creating a rather linear experience with little room for experimentation. Every puzzle has only one solution, and backtracking is kept to a minimum. Part of the reason we didn’t add much complexity in our game had to do with the lack of time and how the current gameplay elements were implemented made it difficult to create these puzzles, but another part had to do with our lack of sleep. At one point while designing the puzzles, we were so confused with our own levels, we couldn’t solve it while testing. While it made sense at the time to implement more linear puzzles during the jam, in hindsight, it felt like we cheapened the experience.

Larger houses are under-utilized

Currently, after diving into an embedded dollhouse, the previous house is visible through the windows. The now-large dollhouse, however, serves no purpose outside of visuals. This did feel like an underutilized feature, but we never found a good use of it until recently. While creating a shortcut to the last few puzzles, it just hit us while looking out the window that we could have hid a super-small code in the larger dollhouse that would only be legible through the window of an embedded dollhouse.

At one point while brainstorming on different gameplay elements into the game, an idea we had was to be able to carry and place dollhouses themselves. We didn’t pursue this, however, due to the lack of puzzles that would justify such a mechanic, and the difficulty of resolving what should happen if the user clicked at a carry-able dollhouse with an item already in the house. The previous small-code hunting mechanic would have resolved the former problem, along with making it the primary method to carry levers. We just feel bad we weren’t able to come up with these ideas sooner.

No visual variety

Since we were only beginners with 3D modelling in general, we were not very quick a creating models, let alone UV-mapping and texturing them. Seeing that justifying the core mechanic was our strength, we decided on focusing that aspect. This unfortunately meant that the graphics suffered: while we had plans on creating dollhouses with different shapes and window sizes, we did not have the time to make any of them. The textures on the dollhouses and the springs are actually just us color-coding which segment of the texture corresponds to which part of the model. The dollhouse’s toy-like appearance is entirely coincidental. For a puzzle game that involves some back-tracking, a variety in graphics would have helped the player navigate the game by making it easier for them to memorize where each dollhouse is.

What to do next

A lot of the bad parts in our design can be easily attributed to our lack of sleep, and poor pacing. Taking that into account, it might have been a good idea for us to scale back a bit and implement what is only necessary. Next time when we design a puzzle game, we should probably avoid numbers and/or code-based puzzles. If we want to add level designs that requires memorization we should make it more universal by relying on easy-to-recognize shapes and colors. Finally, we should emphasize more on exploration by adding multiple paths and hopefully multiple solutions to each puzzle, to create the appearance of complexity in each level.

New Ludum Dare game: The Recursive Dollhouse

Like a swift ninja skittering across a frozen lake, Ludum Dare 37 have come and went swiftly…

Hello, everyone! Sorry for the silent treatment, but we have a new game out! Inspired by an episode of Tales of the Unusual (Japanese version of Twilight Zone), we went full-on surreal: The Recursive Dollhouse is a very strange game about a very strange dollhouse. Created by Taro Omiya, Petey Pezzulo, and Graham Lerch, this open-source first-person puzzle game involves going in deep. Very, very deep.

Full Description:

​A very strange game about a very strange dollhouse. A surreal first-person puzzle game created in 72-hours for Ludum Dare 37.

This game is funded through Patreon. Many thanks to the following:

* Adam R. Vierra
* Joshua Jennings
* XanderHD
* Tommy Pedersen
* Jacob Clark
* David Lin

Made in Tech Valley Game Space!

If you can, please rate the game, and let us know what you think!

Link to Itch.io: https://omiyagames.itch.io/artifacts-of-the-ancients

Link to GameJolt: http://gamejolt.com/games/the-recursive-dollhouse/217729

Link to Ludum Dare voting page: http://ludumdare.com/compo/ludum-dare-37/?action=preview&uid=20557

Some screenshots!