Six Steps Ahead

It's a multiplayer 1v1 game in which each player's movements and actions are done first through a ghost form. When both players' turns are up, all the actions that happened during ghost form play out.

Comment

Inspiration

  • Our game aimed to take a twist on the stereotype that delay (think lag, ping, latency) is a common source of frustration to many users.
  • We originally planned to center our game’s core mechanic on input delay, where we discussed ideas such as collaborative puzzle games (think to the success of many popular games such as Overcooked or Unrailed, where an ordinary collaborative situation is made to be stressful, but that only serves to make the game more fun) or bullet-hell shooters (some interesting mechanics with delay and predicting the trajectory of projectiles). We eventually settled on a fighting game to maintain a sort of strategic and competitive aspect to the game.
  • We spent much of the first 6 hours of the hackathon developing the core mechanics of our planned game, using queues to control the rate in which we dequeue inputs from the user to create the effect of input delay
  • However, we soon realized that there is a reason that such an idea isn’t explored more often; because playing with lag can be very frustrating
  • Still wanting to maintain the strategic aspect of pre-empting opponent’s moves, while wanting to drastically pivot away from the original core mechanic, we decided to take a twist on the typical turn-based games.
  • The idea was that we would have two users input a fixed number of moves (in our case, six inputs corresponding to movements along a tile grid, where attacks counted as inputs), and then these moves are simulated out. There is a sort of turn-based aspect while also having to be strategic in pre-empting the moves of the opponent, like our original idea with input delay
  • Some other inspirations include games such as Crazy Arcade, where the dropping “bomb” mechanic came from.

What it does

  • First, the player enters the lobby, allowing them to join in or create a room with a passcode.
  • Then, the player enters the map grid, where they can input their actions. However, the actions will only move the image, or “ghost” of the player’s character.
  • The player can only move or attack 6 times, which is where the name came from.
  • The player has to plan out and input their moves or attacks. When they end their turn, the queued actions are executed in sequence.
  • The player’s attacks consist of dropping fire tiles, which kill the opponent if they end up stepping on a fire tile.
  • Meanwhile, the opponent does the same actions but might unload their action queue at different times, making it harder for both sides to predict the movements of one another.
  • The side that makes the opponent step on a fire tile wins the game.

How we built it

  • We used Unity engine to assemble the game, and VS Code to write the scripts.
  • We first created the game project and added assets to it.
  • Then, we divided our tasks efficiently so that half of our team were working on setting up the multiplayer library, and the other half working on the core mechanics such as map and movement.
  • Then, we came together to merge our code together and debug the multiplayer mechanics by sharing our devices.
  • We used Github to ensure that everyone has the latest files before we do any changes.

Challenges we ran into

We had a lot of issues not only making all the game systems and mechanics work on their own for one player but also to sync across many different players playing the game at once in the same server. Furthermore, our project had a lot of interdependent objects (the ghosts were dependent on their parent, most gameplay mechanics depended on the synchronicity system, etc.) so maintaining it and trying to figure out which part in this interconnected web was the reason of some null pointer or index out of bounds error was quite the challenge.

Accomplishments that we're proud of

We made a multiplayer system that allows for different computers to play with each other using a free server in the cloud using Photon. Although the whole process was very challenging (and took most of our night trying to figure out how to get right), there was an extremely strong sense of pride and satisfaction as we gathered around a laptop and watch the mechanics unfold as we intended.

What we learned

We learned how to create menus in Unity, how to use data structures to store character data, and how to correctly sync multiple characters in the same game. This is also the first time we use the Photon Server’s Networking System to communicate with our multiplayer game in Unity.

What's next for Six Steps Ahead

To further develop the combat system with new weapons, attacks, and abilities. We also plan to add audio we have picked out already within our game files to the game so that everything has sound that you would expect it to have. We could also have levels with obstacles or different maps for more strategies like “choke points”, etc.

Built With

Share this project:

Updates