Hello, world! I’m Matt Graber. I just finished my undergrad at the University of Maryland. I started my game development career back in freshman year in the UMD AR club. I used to teach other students how to create augmented and virtual reality experiences with Unity, a cross-platform game engine. I also enjoy informal game jams and larger projects in Unity with fellow developer friends. Recently, I won the sponsored prize at the Bitcamp hackathon for building —an arcade game that notifies players of their status on the leaderboard. It was an exciting hackathon and also a learning experience for me. I learned how to use Courier and also how to use Unity with C# to create automatic POST requests to an API server—a teaser of what I will share later on. Package Person I got featured in to build a notification-based game with , , , and . In this article, I will walk through the design of this game, called , and provide a step-by-step explanation of how I used Courier to integrate notifications into the game. Courier’s live stream Unity Engine Courier Twilio Mailjet Rain Spikes Rain Spikes: The design of the game People are naturally competitive. Even though Rain Spikes is simple, it’s addicting because players get notified about their score via email and text messaging, which prompts them to try it again and again and again. Once the game starts, the player uses arrow keys to move a square from left to right to dodge the falling spikes. The more spikes they dodge, the more points they gain. If a spike hits your square, the game ends with a prompt to fill in your details—name, phone number, email, and memo (a message to include in the email). When you click submit, an automated email or an SMS message is sent showing your end score and the memo. Here’s how the game works: Let’s go into a little bit of the design architecture for this game. First, if you don’t know, everything in Unity is object-oriented and is based on game objects. For example, the player game object (the object the player controls) is the square. The player game object has two components attached to it: the , which renders 2D and 3D objects, and , which detects collisions (in this game, with the falling spikes). Sprite Renderer Box Collider 2D Finally, the last component I implemented as a script is the player control component, enabling the player to move the box with the left and right arrow keys independently of the frame rate. As I said earlier, I wanted to add notifications to give Rain Spikes a competitive, addicting edge. So here’s how I did it. How I Added Notifications Using Courier to Notify Players of Their Score Courier’s API allowed me to use the information collected in the end-game form to send notifications whenever the game ends. Of course, the emails and text messages are opt-in, of course — nobody wants to design an app that spams people with unwanted emails. I created a basic game with Unity Engine. While this article focuses on my Courier integration into the game, here is a recommended beginner-friendly tutorial to create a game with Unity Engine. Feel free to check out my code for this game
on . Step 1: GitHub I already had an account on Courier, so all I needed was to log in and click on create a notification. If you don’t have a Courier account, it’s a simple sign-up. Step 2: Courier has different channels to deploy notifications from the exact location. So all I had to do was choose the specific channels for this game: and . Step 3: Mailjet for emails Twilio for SMS messages Next, I had to write out the email message for Mailjet: Step 4: Hello {playerName},
You recently scored {score} while playing that Courier-Unity integration demo game!
You sent the following memo to yourself:
{memo}
You should play again sometime! playerName, score, and memo are assigned variables to fetch data from the game. So by assigning these variables, I sent values from the game to display as part of the message. For the memo and score variable, I made them conditionals — if the memo is not empty, the memo will be displayed. So these fields will only be displayed if the player actually submitted a memo or has a score. Adding conditionals on Courier is a lot easier than figuring out all the logic on the C# side. The next thing was to replicate the same message for Twilio. In Courier, it is easy to drag and drop the text because they are shared components. Thus, it saves the time of typing everything out again. Step 5: After adding the messages, I went over to preview, wrote a test event, and checked if the notifications were working. The test event contains the assigned variables—playerName, score, email, phone number—and test values. Step 6: "data": {
   "playerName":"Billy",
   "score":4,
   "memo":"hello billy here"
 },
 "profile": {
   "email":"dummyemail@gmail.com",
   "phone_number":"555555555"
 },
 "override": {}
} After previewing the notifications and testing everything was working, I published changes. Step 7: Now, this is the tricky part. Currently, Courier has SDKs for Ruby, Python, Go, Java, etc. Unfortunately, there is none for C#. These SDKs generate sample code for sending notifications to the programming languages. It was not much of an issue. All I had to do was create a web request from Unity following the curl logic on Courier. Step 8: Before starting the notification script code, I had to get references for each input field to fetch data to the script. In the Unity Engine inspector, the input field has a component called TextMeshPro (TMP). TMP is the in Unity Engine. Step 9: “ultimate text solution” Here’s what the notification script code looks like: using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.Networking;
    using UnityEngine.SceneManagement;
    using TMPro;

    public class Notifications : MonoBehaviour
    {

      public TMP_InputField nameInput;
      public TMP_InputField emailInput;
      public TMP_InputField phoneInput;
      public TMP_InputField memoInput;
      private GameManager gameManager;

      const string EVENT_ID = "";
      const string AUTH_KEY = "";

    // Start is called before the first frame update
    void Start()
    {
    gameManager = GetComponent<GameManager>();
    }

    public void Submit()
    {
    StartCoroutine(SendNotification());
    }

    private IEnumerator SendNotification()
    {
           WWWForm form = new WWWForm();
           form.AddField("event", EVENT_ID);
           form.AddField("recipient", nameInput.text);
           form.AddField("override", "{}");
           form.AddField("data", "{\"playerName\":\"" + nameInput.text + "\"," +
                                   "\"score\":" + gameManager.GetScore() + "," +
                                    "\"memo\":\"" + memoInput.text + "\"}");
           form.AddField("profile", "{\"email\":\"" + emailInput.text + "\"," +
                         "\"phone_number\":\"" + phoneInput.text + "\"}");
           using (UnityWebRequest www = UnityWebRequest.Post("https://api.courier.com/send", form))
           {
            www.SetRequestHeader("Authorization", "Bearer " + AUTH_KEY);
            yield return www.SendWebRequest();

            if (www.result != UnityWebRequest.Result.Success)
            {
            Debug.Log(www.error);
            }
           else
            {
                 Debug.Log("Form upload complete!");
                 // reload the scene to play again
                 SceneManager.LoadScene(0);
             }
          }
      }
    } Don’t get overwhelmed: Here’s a breakdown of the different methods and classes I used in this script. public class notifications handle the input fields for name, email, phone number, and memo. The GameManger input field is private because that is where the score will be stored. To create this method, I imported the TextMeshPro with a statement. Importing TMP gives the flexibility to use input fields in Unity Engine. Public class notifications: using void Start method handles the private GameManager reference to the game object in the Unity engine inspector. Void Start: The Submit method handles what happens when a player hits the submit button. It basically starts a coroutine (StartCoroutine) to send a message. The coroutine in Unity is responsible for executing the game logic over a number of frames. A coroutine is important because it sends web requests in Unity. Public void Submit: The private IEnumerator method is the coroutine that handles all frame iterations. In this method, I used the class WWWform to construct a form that would hold all the data that will be sent to Courier. Private IEnumerator SendNotifications: UnityWebRequest class is the class that sends the POST request(form) to Courier. UnityWebRequest: I had to set a request header to handle the authorization and authentication for the request to work. SetRequestHeader: yield return handles an async operation (POST request to Courier API) and pauses the execution until the request is sent. Yield return: Debug.Log is used to print to the console in Unity. Debug.Log: The SceneManager is responsible for reloading the scene or restarting the game once the submit request is sent.
