LayOff - Online Game

LayOff

Feb 26 - Aug 1, 2024

Multiplayer Game

Details

Team Name: Names Are Hard Studio
Role: Programmer & Project Manager
Trailer: https://youtube.com/watch?v=ei7RZGlcBMA
itch.io: https://vfs-gdpg.itch.io/lay-off
Repo: https://github.com/AlexBuzmion/LayOff

Objective

Deliver an engaging online multiplayer game, 'LayOff', with a 10-minute gameplay experience for group settings. The game supports seamless multiplayer functionality, promoting strategic and competitive play within a limited timeframe, meeting the final project requirements for a comprehensive understanding of game development.

Tools & Technologies

C#, Unity, JavaScript, Vue.js, Photon, Unity Cloud Services, Figma

Project Summary

'Lay-Off' is a fast paced online 4-player trap placement deathmatch spy showdown! As an underfunded agency's spy, outmaneuver rivals in a race for keycards and survival. Look for keycards inside furniture and fixtures, and earn your job security within the given time. Tick-tock goes the clock - enter retirement in this life or the after. Your mission: be the first spy to get out!

My Contributions:

Project Management

As the project manager, I set up and managed Atlassian tools like Jira and Confluence, drawing on my prior experience. These tools were crucial for tracking project progress, managing tasks, and maintaining documentation, keeping the team organized and on schedule.

Gameplay and Network Programming

1. Keycard System

Collecting keycards is essential for game progression. I created the Keycard Manager script, which dynamically manages the spawning and collection of keycards, ensuring all players have equal opportunities. This system adds strategic depth and competition to the game.

2. Interactable Objects

I developed the logic for Interactable Objects, which serve dual purposes in 'LayOff'. These objects can offer keycards or function as traps, enriching gameplay by adding layers of strategy. Players must decide whether to retrieve a keycard or set a trap, making interactions more meaningful.

3. FInal Door Behavior

The final doors in 'LayOff' serves as the player's gateway to victory, only opening when all required keycards are collected. I implemented this mechanism, ensuring it responds correctly to players' keycard collections, adding a significant challenge and providing a rewarding experience.

At this stage, the core premise of 'LayOff' is established: players must collect the required keycards and make their way to the exit, where they press the red button to escape. However, collecting keycards is only part of the challenge. To add strategic depth and excitement, players can set traps to incapacitate their opponents. These traps can deal significant damage, allowing players to potentially acquire keycards from other players. This additional layer of gameplay not only heightens the competition but also ensures that every move counts in the race to escape.

4. Trap Triggers and Trap Effects Network Management

I was responsible for ensuring the network synchronization of traps in across clients. While my co-developers focused on local trap logic, I managed the networked aspects, handling the instantiation and destruction of trap triggers and effects. This ensured consistent trap behavior across all clients and seamless multiplayer gameplay.

🤔 The Challenge: Ensure that traps were instantiated and destroyed consistently across the network. This required: 1. Network Synchronization, 2. Master Client(Server) Authority, 3. Seamless Player Interaction.
💡 To address these challenges, we leveraged Photon PUN's networking capabilities. The TrapTrigger and TrapEffect base classes were designed to handle network synchronization, ensuring that traps were instantiated and destroyed correctly. Here are the relevant snippets focusing on the instantiation and destruction of trap triggers and trap effects.

// TrapTrigger base class
public abstract class TrapTrigger : MonoBehaviourPunCallbacks, IPunOwnershipCallbacks, IPunObservable
{
    [SerializeField] protected GameObject trapPreEffectPrefab; // prefab to spawn before the trap effect
    [SerializeField] protected GameObject trapEffectPrefab; // prefab for the trap effect
...

🪤 TrapTrigger Base Class:
HandleTrapTrigger: This coroutine manages the entire process of triggering a trap, ensuring that only the master client handles the instantiation and destruction of effects.
SpawnPreTrapEffect: This method instantiates the pre-effect of the trap and ensures it is properly destroyed after its lifetime. The OnPreEffectSpawned method is an empty method meant to be overridden by child classes to implement additional effects.
SpawnTrapEffect: This method instantiates the main trap effect, sets the necessary references, and ensures synchronization across clients.
RequestDestroy: This method ensures that only the master client can destroy the trap, maintaining control over networked objects.

// TrapEffect base class
public abstract class TrapEffect : MonoBehaviourPunCallbacks, IPunObservable
{
    [SerializeField] protected float trapEffectLifeTime = 10f; // lifetime of the trap effect, adjust in inspector
    [SerializeField] public int ownerID; // owner of the trap
...

💥TrapEffect Base Class:
OnCollisionEnter: This method handles collisions with players, triggering the trap's effect, sending updates, and starting the destruction coroutine.
DestroyTrapEffect: This coroutine ensures the trap effect is destroyed after its lifetime.
SetTriggerPhotonViewID: This method sets the owner ID for the trap effect based on the trigger's PhotonView.
OnPhotonSerializeView: This method handles the synchronization of the owner ID across the network.
Destruction is handled by the trap trigger as the effect is set to be a child of the Trigger upon instatiation

Key Learnings:

The project management methodologies I acquired in previous roles are highly transferable to game development. The principles of Agile and effective team communication are just as crucial in game development as in other industries, ensuring project success and team cohesion.
Coordinating efforts among a diverse team of developers taught me the importance of clear communication, role definition, and conflict resolution. It also underscored the necessity of understanding individual strengths and fostering an environment where everyone can contribute effectively.
The significance of centralizing control with the master client / server ownership for critical actions like instantiating and destroying objects. This approach prevents conflicts and ensures consistent game behavior across the network.
Implementing networking for game elements like keycard spawners and traps highlighted the importance of synchronization across all clients.
Working on keycard collection and trap mechanisms enhanced my understanding of complex game mechanics.
Developing interactive objects, such as keycard spawners and final doors, reinforced the need for clear feedback mechanisms.
Implementing trap logic that integrates both local and networked aspects demonstrated the complexity of game interactions.

Learn more about me 👇🏼