Project Description

Deliverone

TEAM
Deliverone FutureGames Game Project 1
Category

Team Projects

Year

2020

Context

FutureGames Game Project 1

Tools

Unity, C#

My Responsibilities

Pickup System, Weapon System, High Score System

Team Members

Artists
Samantha Baqvel
Lena Fredén
Roberto Marcos Söderström

Programmers
Oliver Lebert
Henrik Nilsson
Jupiter Thulin

Designers
Robert Arnborg
Damian Becedas
Sean Falk

Music
Robert Arnborg

Project Breakdown

Introduction

Deliverone is a third-person, delivery, dogfighting game where the player needs to deliver packages quickly and safely to various customers. While transporting goods between skyscrapers in the futuristic city of Botham. The player must protect their cargo from incoming enemy fire while still living up to the customer’s extremely high delivery time expectations. (Because who in the future can afford to wait for more than a couple of minutes to receive their online orders?).

The player will have to switch between two widely different movement systems to complete the task at hand: A swift, jet-style movement to traverse the city quickly and engage in dangerous dog fights with rivaling drones, or a hovering, helicopter-like movement style to be able to carefully pick up and drop off packages. Essentially, mimicking the functionality of a VTOL-aircraft.

The player scores more points by delivering the packages in good condition and as quickly as possible. Additionally, the player can rack up bonus multipliers if they take down enemy drones in the process. If the package takes enough damage or is not delivered on time, then the player receives a “strike”. Three strikes and the game is over.

I worked on this project together with 8 other very talented teammates as our first game project at FutureGames over a period of two weeks. I learned a lot during the project, but above all, I had the honor of experiencing a project where the teamwork worked really well. Because I felt that most team members cared about the end product and were motivated throughout the project.

The pickup System

The system I spent the most time on in the project is the pickup system. Specifically, making the logic behind the process of the drone picking up deliveries from platforms, flying with it, and then delivering it to another platform. Let’s begin by looking at the class diagram:

Deliverone Pickupsystem flowchart

All blocks in the diagram represent a single MonoBehaviour script written in C# for Unity. The three main scripts that make the pickup system tick, are colored in green (or blue for singletons), while its immediate dependencies are colored light gray.

The PickupManager is the core of the pickup system, it ties everything together. It has a list of all the DropPoint’s the drone can pick up deliveries from and another list of the DropPoint’s the drone can deliver to. The lists are populated by each DropPoint like this (PickupManager.deliveryPoints and PickupManager.pickupPoints are the lists):

// In PickupManager.cs
[Header("Debug")]
public List pickupPoints = new List();
public List deliveryPoints = new List();

public static PickupManager Instance { get; private set; }

// In DropPoint.cs
public bool isPickupPoint;
public bool isDeliveryPoint;

private PickupManager _pickupManager;

void OnValidate()
{
    if (_pickupManager == null)
    {
        _pickupManager = PickupManager.Instance;
    }
    if (!isDeliveryPoint && _pickupManager.deliveryPoints.Contains(this))
    {
        _pickupManager.deliveryPoints.Remove(this);
    }
    if (!isPickupPoint && _pickupManager.pickupPoints.Contains(this))
    {
        _pickupManager.pickupPoints.Remove(this);
    }
    if (isDeliveryPoint && !_pickupManager.deliveryPoints.Contains(this))
    {
        _pickupManager.deliveryPoints.Add(this);
    }
    if (isPickupPoint && !_pickupManager.pickupPoints.Contains(this))
    {
        _pickupManager.pickupPoints.Add(this);
    }
}

So every time you turn on an isPickupPoint/isDeliveryPoint bool on a DropPoint, it will add itself to the corresponding list in the PickupManager. It works surprisingly well (even though OnValidate might sometimes be unreliable) and proved to be a much cleaner way to edit the settings than to manually assign the lists.

The Pickup script is placed on the actual pickup object and is in charge of attaching itself like a magnet to a transform parented to the player when the player is close to the pickup. It also controls the player’s health, when the player drops it too hard the health will run out and the player will lose a life. When the pickup is dropped it will also interface with the Sfx script to play an impact sound. This is only when the pickup is not being held though. When the pickup is held, the player script is in charge of handling collision damage, fire from enemies, etc. The player can only take damage when it is holding a pickup however, design-wise this makes the pickup’s condition be the purpose of the health bar. If the pickup gets too damaged the customer won’t want to receive it.

Now that you understand what each script handles, let’s go through what happens during one job. At the start of the job, the PickupManager chooses a random pickup point and a random delivery point. Then the pickup spawns (object’s position is set and the GameObject is enabled) at the pickup point. A beacon at the pickup location is activated and a timer is set and started with a random amount of seconds based on a customizable range. When picking the pickup up for the first time during that job, the music will change, the health will be set and the beacon will now instead lead you to the delivery point. If you drop the pickup too hard, get shot (when carrying it), or collide with objects (also when carrying it) you will lose health and eventually die. You will also instantly fail if you drop the pickup off the map or if the timer runs out.

When dropping the pickup off at the delivery point the score is based on the remaining health, the number of seconds left in the timer, and how close to the middle of the delivery point the pickup was dropped at. Those points are added to a variable in the GameManager that tracks the current points.