Check out the for some additional explanation of the notifications script code. SceneManager: Courier Live Stream After coding the Notification script, I attached it to the GameManager gameObject, populated its input fields, and assigned the Submit button to be executed onClick event. Step 10: Next, I went over to the Courier notification to map out the event ID selected in the code and get the authentication token. Step 11: Now’s the fun part! I gave the game a test play. Step 12: With Courier, I Integrated Notifications in Under an Hour This process would have been a bona fide nightmare without Courier’s API. I would have had to program the logic myself, taking hours, if not days. With Courier’s pre-built logic and conditionals for the message content, I was able to build email and text SMS notifications into the game in less than an hour. Heck, you can watch me do the entire process in the live stream. While Rain Spikes was mainly an exercise in building notifications into a game, I see a ton of potential for Courier to be used for more complex and sophisticated projects in the future. For example, notifying players when someone has achieved a special reward or my idea for modernizing is to send gamers updates about the game via Discord. Courier messaging in Package Person Author: Matthew Graber Illustration by Rebekka Dunlap

Fetch

YouTube

Orchestrate Unlimited Notifications From 1 API | Sign-up today!

Courier simplifies triggering and sending notifications from your app with one API and drag and drop UI.


2021 - HackerNoon Contributor of the Year - SOFTWARE-ARCHITECTURE

2022 - HackerNoon Contributor of the Year - Business Strategy

2022 - HackerNoon Contributor of the Year - Digital Transformation

2022 - HackerNoon Contributor of the Year - Graphql

2022 - HackerNoon Contributor of the Year - Rest Api

2022 - HackerNoon Contributor of the Year - Software Architecture

2022 - Tech Ceo of the Year

2021 - HackerNoon Contributor of the Year - APP-DEVELOPMENT

Nominated for 2022 - HackerNoon Contributor of the Year - Rest Api

Nominated for 2022 - Tech Ceo of the Year

Nominated for 2022 - HackerNoon Contributor of the Year - Digital Transformation

Creating a Notification-Based Game via Unity and Courier

Too Long; Didn't Read

Companies Mentioned

Courier

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...