DEV Community: Dev Rayda

How to Publish Your Unity Game to Google Play

Dev Rayda — Fri, 12 Aug 2022 16:20:00 +0000

This article was originally published on the Sentry blog here.

For this tutorial, we will publish the “Tap (Frog)” game I developed in my previous Unity series, which you can explore here.

You need to have a Google developer account (which requires one-time payment of $25). After setting up your account, you can start adding and publishing your applications to Google Play. Before doing so, let’s prepare your game for publishing.

Prepare your game

Landscape Orientation

The “Tap (Frog)” game we developed is currently in landscape mode. Meaning, if a player were to rotate their phone, the game would automatically rotate and the player wouldn’t be able to play properly as the game screen would be cropped. To fix this issue, we want to adjust the game’s orientation to landscape only.

Open the game in Unity, click on File > Build Settings. Select “Android” as shown in the image below since we want to publish this game on an Android platform:

Next, click on Player Settings > Resolution and Presentation. Scroll down until you find “Allowed Orientations for Auto Rotation”. Uncheck “Portrait” and “Portrait Upside Down”. The game is now locked to a landscape orientation only.

Switching to Android Platform

The default for a Unity game is “PC, Mac & Linux Standalone”, so we need to switch to the Android platform. Return to the build settings window and click on Switch platform.

Other Player settings

Let’s return to the Player Settings and finish setting up the application. First, write the “Company Name” and “Product Name” as shown below. You won’t be able to change these after you upload the game, so make sure you’re pleased with your name(s).

Now you need to add the game icon which will appear on the user’s phone. You can either add one icon in the “Default Icon” field and it will resize automatically for the rest of the sizes, or you can click on “Icon” below and fill all the sizes for the different Android versions under Adaptive, Round and Legacy. Google requires the application icon to be 512 x 512 px, so this is what we will upload in the “Default Icon” field, as shown below.

Publishing Settings

Scroll down to “Publishing Settings” in the same window and click on “KeyStore Manager”. A keystore is a container file for keys used to sign the applications that identifies you as the developer. You will need a key and password for this.

Let’s create a keystore by clicking on the Keystore dropdown > Create New, and save somewhere for referencing later.

Next, setup and confirm passwords, and an alias, as shown below, before clicking on “Add key”.

A confirmation window will popup; click yes:

Now we can build the application. Head back to the build settings window and check “Build App Bundle (Google Play)” as shown below:

Click on “Build” in the build settings window. When the build is done, you will have a file with an .aab extension. You’re now ready to upload your application to the Google Play Store.

Upload Your Application to Google Play Console

Head over to the Google Play Console, click on “Create app”, and fill in all the necessary details for the app on the first page.

Before publishing, we’ll release our application for internal testing (you can test it with up to 100 internal testers).

Testing your application

There are three types of testing options in the console.

Open Testing, where anyone on Google Play can join and test your application.
Closed Testing, where you can release several versions of your application at the same time to test different features with a specific group of testers you choose.
Internal Testing, where you test with up to 100 internal testers (this is what we’ll do).

Internal testing

First, let’s create a release for internal testing and add yourself as a tester so you can test it yourself. Feel free to add additional testers to this track. Select “Internal testing” from the side menu, then click on “Select testers”:

We’ll create an email list of our testers, or upload via a .csv file.

A few more setting changes before uploading our game:

In your Build Settings > Player Settings, change the “Target API Level” to “Android 11.0 (API Level 30)”. You may need to update your Android SDK to API level 30. Each time you upload a new app bundle, make sure you increase the “version” from the Build Settings > Player Settings window. Otherwise, you’ll encounter an error.
While in your build settings, change the scripting backend from “Mono” to “IL2CPP”. In short, Mono is a better setting for iterative development, but if you care about performance, IL2CPP is the choice. Plus, the Google Play Store requires this for upload.
Lastly, check “ARM64” to make the game available on 64-bit devices.

Now click “Create new release”, where we can upload our application bundle build file, name the release, and write in any release notes.

If everything looks good and the upload was successful, “Save” then “Review Release” as shown below:

Next we’ll roll-out internal testing

Head to the testers tab, select the testers, copy that link, and open the link from your Android test device to begin testing your application.

The Dashboard

From the dashboard page, you can publish your store listing before you release the game and let users pre-register for your application. They will get a notification to download when your application is available.

Setting up your application’s content

On the dashboard page under “Set up your app”, there are tasks you need to complete. Finish these tasks and your application will be ready to be published.

After you finish testing and have setup your applications’s content, you are ready to create a release and publish to Google Play. Bear in mind that Google will take a few days to review your application and if there are any issues you’ll be notified about what to fix before submitting again.

Unity Tutorial: Developing Your First Unity Game - Part 3

Dev Rayda — Mon, 20 Jun 2022 09:19:26 +0000

This article was originally published on the Sentry blog here.

Welcome to the final article in this Unity series where we are developing a Unity game. You can check out my intro article, where I dive into Unity editor basics, or dive right into part 1 of our “Developing your first Unity game”, where we begin developing our Frog Unity game and I dig a bit deeper into a couple important game object components, and then part 2 of our “Developing your first Unity Game”, where I walk-through adding a falling effect, instantiating several prefabs in random places, & making and displaying a score counter.

In this article, we are going to create a main menu, add sounds to the game, animate buttons, pause, & finally, exit the game.

The following should be installed on your computer to follow along this tutorial:

Unity Unity Hub Visual Studio

In this tutorial, Unity Version “2020.3.23f1” is used.

How to create a main menu

To create a main menu for our game, we can add a new scene or create a popup window in the same scene. I personally prefer adding a new scene because the larger the game becomes & the more game objects you have in a scene, the heavier the scene is. You will have the opportunity to add more features to the game later.

Let’s add a new scene and name it “Menu”. We will use the same background we used in the game scene. Return to the TapGame scene and copy the canvas and the EventSystem from the hierarchy, and paste it in the “Menu” scene as shown below. This will save us a lot of time. If we want, we can edit the background image later.

Now we have the same background image, but we need to center it. Do so by adding the Main Camera in the Render Camera field in the inspector of the canvas (as shown below):

Since we don’t need the text object inside the canvas object, we can delete it.

Now we’re ready to make the main menu scene. First, let’s add an image for the game’s name. Drag the image from your assets folder and drop it into the hierarchy as shown below. Move the image towards the top-center part of the scene:

We’ll next add a play button that will take players to the game scene so they can start playing. To do so, right click in the hierarchy, add a button, and name it “Play”. You can either add an image as a sprite for the button and delete the text object as shown in the image below, or use it as it is. I will use a play button image and delete the text object.

The game should look something like this:

Next, we’ll animate our play button.

How to animate buttons

Unity has a great animation tool which we’re going to use on the play button we just added. We can change a lot of properties for the button; for example, rect Transform properties, image properties, or button properties. We will scale the play button down, then scale back to its original size when it’s clicked to create the effect that we’ve pressed and released. After the animation ends, we want players to enter the game scene.

To add an animation to a button, simply open the animation tool from Window > Animation > Animation:

While the play button is selected in the hierarchy, click on create in the Animation tab that opens and change the name to “playButton”.

An animator component, which is the controller of the animation, will be added automatically into the button object. Add a scale property to the animation as shown below:

Let’s make the animation duration 0.10 seconds long since we don’t want too long of a time gap between the button click and the action, which is transitioning to the game scene; but feel free to increase or decrease the animation duration to a value you prefer.

Next we need to create a clicking effect. To do so, we will reduce the scale value by 50% to 0.05 seconds so that the first half of the duration, the button’s size decreases, and the second half of the duration, the button’s size returns to its original size. To do that, copy the keys (the four small diamond shapes) and paste them at the 0.05 and 0.10 second intervals. Those keys we just pasted will change the details of the property. Now we can change the scale of the button to get the animation we desire. To do so, select the keys at the 0.05 second interval, which is half the animation duration, and change the scale value for x & y from 1.5 to 1.0 as shown below:

The animation will loop and start immediately after we click the play button. However, we don’t want the animation to loop; we just want it to play once. We also want to jump to the game scene after the animation ends. To do so, we need to create some transitions, so let’s double click on the play controller in the inspector as shown below and get started.

The animator controller window will open, & we can change when the animation will be activated. Right-click in the animator window and add a new state. Then, make two transitions from (and to) the new state & the playButton animation so that we can control the animation with these two transitions. Finally, since we don’t want the animation to start immediately when we start the scene (we only need it to start when we click on the button) we will set the new state as the default state:

Next, since we want the animation to begin when we click, we need to send a signal or make a clicking event, and to do so, we need to add a trigger (which we’ll name “Active”) to the transition from the new state to the playButton state. This will trigger the animation to start. To transition from the new state to the animated state, uncheck the “has exit time” checkbox.

We’ll then need to activate the trigger by writing a C# script, which we’ll name “Play”, and attaching it to the play button. Write the following code in the file:

Let’s run the game and click on the play button.

It doesn’t do anything (yet) after the animation ends. So we need to write a script that will take us to the game scene. In the “Play” script, add the following code:

To complete this feature, we need to add an event to the final step of the animation. Return to the animation window and add an event at the 0.10 second interval and select the function “PlayGameScene” as shown below:

Play the game and see what happens. You’ll notice an error occurring:

“Scene ‘TapGame’ couldn’t be loaded because it has not been added to the build settings or the AssetBundle has not been loaded.”

So, to move from scene to scene, all the scenes should be added to the build settings. To do so, click on File > Build Settings > Add Open Scenes as shown below. (If the TapGame scene is already open, it will be added. If not, make sure to open it and add it.:

Now play the game one more time.

We have a functioning play button that transitions us right into the game.

Pause Feature

Jumping back into the game scene, we need to be able to pause the game (open a pop-up window) and then resume playing. Let’s first add the UI elements for this feature.

Add the pause button to the top right of the scene exactly like we did with the play button in the menu scene. It should look something like this:

Next, we will make the UI for the pause pop-up window. We need a dark background image the same size as the background image and with an opacity of ~80% so we can still see a little bit of the background as shown below. Let’s duplicate the background image in the scene and replace the image with the dark background image.

Continuing on, we need to add an image for the frame of the pause window. It needs to be an image, not a sprite. If you drag the frame image from the project assets into the hierarchy, it will be a sprite, and you won’t be able to add or see other content (for example, text or buttons). It should look something like this:

Next we’ll add text “Paused” to the top center of the frame to indicate the game is in a paused state, two buttons for users to “Resume” and “Exit”, and finally a third button to toggle sound on/off. It should look something like below, but the buttons won’t do anything until we write some functions. All the objects are children of the Frame game object.

Time to code these buttons. We’ll start with the pause button in the game scene. We want to pause playing the game, show the dark scene, and display our paused window. To pause the game, we need to add a condition to the IEnumerator in our “Spawn” script:

Next, we need to write a “pause the game” function within the “Spawn” script:

public void PauseGame()
    {

        IsPause = 1;
        darkScreen.SetActive(true);
        frame.SetActive(true);

    }

Add this function to OnClick() of the pause button:

Before we try this code, make the public reference to the frame and the dark screen in the Spawn script as shown below:

Then drag the dark screen object and the frame objects from the scene into the empty fields in the inspector for the Spawn script as shown below:

When we play the game, the frogs that were already generated are still there after we press the pause button, and the frame is active. To fix this problem, we’ll simply destroy these frogs because it is faster and easier compared to keeping the same frogs, pausing their movement, maintaining their location, and continuing falling down the screen after we press resume.

Let’s add a tag, “frog”, then destroy game objects with the tag “frog”.

Head back to the Spawn script we just updated and write the following code. to destroy the frogs already in the scene by finding the game objects with the “frog” tag we just added.

For the resume button, we need to reverse what we did for the pause button; set the dark screen and the frame to be inactive, set isPause to 0, and start the coroutine again. Write the following code in the “Spawn” script…

public void ResumeGame()
    {

        IsPause = 0;
        darkScreen.SetActive(false);
        frame.SetActive(false);
        StartCoroutine(spawningFrog());
    }

…and add this function to OnClick() of the resume button. It should look like this:

For the exit button, we just want to go back to the menu scene. Load the menu scene as we did before (using the script below) and attach it to the exit button.

In the inspector for the exit button, select the function from the drop down menu for the OnClick() as shown below.

Time to check the pause & resume buttons. The experience should look like this:

Adding sound

Before adding a sound button to toggle on/off, we need to first add sounds. Let’s add a sound when the frog explodes. You can search for free sounds for commercial use online or use files you’ve paid for already. Import the file into the assets folder once you’ve downloaded it.

Next, attach the sound script to an empty game object and refer to the script when we need it. Create an empty game object and name it “SoundManagerObject”. Create a C# script, name it “SoundManager”, and attach it to the object created.

We will write the following code in this script.

using UnityEngine;
using UnityEngine.UI;

public class SoundManager : MonoBehaviour

{

    //A public variable for the audio source we just imported.
    public AudioSource explosionSound;

    //A variable to check whether the user wanted a sound or the user muted it.
    int IsSound;

    //References to the sound buttons and its two images.
    public Sprite soundImage;
    public Sprite noSoundImage;
    public Button SoundButton;

    // Start is called before the first frame update
    void Start()
    {
        //Get the sound value from the player preferences.
        IsSound = PlayerPrefs.GetInt("Sound", 1);

        //Check if the user wants a sound or not.
        if (IsSound == 1)
        {
            //Change its image
            SoundButton.GetComponent<Image>().sprite = soundImage;
        }
        else
        {
            //Change its image
            SoundButton.GetComponent<Image>().sprite = noSoundImage;
        }

    }

    public void playSound()
    {
        IsSound = PlayerPrefs.GetInt("Sound", 1);

        if (IsSound == 1)
        {
            //Play the explosion sound
            explosionSound.Play();

        }

    }
    public void muteSound()
    {
        //Reduce the volume to zero

        explosionSound.volume = 0;
    }

    public void unmuteSound()
    {
       //Raise the volume to one
        explosionSound.volume = 1;
    }

public void ToggleSound()
    {
        //Check if the sound is on, equal to 1
        if (IsSound == 1)
        {
            //Change the variable to zero and save it in preferences
            IsSound = 0;
            PlayerPrefs.SetInt("Sound", IsSound);
            PlayerPrefs.Save();
            SoundButton.GetComponent<Image>().sprite = noSoundImage;
            muteSound();

        }
        else
        {
            IsSound = 1;
            PlayerPrefs.SetInt("Sound", IsSound);
            PlayerPrefs.Save();
            SoundButton.GetComponent<Image>().sprite = soundImage;
            unmuteSound();
        }
    }

}

Up until this point the frogs haven’t made any sound when they explode, and our sound button cannot be used to mute/unmute. We need to toggle the sound button. Head to the sound button inspector and add the OnClick() function of “ToggleSound()” as shown below:

The only thing missing is an explosion sound when the frog explodes. To do so, we need to add the audio source component to the “SoundManagerObject” game object. Select it, add the “Audio source” component, and drag the sound file into the empty field as shown below.

Lastly, edit to the “KillFrog” script to play the sound when we click/destroy the frog. We will add the following code inside this script:

Our game is ready to play.

I hope this 3 part series has been helpful as you begin developing more games in Unity. Thank you for reading and I hope you enjoy playing the frog game you just created.

Unity Tutorial: Developing Your First Unity Game - Part 2

Dev Rayda — Thu, 12 May 2022 17:56:41 +0000

This article was originally published on the Sentry blog here.

Welcome to the third article in my Unity series where we are developing a Unity game. You can check out my intro article, where I dive into Unity editor basics, and then part 1 of our “Developing your first Unity game”, where we begin developing our Frog Unity game and I dig a bit deeper into a couple important game object components.

In this article, we are going to walk-through how to add the falling effect, how to instantiate several prefabs in random places, & how to make a score counter (and display it) for our Frog game.

The following should be installed on your computer to follow along this tutorial:

Unity Unity Hub Visual Studio

In this tutorial, Unity Version “2020.3.23f1” is used.

How to add the falling effect to your Unity game

Let’s say we want to add a water effect for when the frog falls into the lake. But the lake is a background image and we want the frog to be able to collide with the lake. To do so, we will simply create an empty object by right clicking in the hierarchy, and give it the name: “lake”. For a game object to collide with another, we need to add the “Box Collider 2D” component as I explained in my previous article (deep link for your convenience).

We need to edit the collider to be located at the bottom of the scene and make it as wide as the scene (as shown in the image below):

Now let’s add a script so that when the frog collides with the lake game object it gets destroyed.

Open the “KillFrog” script and write the following code.

private void OnCollisionEnter2D(Collision2D collision)

    {
        Destroy(gameObject);
    }

Let’s save the code and run the game to check if the frog will get destroyed.

So far, so good. Now let’s instantiate the water effect for when the frog falls into the lake. As I introduced previously, we can visit the Unity Assets store and import the “Cartoon FX free” asset. For this, we will use the water effect. Open JMO Assets folder > CFX2 Prefabs folder > Water. We will do exactly as we did in my last article with the smoke effect, but we will write the code inside the OnCollisionEnter2D() function.

Write the following code in the “KillFrog” script:

Let’s drag and drop the water effect in the empty field in the inspector:

Time to run the game again. As you can see, the frog is destroyed and there is a water splash effect when it nears the bottom.

The above code we added will be problematic in the future; it will destroy the frog if it collides with any game object with a collider component attached to it. So, when we add more frogs later, and when they collide with each other, the frogs will get destroyed. To fix this problem, simply add a tag to the lake in the inspector and in the script check if the frog collided with the game object with the tag “lake”.

We’ll add a tag and name it “lake” in the inspector as shown in the image below.

Let’s write the following code in the “KillFrog” script to make sure the frog collides only with the game object with the “lake” tag.

Now the frog is ready to be a prefab.

How to create a prefab

Before creating a prefab, create a new folder inside the assets folder and name it “Prefabs”. To create a prefab, simply drag the game object (in this case, the frog) from the hierarchy into the prefabs folder. And voila – you have a frog prefab.

C# script: Instantiate a prefab in a random place

Before instantiating several frogs into the scene, delete the frog currently in the scene. To do so, just right click on the frog and then delete. We don’t need it anymore as we will instantiate several frogs from the prefab we just created.

We want to instantiate the frog within the bounds of the screen right. To do so, we need to determine the width and height of the screen. We will generate a random number between 0 and the width of the screen for the X position and random number between 0 and the height of the screen for the Y position.

To do this, write the following code in a new script file called “Spawn”.

For this script to work it has to be attached to a game object. We can attach it to the main camera and drag and drop the frog prefab into the empty field.

Let’s run the game and check where the frog will appear:

Now we can generate several more frogs.

How to instantiate several sprites

There are several ways to do this. First, we can write the code in the update function. In this case we will get a frog in every game frame. That will probably be too much – but let’s check it out.

Now cut the code you wrote in the start function and paste it in the update function.

See what happened here? The reason for this is the default rate for a Unity game is 60 frames per second. And in our code above, we generate a frog every frame.

The second way to do this is to specify a certain number of frogs you want to instantiate in the current scene. We can use afor loop for this case so cut the code and paste it in the start function cause we want it to work only one time.

Check the code below and run the game.

A third way to do so is to use IEnumerator function and StartCoroutine. They are used if you want to pause a running function for a few seconds and call that function again. In this code, we wait for 0.8 seconds before instantiating a frog so every 0.8 second a frog is spawned in the scene. This code runs forever, as long as the game is running. Let’s check the code below and run the game.

How to create a Score Counter

Now we want to count the score for when we kill the frogs and keep this number so we could display it later.

First, we need a public integer variable for the score. Second, we need a player preferences variable to keep this score across the game and this one will be accessed from any script. It will be saved on the player’s device. We have to save the public integer in the player preferences variable after the player kills a frog.

Let’s go back to the script attached to the frog, “KillFrog”, and write the code below. What we need to do is, after we kill the frog, we increase the score and save it in the player preferences variable.

For now (before displaying the score), we can log the score into the console to see if it is working.

Debug.Log("Score "+ TotalScore.ToString());

Now let’s display the score in the scene.

We need a text game object for the score. To add one, just right click on the canvas object in the hierarchy and select UI then Text. Name it “ScoreText”. The text is so small and in the middle of the scene. Let’s drag it to the top left of the scene, increase the font size to 50, change the text to “Score”, change the color to black, make it bold, and change the vertical overflow to “Overflow”. It should look like the image shown below.

Now we need to change the score text dynamically. Let’s go back to the “Spawn” script and write the following code. We will need to drag the text object into the empty field in the inspector.

Let’s run the game and see the score changing dynamically.

Setting up Issue Alerts to monitor errors

If we want to get alerted when errors occur in our Unity game, we can set up Issue Alerts in Sentry so we’ll know when our code is breaking. We’d like to monitor for errors while avoid getting spammed by tons of alerts about the same errors. With Sentry you can group errors together in a single issue and get notified about the issues you care most about. You can create conditions, for example (to name a few):

when you want to be notified
who will receive this notification from your team
what error type(s) you want to get notified about

With Sentry, we can create two types of alerts: Issue Alerts for errors and Metric Alerts for performance issues as shown in the image below.

Let’s quickly define all the specific issues or metrics we can create alerts for:

Issues: It is used for a group of errors and you can check an example of creating one below these bullet points.
Number of Errors: This one is self explanatory, it is when the number of errors exceeds a certain number you specified. Users Experiencing Errors: When you want to monitor if the number of users having errors exceeded a certain number.
Crash Free Session Rate: When you want to monitor the rate of a session without crashing. A session is when the application starts and ends by either getting closed or goes into the background. Crash Free User Rate: The number of users who haven’t experienced a crash while using the application.
Throughput: When you want to monitor the number of transactions in a specified amount of time.
Transaction Duration: When you want to know how long a transaction takes to complete.
Apdex: When you want to monitor the user satisfaction rate and that is measured through the response time of your application.
Failure rate: When you want to monitor the rate of failed transactions.
Largest Contentful Paint: When you want to monitor the loading time of the largest content to render in the viewport.
First Input Delay: When you want to monitor the response time of when the user interacts with the application.
Cumulative Layout Shift: When you want to monitor the visual layout shift. For example, if an image is taking time to load and when it loads it shifts other items on the page.
Custom Metric: When you want to monitor a metric not included the list above, you can create a custom one.

Let’s create a new alert.

You can set rules for Issue Alerts on the alerts page in Sentry. To create an Alert rule simply click on “Create Alert” then the “Set Conditions” button.

We’ll set two types of triggers which will determine the activity type we want to monitor.

Issue state change, and
Frequency

I want to get an email when there is an event and it is seen more than 5 times in 1 hour. Select from the filter options. Filter is for adding “if” conditions to rule out unneeded errors.

And I want to select the level of this event to be error. There are several levels for the events and they are: sample, debug, info, warning, and fatal.

Next we’ll add an action for this alert. You have the option to set up Slack notifications, send a notification to another team member, send via email, create tickets in Microsoft Teams or create a ticket in Jira.

Finally, you can set an interval for this action. As I mentioned earlier, I’d like an email to be sent every hour.

Now let’s trigger an intentional error and see if we get an alert and an email.

Go back to the Unity project and remove the score text game object from the field in the Main Camera inspector in the script component. Now run the game and play it for a bit. You can see that the score is not updating and you are getting tons of errors.

Back in Sentry, you will find 1 alert triggered, and you can check your email to find a notification sent from Sentry about this alert. The image shown below is the Alert page after getting 1 Alert triggered. You will find a graph showing the number of times this alert has been triggered over a specified date range. On the right, you will find last time this alert was triggered, the alert conditions that you specified, plus more details about this alert.

Now go fix the error by dragging the text object into the empty field in Unity, and close it out in Sentry by clicking resolve. We’ll keep our alert settings in place in case we experience this error again in the future.

That’s all for now. Stay tuned for my next article where we will finalize our frog game.

Unity Tutorial: Developing Your First Unity Game - Part 1

Dev Rayda — Thu, 07 Apr 2022 12:34:57 +0000

This article was originally published on the Sentry blog here.

Welcome to the second article in this Unity series. You can check out the first article, where I dive into Unity editor basics, here. Over the next few posts we are going to develop a fully functional mini game. In this article, we are going to walk-through adding a new scene, two important components (Rigid 2D and Box Collider 2D), how to destroy a game object, prefab, and how to instantiate a prefab.

The following should be installed on your computer to follow along this tutorial:

Unity
Unity Hub
Visual Studio

In this tutorial, Unity Version “2020.3.23f1” is used.

At the end of this series, a 2D mini game will be created. In this game, players will try to tap on frogs, who will be appearing in random places, before they fall into our lake. When players tap on them there will be a purple smoke effect.

Adding a New Scene

Let’s add a new scene in the project we created last time. This scene will be our new mini game. To add a new scene, simply right click in the Assets/Scenes folder > Create > Scene.

Name the new scene “TapGame”.

Open the new scene and add a background image. Follow the exact steps that were covered here in my last article. This is how the scene should look (below). In the hierarchy, you should have an event system and a canvas with the background image as a child.

Adding the sprite

Now we will add the frog sprite. Just drag and drop the frog in the hierarchy, and scale the frog down to 0.1.

Next, we’ll add two important components to the frog sprite.

Box Collider 2D

Since we want to click on the frog, we need a Collider 2D component. Collider 2D components help in defining the physical shape of the game object for collision and trigger purposes. There are several shapes for the Collider 2D aside from the “Box”, which is a rectangle shape, and they are:

Circle collider 2D for round objects
Polygon collider 2D for 2D complex shape
Edge collider for surfaces

The frog’s shape is closer to a rectangle so I chose the Box Collider 2D.

Let’s add this component and check the inspector. Click on “Add Component” and select “Box Collider 2D”.

Let’s check the component’s properties.

Edit Collider: As the name suggests, we can edit the collider rectangle by clicking on this button. When you click on it, you will see a green rectangle around the frog as shown in the image below. You can move the lines by selecting the small squares.

Material: the physical material that covers your game object that affects its physical properties, such as friction and bounce.
Is Trigger:check this one if you want the Cox collider 2D to be a trigger. A trigger means that if a rigidbody gets in the trigger’s volume it will send these messages: OnTriggerEnter, OnTriggerExit, and OnTriggerStay. If it is checked, a collision with a rigidbody won’t be registered.
Used By Effector: check this if you have an Effector 2D component added to the game object, and you want to direct the forces according to that effector component when game objects collide with each other.
Used By Composite: check this box if you have a Composite Collider 2D component added to the game object. When you check this one, some properties disappear, “Is Trigger”, “Material”, “Used By Effector”, and “Edge Radius”, as they are controlled by the composite 2D component.
Auto Tiling: Check this if the sprite draw mode is Tiled. I will explain tiled draw mode in a later article, but if you’re curious now, you can read more about it here in Unity’s documentation. The shape of the collider will be updated automatically when the sprite’s size changes.
Offset: when you move the collider lines, the offset values change. The values are zero when the lines are exactly on the edges of the sprite.
Size: this one is self explanatory, the size of the collider box.
Edge Radius: this is the corner radius of the collider box and controls whether you want the box edgy, or with round corner radii.

Rigidbody 2D

Now let’s add a Rigidbody 2D component to the frog by first clicking “Add Component”. We’ll then search for Rigidbody 2D and add it.

Before doing anything else, let’s click on the play button to see what happens in our mini game so far…

As you can see, the frog just falls down and leaves the screen. This is because the frog has a rigidbody that is affected by gravity as it is under the control of Unity’s physics engine.

Let’s check the Rigidbody 2D component properties.

Depending on the Body Type, the properties of the Rigidbody 2D component change. The body type affects movement and collider interaction.

Body Type: Dynamic

The Dynamic body type is the default type. It has all the properties and is the most interactive.

Material: The physical material is the same as the one I explained in Collider 2D component. If there isn’t one already set in the Collider 2D component, this is the material that will be used. If there is a physical material set in both components, the priority will be the material set in the Collider 2D component.
Simulated: When this one is checked (and it is checked by default) the Rigidbody 2D component and any attached Collider 2D components will interact with the physics simulation. If not checked, they won’t.
Use Auto Mass: Check it if you want to use the mass from the attached Collider 2D component.
Mass: Define the object’s mass
Linear Drag: A coefficient that affects positional movement.
Angular Drag: A coefficient that affects rotational movement.
Gravity Scale: This is self explanatory: how much do you want your object to be affected by gravity? For a lower gravity effect, pick a number less than 1. There is a simple way to make the frog fall down slower. Let’s change the gravity scale into 0.3 to have a slower speed. You can check the frog’s falling speed by running the game.
Collision Detection: This will either be discrete or continuous. If Discrete is selected, game objects can pass through each other after a collision. If Continuous is selected, game objects can not pass through each other.
Sleeping Mode: The three modes for the game object’s sleeping: Never Sleep, Start Awake & Start Asleep.
Interpolate: This defines how the game object’s movement is interpolated. There are three options:

None - no movement smoothing at all
Interpolate - smoothed movement based on the game object’s previous frame position
Extrapolate - smoothed movement based on the game object’s next frame position.

Constraints: This is used to restrict the game object’s position or rotation.

Body Type: Kinematic

A game object with a kinematic body type is not affected by gravity or forces. So it is faster than a dynamic body type game object. You will need scripts to determine how this game object should move and physics queries to detect collisions. It only collides with a dynamic rigidbody.

As you can see from the image below, some properties we defined above are not available for the Kinematic Rigidbody.

We do see one new property, however.

Use Full Kinematic Contacts: If you want this kinematic rigidbody to interact with all rigidbody types, check this option, but understand it will act as an immovable game object.

Body Type: Static

This rigidbody type does not move at all under simulation even if another game object collides with it. It only collides with dynamic rigidbody game objects.

For this game, we want the frog to have a dynamic Rigidbody type with a gravity scale of 0.3.

Destroying a Game Object

In order to destroy a frog when a player taps on it, we’ll need to write a C# script.

For organizational purposes, let’s create a new folder and name it “Scripts”. Move the “Scale” script we created in my last article to this folder. Right click in the Assets folder > Create > Folder, as shown in the image below.

Now let’s create a new C# script inside the “Scripts” folder. Right click in the Scripts folder > Create > C# script, as shown in the image below.

We’ll name it: KillFrog

Now open the “KillFrog” script and write the following code:

Add a onMouseDown() function and inside it, Destroy(gameObject). This will destroy the game object it is attached to when a player clicks (on PC/laptop) or taps (on a tablet/mobile phone) on it.

Attach this script to the frog by simply dragging the script into the frog’s inspector, or the frog object itself, in the hierarchy.

Now let’s run the game and check if it is working.

It disappears! Clicking on the frog destroy it, but what if we want to add an effect when the frog is destroyed?

Let’s explore two new concepts for this type of effect:

Prefab
Game object instantiation

Prefab

A prefab is simply a game object template. You can configure a game object with the needed components and its properties, and then can create an instance from this prefab in the scene. The game object instance will have these components with the configured properties. When you change the components in a prefa, all the instances’ components will change as well so they will be in sync.

When you want a game object to appear in the scene that was not created from the start, you need to instantiate a game object at runtime. To be able to instantiate a sprite, for example, you need a prefab. When you instantiate a game object at runtime, there will be an instance of that game object created in the scene.

To create a prefab simply drag the game object from the Hierarchy into the project Assets folder (after, of course, adding all the components you need.You can edit these components and add more components anytime).

We will create a frog prefab later in the series when we finish all the needed components. But for now we understand what a prefab is.

Time to add an effect for when the frog is killed. Let’s visit the Unity Asset store to browse effects.

Unity Asset Store
Unity has a Unity Asset Store which you can visit directly or through the Unity Engine by selecting Window > Asset Store.

This is an assets store with tons of free and paid assets you can use in your games. Check their licenses before using them commercially, though.

I will use the Cartoon FX Free effect. This asset is available for free and has around 50 cartoon effects.

To import this asset into your project, click on the “Add to My Assets” button in the Asset Store.

Accept the Terms of Service and then click Open in Unity.

The Package manager will open and you’ll be able to download the package.

Import this package into your project. You can leave all the items selected or feel free to select only a few items.

You will find a new folder titled “JMO Assets” in your assets folder, with 3 folders inside.

We need the prefabs inside the first folder, “Cartoon FX”.

These prefabs are for particle system effects. I will elaborate more on this in a later article. For now, we need an explosion effect for when a player kills the frog.

Locate the explosion prefab inside the “Explosions” folder in the “CFX2 Prefabs” folder.

Double click on the explosion prefab to take a look. You can click on play to see it in action.

Now let’s instantiate this prefab when we destroy the frog.

Instantiate a prefab

To instantiate a prefab, you only need one line of code and a reference to that prefab.

Let’s understand this line of code:

Instantiate(SmokeEffect, transform.position, Quaternion.identity);

[SerializeField] makes this a public game object where we can drag the prefab and into the field within the inspector of the game object that the script is attached to.
transform.position: this position is that of the game object the script is attached to, which is the frog in this case – which is exactly what we want.
Quaternion.identity: Quaternion means zero rotation so the explosion will not be rotated.

Let’s save the script and go back to Unity to drag the explosion effect into the empty field of the script, as shown in the images below.

Time to run the game and tap on the frog to see if this worked…

Error Monitoring Using Sentry

In my last article I introduced Sentry and used it to track our game’s errors and monitor our game’s performance. In this article I will focus in more on error monitoring.

Let’s make an intentional error & track it in Sentry.

I’m going to remove the explosion game object from the “Smoke Effect” reference field in the script “KillFrog” inspector as shown in the image below.

Run the game, tap on the frog and see what happens.

As you can see, the frog is destroyed but there is no explosion effect and we get an error in the console, an Unassigned Reference Exception.

We can open up Sentry to see all the context for this error. Since we don’t sit at our desk all day waiting for errors to occur, we can set up alerts to show errors based on criteria (like how often they’re happening) and notifications to our email or Slackworkspace.

From the issues tab, you will find you have an unresolved issue.

The issue is “Unassigned Reference Exception”. Let’s open the error page and dive in.

When you arrive on the error page, you will find the name of your project, the error type, then a few buttons.

Resolve: closes out the issue when you resolve it
Ignore: If you want to ignore this issue (perhaps we’re already aware of it, or it’s noisy and we need to edit our criteria for when we’re alerted about this particular error)
Mark reviewed: If you’ve already reviewed this issue.
Delete (icon): you can delete this issue without solving it, but of course this error will be created again if the issue happens again.
Share: Get a link to share it with colleagues, or publicly
Open in Discover: You will need a business plan for this feature. You can start a 14 day trial to utilize Discover.

Then you have the exception section where we can see the error type and what went wrong. For example, here, we see exactly why this error occurred and what we need to do to fix it.

The error: “The variable SmokeEffect of KillFrog has not been assigned.”
How to fix it: “You probably need to assign the SmokeEffect variable of the KillFrog script in the inspector.”

Then it gives more details on the error: The error happened at line 28 in the KillFrog.OnMouseDown function when we tried to instantiate.

Below that we see the breadcrumbs, which shows us what happened leading up to the error occurring.

Along the right hand side in Sentry, as shown in the image below, we are provided with additional context about this error.

At the top, we see “Ownership Rules”, which are used when you have a team so that issues can be automatically routed to the right person to resolve the issue. Next, you will notice “first seen” and “last seen” times to give you a quick understanding of how long ago, and how recently, this issue has occurred. If you want to connect Sentry to your issue tracking tool, like JIRA, you can do so here (as well as in Settings). Below that are tags related to this issue which provide even more context (what devices or operating systems are experiencing this particular error? Which release(s) is the error showing up in?). And finally, which team members are already participating/working on this issue.

In summary, Sentry is providing us with a lot of context about the issue.

We can fix the issue by assigning the explosion prefab in the inspector and resolving it (clearing it out) in Sentry. Again, as mentioned above, if we want to set up a specific alert for if/when this error occurs again, we can manage our alerts to get notified when certain error criteria that set is met.

Conclusion

Thank you for reading and I hope you learned more about the Unity & Sentry platforms. Stay tuned for the next article where we will continue developing our exploding frog game.

Unity Tutorial: What You Need to Know Before Developing Your First Unity Game

Dev Rayda — Fri, 25 Mar 2022 08:55:31 +0000

This article was originally published on the Sentry blog here.

In this article we are going to talk about Unity basics. By the end you will understand the Unity editor interface, Game Objects and Sprites, the frequently used UI elements, and a high-level overview of how to monitor your Unity games for errors and performance issues. This is written for beginners who have never used Unity before but have previous experience using a programming language.

The following should be installed on your computer to follow along this tutorial:

Unity
Unity Hub
Visual Studio

In this tutorial, Unity Version “2020.3.23f1” is used.

Unity is a cross-platform game engine where you can develop 2d and 3d games. When we say cross-platform, we mean it is used to build multi-platform applications (for example, Android, iOS, desktop, virtual reality, consoles). It supports more than 19 platforms and the Unity editor is supported by macOS, Windows, and Linux.

Let’s open Unity.

Introduction to the Unity editor interface

Start by opening Unity Hub > Click on New Project > Select 2D > Click on Create Project.

After opening Unity and creating your new project, you’ll land in the editor interface (see below). The Unity Editor has several windows. You can edit the layout to whatever suits you. But before changing the layout, let’s understand a little more about each window’s capabilities.

Hierarchy window

This window is for all the objects in the scene in hierarchical order. By objects, I mean game objects which are literally anything in the scene. In the image above, the “Main Camera” is a GameObject. The GameObjects will be arranged in the same order you created them (you can re-arrange if you’d like). The order (top to bottom) does not matter all that much in most cases. But the Hierarchy allows creation of Parent-Child relationships by dragging GameObjects into each other.

Scene Window

A Scene is where the actual content of your game lives. The scene can be a menu scene, a level scene, a game scene, etc. You can view the scene in 2d and 3d view, even if it is a 2d project. To do so, just toggle the 2d button as shown in the image below. In this window you can select, position, and/or modify the GameObjects.

Game window

Located just to the right of the “Scene” tab, the “Game” tab opens a window of what the player will see when they play your game.

Game Object Inspector Window

From this window, you can change any component of the selected GameObject. In the image shown below, the Main Camera GameObject is selected, and below is all the detailed information for the Main Camera. “Transform”, “Camera”, and “Audio Listener” are all components added to the Main Camera by default. You can add more components to a GameObject by using the “AddComponent” button. We will talk more about components later.

Project Window

This is where the project folders live. There is an Assets folder and a Packages folder. The Assets folder contains everything about your game — scenes, images, fonts, C# scripts, sound files, and more. The Packages folder contains the packages which are “extensions” to the Unity Editor that can add functionality or assets that you install from the Package Manager (for example Unity UI Package, which is installed by default). You can remove the packages from the Package Manager. To open the Package Manager click on Window in the menu bar, then Package Manager.

Console Window

Just right of the Project Window is the Console Window. Here you will find log messages, error messages, and warnings.

Changing the Layout

I’m going to change the layout to a (personally) more preferable view.

There are pre-saved layouts from the Layout dropdown menu as shown in the image below.

You can change the layout by dragging and dropping the windows wherever you desire. Here, I dragged the Game window to be below the Scene window at the center, and the Project & Console windows to be below the Hierarchy window on the left. Choose whichever layout you prefer.

Game Objects

A GameObject is any object in your scene. It is like a container that has properties. You change properties by adding and editing its components. Unity has a lot of components ready to be used, but you can create your own as well using C# scripts.

There are a few ways to create a GameObject and add it to a scene:

Right-click in the Hierarchy window, then choose any of the objects from the popup menu as shown in the image below. You can create an empty object, select a 2D object, a 3D object, effects, and so on.

Alternatively, you can drag an object from the Assets folder and drop it in the Hierarchy window (Unity will try to create a GameObject with the appropriate components for you).

When you create an empty GameObject, it is an empty container until you add components. This empty GameObject can be used as a container for the scene management script, for example (we will talk about scripts later). This GameObject will not be visible to the player since it has no component that can be rendered/displayed to the player, but the script will run in the background.

Let’s create one and check the inspector.

According to the image above, the empty GameObject only has a Transform component. We will talk about the Transform component a little later. As you can see in the Scene window, only the Main Camera is shown. The Main Camera has some special components like Gizmos which can easily be found in the scene view.

Let’s check out some other frequently used game objects.

Sprites

A Sprite is a 2D graphical GameObject (basically an image). They are images that cover the GameObjects to give them a visual appearance.

Let’s add a Sprite into our scene.

There are two ways we can add a Sprite:

If you want specific shapes, like a square or a circle, right click in the hierarchy window > 2D Object > Sprites > Select whatever shape you want as shown in the image below.

Drag an image from the assets folder into the hierarchy window. To do this, we’ll need to add images into the asset folder. For organizational purposes: Create a new folder within the assets folder for Sprites / images.

Now you can drag items into the images folder, or right-click on the images folder > Import New Asset > Choose the image you want from your computer.

I’m going to add an image of a frog into my Assets > Images folder.

Let’s add this Sprite into the scene by dragging it into the Hierarchy window.

As you can see in the image below, the frog image appears low quality as the outline is pixelated.

To improve the quality, uncheck Low Resolution Aspect Ratios as shown below.

We need to scale the frog down as it is too big. To do so, select the frog, then go to the Inspector and change the Scale in the Transform Component to a smaller size (0.5, for example). Another way to do this is to select (and grab) the image by one of the blue dots around it’s edges and, while holding the shift key to maintain aspect ratio, drag it to the size you want.

Sprite Inspector

Now let’s take a look at the Sprite’s inspector.

As shown in the image, a Sprite has two main components by default:

Transform
Sprite Renderer

You can always add more components using the “Add Component” button at the bottom.

The Transform component has the object’s position, rotation, & scale in X, Y, & Z coordinates. Since this is a 2D game object, Z will be 0. These are pretty self explanatory.

Let’s see how these X, Y, and Z coordinates are measured.

For the “Position”, X & Y are measured from the center of the screen. The center of the screen grid is point (0,0).

The frog’s center is located at point (0,0) thus position X = 0 & Y = 0. This point is measured from the blue circle at the center which is called the object’s pivot.

The Sprite’s rotation will rotate around the pivot. Let’s change rotation values and check the frog. If we change the X value, it will rotate around the X axis.

If we change the Y value, it will rotate around the Y axis.

If we change the Z value, it will rotate around the Z axis.

To open the Sprite Editor window: From the menu bar, select Window > Select 2D > Sprite Editor, then select the value from the Pivot dropdown window (center is the default).

Let’s define the main properties of the sprite renderer component:

Sprite: You can change the image here

Color: Change its color.The chosen color will cover the image but keeps the outline of the frog. Let’s change the color to black as shown in the image below.

Flip: Allows you to flip the game object vertically and horizontally by checking the X & Y.
Additional Settings: If you use layers, you can sort the GameObject into a specific layer, as well as its order in that layer. For example, you can make a background layer that will be the background image of your game. Then the UI layer will be for the buttons and menus.

UI Game Objects

To add these GameObjects to the scene, we right-click in the hierarchy window > UI menu.

Now, let’s add the following UI GameObjects and check their inspector components.

When you add a text, image or button GameObject, a Canvas and an EventSystem are automatically added to the Hierarchy. Let’s define and understand these, and then we’ll continue on with the GameObjects.

Canvas

The Canvas is a container for all UI elements in the scene. All UI elements such as texts, images, & buttons should be inside a Canvas. If Unity did not find one, it will add one automatically as you saw when you added a text GameObject.

As shown in the image, Canvas inspector has four components in its inspector by default:

Rect Transform
Canvas
Canvas Scaler
Graphic Raycaster

Rect Transform

Similar to Transform but has more properties and is mainly for UI elements. Here it is grayed out, as these values are controlled by the Canvas component.

Canvas

Canvas is a component that controls how a group of UI elements will be rendered. All UI elements must be children of a Canvas. It is possible to have more than one canvas in a scene.

When we look at our frog in the game view and scene view, you’ll notice the text is very small in the game view and the Canvas is shifted in the scene view.

To adjust, we can change the Render mode to “Screen Space - Camera” and drag and drop the “Main Camera” from the Hierarchy into the Render Camera component as shown in the two images below.

Now the Canvas will be centered in the main camera view as shown below:

Canvas Scaler

This component lets you choose how the UI elements scale when the screen size changes from device to device. You will normally want it to scale with screen size and that is what we will do. Change the UI Scale mode to “scale with screen size” as shown:

We also need to choose a reference resolution. This is self explanatory. I normally choose the size of the background image so the image won’t be crushed. We will change this later after we add a background image.

Graphic Rayaster

Do you ever wonder how the graphics are being detected?

It is the raycaster that sends rays and looks to see if any graphics have been hit or not. (“hit by that ray”)

From this component you can determine whether to ignore reversed graphics (backfacing graphics) or not, and decide on the blocking objects and masks to that ray.

Event System

The Event System is for events. It captures input events from input devices (for example a mouse, keyboard, or touch on mobile devices). If there is no Event System, you will not be able to have any input events.

Text, Image, Button objects

Text

Now let’s go to the text GameObject. Locate and select the text, then drag it to where you want it on the screen (let’s move it to the top left corner). We can increase the text font size (to 30 for example) to make it more visible. It will appear the text has disappeared, but we can correc this by changing the vertical overflow in the inspector from “Truncate” to “Overflow”, as shown below. We will probably change the text color later, after we add a background image. You can change the size of the text GameObject as well by dragging the text by one of it’s corners so it will hold more text without the need to overflow. This will be needed after we make a final UI design as this text may have a background frame.

Image

Let’s give our game (and frog) a background image. We can import a background image into the assets/images folder. I added the image GameObject into the scene and named it “BackgroundImage”.

In the Image inspector, drag and drop the imported image into the “Source Image” property in the “Image” component.

If the image looks too small, navigate to the image component and click “Set Native” to make the image its original size. But now it’s too big. Make sure position X & Y are both set to zero so that the image is centered.

It is ok that the image is too big, the reason for this is that the canvas is set to a lower resolution. Remember earlier when I mentioned that we’d change the reference resolution to the size of the background image? Let’s go to the canvas GameObject and set the reference resolution to the size of the image.

My image is 1920 x 1351 px. Now the image’s size looks good, but because it is not the same ratio as the screen, we will have to change the anchors and the image position.

If we want to change the image position and anchors, we can navigate to the “Rect Transform” component for our background image in the image inspector. Select “center-middle” from the anchor presets.

Hold “Alt/Option” and select the bottom-center position for the image and anchors position to adjust. As you can see, the anchors changed their location to “bottom-center” and the image did as well.

Since we added text GameObject before the background image, we’ll need to change the order to bring the text to the front. You can move objects forward or backward by moving them up (or down) in the Hierarchy window. Lower items will be more forward, and higher items more towards the back.

We need to revisit our text object and change its size as it depends on the reference resolution of the canvas. As you can see a few images above, the text is relatively small.

I changed the font size to 60 and edited it to say “Make the frog smaller”, changed the text color to black, and made the text object wider by dragging in the scene viewer. You may have noticed the text object disappears (if you happened to move it over top of the frog) as the frog is a Sprite, not an image.

Button

To insert a button, right click in the Scene Hierarchy and go to Create → UI → Button. The button is accompanied with a text GameObject.

We can change the position, color, and size of the text & the button,

I edited the text game object of the button, changed the text to “Scale”, changed the color to black, and changed the font size to 40. Now we have a button that does not do anything until we add a C# script.

Introduction to C# Scripts

If you’re not familiar with C#, you can get familiar with it over at W3Schools or Microsoft. It is the programming language used in Unity scripts.

Let’s add a small C# script to our button GameObject so that when we click the button, the frog scales down. We’ll add a script component to the button by clicking on “Add Component” in the button’s inspector and name the script “Scale”.

Unity defaults to Visual Studio for editing, but you can select any editor you prefer from the “External Tools” panel in preferences. After double clicking on the “Scale” script we’re taken to our editor with some initial content like this:

Every script made in Unity contains two functions, “Start()” and “Update()”, inside a public class with the name of the C# file you just created.

When you run the game, the “Start()” function runs one time at the beginning of the game, while the “Update()” function is called once per frame. We don’t have to use these functions in every script, so we can either delete them or leave them empty.

To scale down the frog when we click on the Scale button, we will make a new function, public void ScaleDown(){}, so we can call this function when we click on the Scale button.

Save the script file and return to Unity to call the function and run the game. Select the button GameObject from the Hierarchy. You will find the OnClick() list in the button component in the inspector as shown in the image below. Click “+” and add the function we just created in the script. Since the script is attached to the button itself, drag and drop the button GameObject from Hierarchy to the empty GameObject area and select the “ScaleDown()” function from the drop down menu.

Time to run our game. Click the play button.

When we run the game, any changes made while in game mode cannot be saved, and when you exit game mode, everything returns to the state it was in prior to running (keep this in mind).

Now let’s click on the “Scale” button and see what happens to the frog.

(Before clicking on the scale button)

(After clicking on the scale button)

As you can see, the frog is smaller — and if you check the inspector, the scale values are now 0.2. Once you stop the game, the values will return to their originals.

If you made it this far — congratulations. You have made a functioning micro game!

Monitoring our games for errors & performance issues

Whenever we develop a game so popular that it’s played by thousands of gamers, we’ll want to make sure we’re monitoring for errors and performance issues our users may experience so we can quickly resolve them. A tool like Sentry can help us with this.

Implementing Sentry

Getting started is easy. Signup, and select “Unity” as the platform you’d like to setup.

Create a new project in Sentry and give it a name. You can associate projects with certain teams, which is useful for large organizations.

Once your project is created, you will find the steps to install the package, configure your DSN, and call the Unity SDK.

We can open the package manager in Unity by clicking Window > Package Manager.

Click the ”+” sign and then “Add package from git URL…“.

Paste this URL into the input field:

https://github.com/getsentry/unity.git#0.10.1

You can get the latest URL from the “Install” section in Sentry’s docs (https://docs.sentry.io/platforms/unity/). This will install the package.

We’ll need to add our DSN by clicking on Tools > Sentry.

To find the DSN to your project.

If you are signed in, the Unity Sentry documentation will have the DSN to your project here https://docs.sentry.io/platforms/unity.

You can get the DSN for your project within Sentry’s platform.

Go to your Projects page > Click on your current project > Settings > Client Keys (DSN).

Tracking errors

To track an error in Sentry, we need to trigger an intentional one. Let’s make a spelling mistake in our frog name and check if Unity will find the frog GameObject.

As seen below, we triggered a Null exception error as there is no GameObject called “Frog”.

Now let’s run the game one more time and see how Sentry tracked the error.

We have a new, unhandled issue to resolve. Once we handle this exception, we can click “Resolve”. (I’ll write more about what else we can do to monitor Unity errors in Sentry in a future post).

Monitoring performance

A laggy game is a sure way to make someone stop playing. In addition to catching errors, it’s also important to monitor slowdowns or crashes in our game. We can get started by clicking “Performance” within Sentry.

“Start setup” and then select the Unity SDK from the list of supported SDKs.

Back in the Unity editor, navigate to Tools > Sentry > then change the “Traces Sample Rate” to a value between 0 and 1, as shown in the image below. Inputting “1” will send 100% of transactions to Sentry.

We can open our “Scale” C# script to capture transactions for Sentry to monitor our project’s performance. We set this up by adding the code below:

Now we can run the game and check the performance page in Sentry. You can toggle between projects, environments, and the time duration for the transactions you’re monitoring.

We can look at all transactions, or filter to only look at web vitals, frontend, backend, and/or mobile transactions.

For example, here, the All Transactions tab is open where we can see a handful of performance metrics (more details
here including User Misery, which is the number of users who experience a load time 4x the company response time threshold of 300ms).

Conclusion

Thank you for reading and I hope you have a basic understanding of the Unity Platform as well as Sentry’s application monitoring platform. Stay tuned for more Unity articles as we build on our foundational knowledge.