Game Development Notes

C# in Depth

2023-11-08T00:00:00+00:00

Today we are going to talk about the best book for people who study C#, we are going to review its pros and cons and with this you will be able to know if this book is for you.

C# in Depth is the most recommended book for people looking to learn C#, it is written by Jon Skeet, who for several years has been the Stack Overflow user with the highest score due to his answers to questions related to C#, .Net, .Net core and similar technologies.

I had tried to read it other times but couldn’t finish it, this last time I decided to read it in its entirety, and after the first chapters I realized what the tone of the book was.

As the name implies, it is an in-depth exploration of the C# language, the name can be a little confusing, the book is not about learning C# from start to finish, it is more of a historical explanation from C# 1.0 to making certain bets on What will be the new features of C# 8.

It should be noted that I still think the book is quite good, but I decided to do this review as a reference to other people about whether it is a suitable book for you.

The target audience for this book are people who already have knowledge about the development of C# and who have participated in several projects with this language. However, they are not content with knowing how to handle the implementation of the language and seek to know what the compiler does behind the scenes and how it interacts with the platform at a low level.

It will also help the reader to put the new features of the language in each installment into context and will explain what problems they solve at the language level. It is worth clarifying that not many specific examples will be given of where to implement them, it is more an explanation of what the need of the language at that point in history was and what problem adding a particular feature solves.

The book has 470 pages and an appendix in which it specifies which features appear in which version. It touches on several topics in depth about why it was decided to integrate such a function into the language, but from a point of view that is too academic in my opinion. There are times when you can see the author talking about the low-level implementation in great detail, only to comment at the end of the chapter that they will probably never have to use something like this, or that in general implementations of this type are not used in code of production.

Personally, although I thought that the book had good points, and it clarified some doubts about some concepts that I had read in code or in the C# documentation at some point but that were not completely clear to me and therefore I didn’t use them so much, those concepts helped me lose my fear of them and try to implement them in my own code when necessary.

On the other hand, I do not consider myself an academic programmer, and although I like the C# language, knowing how it works at a low level has never been of my interest, since at the moment I do not feel at a professional level in the that I could contribute to the language repository to extend it, and I am more interested in the implementation and what problems it solves under what circumstances, I am more interested in knowing the context of a feature and how it is applied and why it is applied in this or that way.

C# in depth takes a different approach, it will present you with a feature, give you the context of what problem it solves at the code level without a real example, and then explain how memory is managed at a low level with translated examples on how does the compter interprets the C# implementation. I think that my personal impression is not the fault of the book, I feel that the material on which it works is good and the explanations given are quite clear, sometimes overwhelming due to the level of detail it handles, but in general I feel that C# in depth is not a book for me or for the way I am used to work.

I was interested in delving into the C# language since I want to professionalize my career and one of the main recommendations for C# books was always C# in depth by Jon Skeet, now, once I have read it I can say that it is not a book for me, I will follow it fondly and will probably review it as a reference, but for implementation issues I think that the official Microsoft documentation is still the most practical way to explore any C# topic.

But if you are not like me, if you are a person who works in academia, if you are interested in compilers or you are creating your own compiler, this book is definitely for you, it is fresh, the way it is written is very casual in the explanations and deep into the context of the decisions and gives you advice and a unique view on what to expect at the machine level about the code that is being executed.

Points in its favor:

These topics are very well explained: Generics, Delegates, Anonymous Types, Lambda expressions, Extension Methods, Asynchronous code (Async/Await), Tuples.

If you have any questions about how to implement any of these topics, I recommend this book, Jon Skeet gives an excellent explanation of them.

Topics I hoped would be better explained: LINQ

There is an entire chapter dedicated to LINQ, and I was waiting to read it because I have seen it in several of my projects that I collaborate on and in general as an answer to various StackOverflow issues. I have worked with LINQ but I always felt that I didn’t really understand what was happening in very long queries or perhaps I was implementing them inappropriately, so, upon picking up a book called “C# in depth” with an entire chapter dedicated to LINQ, I thought it was a great opportunity to master the subject.

However, the way the topic is approached is to talk about each part that uses LINQ separately (Implicit typing, Object and collection Initializers, Anonymous types, Lambda expressions, Extension methods, Query expressions) and then a brief explanation of how each component is related in the LINQ implementation.

I would have liked to see more exploration of LINQ implementations and a better explanation of the different combinations of queries that can be used, but they are only superficially reviewed.

Then the book moves on to the next topics and leaves LINQ aside, and I would like to emphasize that it is not the book’s fault, it is my fault for expecting something from a book that I didn’t know if it was going to be focused on my needs, so I blame myself.

In conclusion, this book is focused on a very particular type of programmers, but I am not a part of that type of programmers.

If you really like to delve into the implementations of programming languages, if you have thought about making your own programming language or you like to create your own compilers, yes. Totally recommended.

If you are a programmer looking for solutions to real problems and are looking to deepen your knowledge… I would also recommend it, just give yourself some time to read it between chapters, or use it as guide material for an interview, or reference material on specific topics, You definitely won’t find the entire book useful, but there are some excellent gems and explanations within the book that are highly recommended.

I would like to clarify that it is not my intention to be harsh with the book, nor do I want to imply that programmers who focus on results are superficial, in the world of software development there are many ways to solve the same problem and we all learn differently. different, don’t get discouraged and keep learning.

C# in depth by Jon Skeet, is a great book, if you are using C# in your work or projects you will most likely learn several things from it.

Update vs. FixedUpdate vs. LateUpdate in Unity

2022-10-12T00:00:00+00:00

Originally posted on LogRocket on October 12,2022

In Unity, the way a game is presented to the player is everything. Both the smoothness of the controls and the gameplay they are experiencing are key, and knowing how this information is shown to the player will give you an advantage in the way you approach your Unity projects.

For that reason, we’re going to be discussing update functions, learning their implementations, and deciding when to use each.

What is a frame in Unity?

You can imagine a frame as a picture, and if you have multiple similar pictures showing rapidly, you can create the illusion of movement.

A frame is a term inherited from animation, where some common values are 24, 30, and 60 frames per second (FPS). When it comes to games, we say that “it’s running at 60 FPS” when there are 60 new images in a second presented to the player. This is called frame rate, and frame interval is the time that happens between each frame.

In our example of 60 FPS, 60 would be the frame rate, and frame interval would be 1/60 x 1000 = 16.67 milliseconds.

In Unity, a frame is considered a rendered image presented to the player’s screen. Generally speaking, Unity doesn’t care about time, but it does about frames with its property Time.DeltaTime that calculates time between frames.

If for some reason, like having heavy processing during gameplay, time between frames slows down, this drops the frame rate and gives the sensation to the player that the game is running slowly.

Explaining the update functions

During the lifetime of a script, Unity executes its functions in a specific order. You can read more about the execution order here, but to keep this article simple, we will be focusing on two stages: physics and game logic.

During each frame, Unity executes in order all the event functions of the active scripts.

It will first execute the physics simulation logic, calling FixedUpdate first, then the rest of the physics events.

Then it will check for Input events from the user.

Finally, during the game logic, it will execute the Update function, all the game logic functions, and finally LateUpdate.

It’s important to note that each event is executed in the same order across all the scripts on Unity, so if you have ten scripts that use FixedUpdate, those will have higher execution priority than other ten scripts that have code in their Update method; same thing with LateUpdate with the lower priority in the order for this example.

Update functions order

Here we can see the order of these functions: we would create an empty object in a new Unity scene and attach this script to it.

In this script, we will print out to the console the order of the functions that gets executed. We have set up three flags called continueUpdate, continueFixedUpdate, and continueLateUpdate to prevent our functions from executing the same code multiple times and filling the console with unnecessary results:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UpdateOrder : MonoBehaviour
{
   bool continueUpdate=true;
   bool continueFixedUpdate=true;
   bool continueLateUpdate=true;

   // Start is called before the first frame update
   void Start()
   {
       Debug.Log("Start");
   }
   // Awake is called when the object is enabled
   void Awake()
   {
       Debug.Log("Awake");
   }

   //FixedUpdate is called before Update, at the same rate based on Delta Time
   void FixedUpdate()
   {
       if(continueFixedUpdate)
       {
           Debug.Log("Fixed Update");
           continueFixedUpdate=false;
       }
   }

   // Update is called once per frame
   void Update()
   {
       if(continueUpdate)
       {
           Debug.Log("Update");
           continueUpdate=false;
       }
   }
   //Late Update is called after update
   void LateUpdate()
   {
       if(continueLateUpdate)
       {
           Debug.Log("Late Update");
           continueLateUpdate=false;
       }
   }
}

The output will be something like this:

Awake gets called first since the GameObject was active, then Start, then FixedUpdate, Update, and finally LateUpdate.

FixedUpdate

FixedUpdate is usually used for physics calculations since it has the same frequency as the physics system: by default it executes every 0.02 seconds (50 times per second), but you can double-check it with Time.fixedDeltaTime.

You can also change the frequency of FixedUpdate in Unity by going to Edit > Project Settings > Time > Fixed Timestep.

Update

Update is a function that gets called every frame if the MonoBehaviour is enabled.

If the frame rate is 60 FPS, it will execute 60 times a second; if it’s 30, it will be 30 times a second.

If the script gets disabled (i.e., enabled=false), it will stop.

LateUpdate

Like Update, LateUpdate executes every frame if the MonoBehaviour is enabled, and it will stop if it’s disabled.

It will execute after all the update functions are called, and it’s recommended to use LateUpdate on camera scripts instead of Update since it can keep track of objects that have already been moved in an Update function.

Please keep in mind that the order of execution between Update and LateUpdate has nothing to do with speed. Update is not faster than LateUpdate; they are executed in different order to do different stuff. While Update might be used to move objects in a time interval, we would use LateUpdate to reflect the results after those objects have been moved, and it’s safe to assume that they are in a new state.

Where to use each update function

FixedUpdate

It’s recommended to use FixedUpdate when dealing with physics, like Rigidbodies updates.

In the following example, we added three cubes with a Rigidbody each.

What the script does in each case is that it takes a reference of the Rigidbody of each cube and applies a force upwards in the object they are attached to. The only difference between them is the type of update function they use.

The cube on the left has this script; it will be using FixedUpdate:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FixedUpdateRigidBody : MonoBehaviour
{
   public Rigidbody rb;
   // Start is called before the first frame update
   void Start()
   {
       rb = GetComponent<Rigidbody>();
   }

   //Is executed based on the Fixed Timestep (by default 50 times per second)
   void FixedUpdate()
   {
       rb.AddForce(10.0f * Vector3.up);
   }
}

The cube in the center will be using this one, using Update:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UpdateRigidBody : MonoBehaviour
{
   public Rigidbody rb;
   // Start is called before the first frame update
   void Start()
   {
       rb = GetComponent<Rigidbody>();
   }

   //Is executed every frame
   void Update()
   {
       rb.AddForce(10.0f * Vector3.up);
   }
}

And the cube on the right will be using this script, calling LateUpdate:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class LateUpdateRigidBody : MonoBehaviour
{
   public Rigidbody rb;
   // Start is called before the first frame update
   void Start()
   {
       rb = GetComponent<Rigidbody>();
   }

   //Is executed every frame after Update
   void LateUpdate()
   {
       rb.AddForce(10.0f * Vector3.up);
   }
}

From left to right, FixedUpdate, Update, LateUpdate

You can see a clear representation on how each update function works. FixedUpdate will be executed once every time step is settled in Unity; that is why the movement is constant and steady.

On the other hand, the cube in the center is using the Update function every frame, so each time the function is called to apply force upward, and since each frame is more frequent than the time step of FixedUpdate, you can see that it goes up way faster. This is because it’s being called many times more than the cube on the left.

And in the case of the third cube that is using the LateUpdate function, it is being executed each frame too, but after the Update function due the order of execution discussed above.

Please note that to the human eye, the difference between executing code in the Update function and LateUpdate function is pretty much the same. You couldn’t tell which cube is using the Update or LateUpdate function.

Update

Update is called every frame, so if you need to read the input of the player, this is the perfect function to handle it so you don’t miss any event.

LateUpdate

LateUpdate executes after all the Updates functions have been called. This is relevant because the order of execution on Update might be a little chaotic, and you can’t be sure which script will be executed within all your scripts that execute Update.

However, with LateUpdate, you can be sure that you will call this function after all the states changed with Update take place, so you can work with the final results of your objects.

It’s recommended to use LateUpade when following objects with the camera and updating the UI for the players.

Final thoughts

There are two main concepts you could take from this article. For one, there is an order of execution that goes: Update is executed each frame; FixedUpdate is executed at a specific rate defined in the editor; and LateUpdate is executed after all the Update functions have been called.

And the second one is that this order is not based on each script; it’s based on your whole project, meaning that all the Update events will execute at the same time, and after those are finished, LateUpdate will execute. Because of this, one FixedUpdate function could be called at the same time the other two are called, so try your best to order your functions and ideas before executing everything at the same time.

You should be aware that the states of your objects and positions could be changed during those events and plan ahead for the best approach to have the most stable experience for your players.

I hope this article has been useful to you. Happy gamedev!

How to use streaming assets in Unity

2022-08-24T00:00:00+00:00

Originally posted on LogRocket on August 24,2022

An asset can be any resource in Unity; those resources can be images, audio, video, scripts, text, etc.

When building a Unity project to any platform, all the assets in your game will be “packaged” in a file (or more depending on your platform), and the resulting size of the build will depend on the size of the assets you decided to package within your game.

It’s not the same to create a game with multiple HD textures rather than using a Map Atlas, or using video on 240p rather than using 1080p. It’s expected that the greater the size of your assets, the greater the size of your final build.

In general, it’s a good practice to keep your build as lightweight as you can, so the player won’t be discouraged from downloading your game due to the size, and your scenes will run considerably faster.

There are multiple tips and tricks to achieve this, and in this article we will be talking about some of them, starting with streaming assets.

What are streaming assets?

Let’s say you have a nice scene in your game where all the action happens. The player is the enemy base, and in a specific room, you decide to put a video playing on a computer as an easter egg.

The video is really big, like more than 300MB, and the player might or might not enter that specific room to actually see it. Would it be ok to load it in your scene by default? That might cause unnecessary slowness in your great scene. So it could be great to just load it when we actually need it.

A streaming asset it just that: an asset placed in a specific folder that would be loaded by the Unity Player when needed. That asset will be placed in an easy to find address within the target platform.

Please note that any asset placed on a streaming asset folder (named StreamingAssets within Unity) will be copied into the target platform, and if a user searches within the project folder it will be able to see them.

This is how some of the mods of some games are made.

Changing the texture of a character? Go into the data folder and find the used texture, then modify it. Changing the voice lines of a tough boss? Just go to the data folder and find the audio track and replace it with another with the same name.

Streaming assets let the game run smoothly without loading all the assets from memory and serve the bigger ones in an easy to reach path.

Let’s build an easy example of streaming assets

We are going to show how streaming assets work with an easy example by showing a video in your game.

I downloaded a preview of a video from iStockPhoto for this example.

Make sure the video you want to use has one of the following extensions: .mov, .mpeg, .mp4, .avi, .asf.

For our initial example, we are going to create a new folder called Video and place our video inside that folder:

Then, on our Hierarchy panel, we are going to set up our video player.

Right-click on your Hierarchy and add an Empty Game Object. I called mine VideoObject.

Inside of it, I created a cube where we are going to play the video; it can be any shape you want, but I chose a cube for convenience. I call it Video_Canvas.

And at the same level of Video_Canvas, inside VideoObject, I added a new Video Player object by right-clicking VideoObject and selecting Video, then Video Player.

Here is how I set up our Video Player object:

We set the Source as a Video Clip, and then we selected the video clip from our Video Folder that we created, then we selected Loop so the video would keep playing infinitely.

Then, select Render Mode as Material Override and drag and drop the Object you want to play the video on — in our case, the Video_Canvas cube. Let Material Property be _MainTex.

If you click on Play in the Unity Editor, you will see something like this: a video being played on each side of the cube.

You could also create a plane or reduce the scale of the cube to the shape you want if you want a flatter surface, like a screen.

This demo video is 3.5MB.

If we build this project for a standalone platform (Windows, Linux, MacOs) we will see that a blank project with a video it’s 87.6MB.

Now, let’s see how it looks using the same video as a streaming asset.

To do so, we are going to create a new folder called StreamingAssets in the Assets folder; this is a special named folder that will treat our video file video_streamingAssets as a regular file with no options in the properties window of the editor.

Then in our Video Player object, we could change the Source of the Video Player Game Component to URL and leave the actual URL alone. We will create a new Script called LoadVideo and attach it to our Video Player GameObject like in the image.

This script takes as a parameter a Video Player, so we will drag and drop our same Video Player that this script it’s attached to.

Here’s the script of LoadVideo:

using UnityEngine;
using UnityEngine.Video;

public class LoadVideo : MonoBehaviour
{
   public VideoPlayer myVideoPlayer;
   void Start()
   {
       string videoUrl= Application.streamingAssetsPath +"/"+ "video_streamingAssets" + ".mp4";
       myVideoPlayer.url = videoUrl;
   }
}

Basically, at the start of the application it will use Application.streamingAssetsPath to get the path of the StreamingAssets folder in any target platform that has been built into. And then it will reference the name of our video in that folder and its extension.

Then, it will take myVideoPlayer (that already has the reference of our scene video player) and it will write its url property with the path of our video.

This will result in the same cube with the playing video.

Now, if we build this project, we will see that it has the same size as our previous example, but with one major difference.

If we see the Package contents of this build, we can see that on Contents/Resources/Data there is our StreamingAssets folder with our video.

And if we replace the video in our StreamingAssets folder with another of the same name, we wouldn’t need to build our project again in order to see the changes reflected in our game.

Now that we know how we can detach our assets/content from our build. We could also call remote files from the URL on our Video Player. For doing so, we are going to use this video as example. It’s almost 10 minutes long and it’s about 151MB.

If we change our code to:

using UnityEngine;
using UnityEngine.Video;

public class LoadVideo : MonoBehaviour
{
   public VideoPlayer myVideoPlayer;
   void Start()
   {
       string videoUrl= "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4";
       myVideoPlayer.url = videoUrl;
   }
}

…and delete our original video of the StreamingAssets folder, we end up with something like this:

The same functionality, but now the video assets come from an external source.

Now if we build our project without the local video in our StreamingAssets folder, we would see a decrease in the size of our build.

Please keep in mind that this could also be done with an async call or a UnityWebRequest call and a coroutine, but for simplicity, we just add the exact URL of a video to demonstrate the power of streaming assets.

Using a coroutine to fetch a video from an external source

We can modify our LoadingScript like this in order to use a coroutine instead of passing the direct link to our video player:

using UnityEngine;
using UnityEngine.Video;
using UnityEngine.Networking;
using System.Collections;

public class LoadVideo : MonoBehaviour
{
   public VideoPlayer myVideoPlayer;
   void Start()
   {
       StartCoroutine(LoadExternalVideo("http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4"));
   }

     IEnumerator LoadExternalVideo(string url){
      using (UnityWebRequest request = UnityWebRequest.Get(url))
      {
          //Fetches a page and displays the number of characters of the response.
          yield return request.SendWebRequest();
          myVideoPlayer.url = request.url;
      }
  }
}

With this example, we could use a coroutine to consume an API endpoint and retrieve the URL of the video, but for simplicity, this is a simple example on how to do it with an external link.

The result will be very similar; we just need to make sure that our UnityWebRequest result is retrieved from the consumed endpoint and make sure that the URL of a video is present before setting it up to the URL property of the video player.

Final thoughts

Streaming assets are just one of the different ways Unity handles assets for your game. It works great when you are trying to get your player base involved by allowing them to mod your game, or if you want to have a lightweight final build of your game, and then upon first launch, download the rest of the assets of your game before the the player takes notice.

There are many online games that do this approach: their games are very light, you can finish up a little tutorial of the first level, and then you will get a loading screen that downloads the rest of the assets.

You have to keep in mind the best approach for your game. You can’t have all your assets in a remote server, because what would it happen if the first time the player plays your game their device doesn’t have a good internet connection? What would your game look like without assets?

One of the best approaches is having a very light version of your assets as default (like materials, textures, images) as a placeholder, and when you are sure that your player will enjoy that content and the device is ready to download that info, do so as seamlessly as possible.

I hope you have liked this article and find it useful! Happy gamedev!

Using coroutines in Unity

2022-06-30T00:00:00+00:00

Originally posted on LogRocket on June 30,2022

As your Unity project grows, there will be a need to create more complex logic. You might need to load different resources or prepare time-sensitive scenes. Ultimately, we want players to have the most seamless experience without breaking their immersion.

With coroutines, you can use various approaches to achieve this. In this tutorial, we will go over different uses of coroutines and when to use them.

What are coroutines?

Unity uses frames as a way to represent time. Normal methods will execute in one frame and move into the next instruction.

Coroutines can be used to execute a piece of code across multiple frames. They can also be used to keep executing a section of code until you tell it to stop. A coroutine contains a yield instruction that will wait a certain amount of time you tell it to.

When to use coroutines

Let’s say you want to use a normal call method with a for loop to fill a health bar from 1–100 HP. The player will see a full health bar at the end of your method. That’s because the time it takes the method to count to 100 is faster than a frame on Unity, and is also faster than your players’ eyes.

This is a good example of when to use coroutines. You’d tell the coroutine to fill 1 HP, wait a fraction of a second, and do it again until we reach the full 100 HP.

This way, your players will watch the health bar fill up smoothly over time.

using System.Collections;
using UnityEngine;

public class HealthBar : MonoBehaviour
{
   int maxHP=100;
   int currentHP=0;


   void Start()
   {
       Debug.Log("Start Increasing Health");
       StartCoroutine(HealthIncrease());
       Debug.Log("Finish start event");
   }

   IEnumerator HealthIncrease(){
       Debug.Log("Start Coroutine");
       for(int x=1; x<=maxHP;x++){
           currentHP=x;
           //Increase or decrease the parameter of WaitForSeconds
           //to test different speeds.
           yield return new WaitForSeconds(0.2f);
           Debug.Log("HP: "+currentHP+" / "+maxHP);
       }
       Debug.Log("Current health is "+maxHP);
       Debug.Log("End Coroutine");
   }
}

Another potential use case could be if a player is being hit by an object and you want to add a few seconds when nothing else can hit them. This will create temporary invincibility to avoid an unjust game experience.

In pseudocode, we would end up with something like this: when an object hits the player, deactivate the player hitbox for two seconds and then activate it again.

An example of a coroutine

coroutine is a method from MonoBehavior that has an IEnumerator return type. To

invoke and start using it, you should use the StartCoroutine method and pass your coroutine method and parameters if needed.

On a coroutine, the yield return is when your code pauses for the next frame and continues afterward. If you don’t need your coroutine to wait, you can use WaitForSeconds (or any other yield instruction), as well as null.

using System.Collections;
using UnityEngine;

public class Coroutines : MonoBehaviour
{
   void Start(){
       Debug.Log("Begin Start event");
       StartCoroutine(WaitCoroutine(2f));
       Debug.Log("End Start event");
   }

   private IEnumerator WaitCoroutine(float time){
       Debug.Log("Inside coroutine");
       yield return new WaitForSeconds(time);
       Debug.Log("Finish coroutine after "+time+" seconds");
   }
}

The example above will print:

Begin Start event
Inside coroutine
End Start event

It will wait for two seconds, and will print:

Finish coroutine after 2 seconds

Implementing a coroutine that never stops

You can also declare an IEnumerator variable and reference it with your coroutine to invoke it.

In the example below, since the while loop will always be true, the coroutine will continue executing after waiting for two seconds.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class InfiniteLoopCoroutine : MonoBehaviour
{
   IEnumerator myCouroutine;

   void Start(){
       myCouroutine= InfiniteLoop(2f);
       StartCoroutine(myCouroutine);
   }

   IEnumerator InfiniteLoop(float seconds){
       while(true){
           yield return new WaitForSeconds(seconds);
           Debug.Log("Inside infiniteLoop");
       }
   }
}

Please note that WaitForSeconds uses a float parameter divided by Time.timeScale. We do this so we can mimic a real second on the game’s device.

How to stop a coroutine

Now we have a coroutine that has an infinite loop. But how do we make it stop?

You can stop a running coroutine with the StopCoroutine method, which will accept either of the following as a parameter:

A string with the name of the coroutine
An IEnumerator reference of your coroutine

So, in the previous example, we could do:

StopCoroutine("InfiniteLoop");

or…

StopCoroutine(myCoroutine);

A coroutine will also stop if the object that it’s attached to is disabled by SetActive(false) or by destroying the object with Destroy().

The following example will stop the coroutine when the player presses the Space key.

using System.Collections;
using UnityEngine;

public class InfiniteLoopCoroutine : MonoBehaviour
{
   IEnumerator myCouroutine;

   void Start(){
       myCouroutine= InfiniteLoop(2f);
       StartCoroutine(myCouroutine);
   }

   IEnumerator InfiniteLoop(float seconds){
       while(true){
           yield return new WaitForSeconds(seconds);
           Debug.Log("Inside infiniteLoop");
       }
   }

   void Update(){
       if (Input.GetKeyDown(KeyCode.Space))
       {
           StopCoroutine("InfiniteLoop");
           Debug.Log("Coroutine stopped");
       }
   }
}

Pausing games with coroutines

A popular way of pausing a game in Unity is by setting Time.timeScale equal to 0. This sets the property that Unity uses to measure time based on the device running the game.

Keep in mind that this is all in a game/unity project environment, so it’s not equivalent to the time in the real world.

When Time.timeScale is set to 0, the game pauses and the Update method is no longer being executed in each frame. Every animation being executed is stopped and every moving object that was using timescale stops in place.

For coroutines, this is a little different.

If you are executing a coroutine in a loop and it’s still going when Time.timeScale is set to 0, the coroutine will keep going but WaitForSeconds will not.

WaitForSeconds uses Time.timeScale to know what a real second is. In this case, it will behave properly, but the rest of the code in the coroutine will continue executing.

using System.Collections;
using UnityEngine;

public class TimeStop : MonoBehaviour
{
   // Start is called before the first frame update
   void Start()
   {
       StartCoroutine(PrintEverySecond());
   }

   // Update is called once per frame
   void Update()
   {
       if(Input.GetKeyDown(KeyCode.Space)){
           if(Time.timeScale==1.0){
               Debug.Log("Time Stop");
               Time.timeScale=0.0f;
               StartCoroutine(PrintOnStop()); //We start a new coroutine after stopping time.
           }else{
               Debug.Log("Time Continue");
               Time.timeScale=1.0f;
           }
       }
   }

   IEnumerator PrintEverySecond(){
       while(true){
           yield return new WaitForSeconds(1.0f);
           Debug.Log("Inside Coroutine");
       }
   }

   IEnumerator PrintOnStop(){
       for(int x=0;x<=10;x++){
           Debug.Log("Time is stopped but I'm still running "+x);
       }
       yield return null;
   }
}

Please keep in mind that you can stop a coroutine with StopCoroutine before pausing the game to prevent unexpected behavior.

You can also stop all coroutines at the same time! We’ll go over this in the next section.

Using multiple coroutines and stopping them all at once

As you know, you can execute multiple coroutines that behave differently at the same time. They can be stopped all at once by the StopAllCoroutines() method.

using System.Collections;
using UnityEngine;

public class MultipleCoroutines : MonoBehaviour
{
   void Start()
   {
       //You can use multiple coroutines at the same time,
       //even on the same definition.
       //Each one will behave individually.
       StartCoroutine(MyCoroutine(1f));
       StartCoroutine(MyCoroutine(3f));
       StartCoroutine(MyCoroutine(5f));
   }

   void Update(){
       //If you hit space at runtime, all the coroutines will stop
       if(Input.GetKeyDown(KeyCode.Space)){
           StopAllCoroutines();
           Debug.Log("All coroutines stopped");
       }
   }

   IEnumerator MyCoroutine(float sec){
       while(true){
           yield return new WaitForSeconds(sec);
           Debug.Log("I'm on a loop that prints every "+sec+" seconds");
       }
   }
}

StopAllCoroutines() doesn’t take a parameter for stopping all the coroutines in the game at the same time.

Coroutines vs. threads

Keep in mind that coroutines are not threads. Any synchronous code executed in a coroutine will be on the main thread.

If you want to use threads for consuming an HTTP request, for example, you can use async methods.

Here’s an example of consuming an HTTP request using coroutines:

using System.Collections;
using UnityEngine.Networking;
using UnityEngine;

public class HTTP_Request_Example : MonoBehaviour
{
   void Start()
   {
       //Consume an HTTP request with a coroutine
       //It happens on the main thread, which might cause the UI
       //to be unresponsive for a bit
       StartCoroutine(MyRequest("www.google.com"));
   }

   IEnumerator MyRequest(string url){
       using (UnityWebRequest request = UnityWebRequest.Get(url))
       {
           //Fetches a page and displays the number of characters of the response.
           yield return request.SendWebRequest();
           Debug.Log("Page length: "+request.downloadHandler.text.Length);
       }
   }
}

Although there are a lot of examples of this approach, it’s not ideal for this kind of situation when you don’t have full control of the time responses of these external APIs.

Here’s the same example using an asynchronous method instead:

using System.Collections;
using UnityEngine.Networking;
using UnityEngine;
using System.Threading.Tasks;
using System.Runtime.CompilerServices;

//By default, UnityWebRequest is not async, so you will need this extension
//Credit goes to: https://gist.github.com/mattyellen/d63f1f557d08f7254345bff77bfdc8b3
public static class ExtensionMethods
{
   public static TaskAwaiter GetAwaiter(this AsyncOperation asyncOp)
   {
       var tcs = new TaskCompletionSource<object>();
       asyncOp.completed += obj => { tcs.SetResult(null); };
       return ((Task)tcs.Task).GetAwaiter();
   }
}

public class HTTP_Request_Async_Example : MonoBehaviour
{
   void Start()
   {
       //Invoke a new thread when the web request will happen without blocking the UI
       ConsumeWebRequest();
   }

   async void ConsumeWebRequest(){
       Debug.Log(await MyRequest("www.google.com"));
   }

   async Task<string> MyRequest(string url){
       using (UnityWebRequest request = UnityWebRequest.Get(url))
       {
           //Fetches a page and displays the number of characters of the response.
           await request.SendWebRequest();
           string response = "Page length: "+request.downloadHandler.text.Length;
           return response;
       }
   }
}

Out of the box, Unity uses its own networking package called UnityEngine.Networking.

By default, this package is not asynchronous. If you use it inside of a coroutine, it could potentially lock the main thread of your app, resulting in some unexpected behavior.

The second example will use its own thread and leave the main thread free for the player. The game will feel like it’s running as smoothly as ever!

Additional thoughts

Coroutines are very resource-efficient, so don’t be afraid of trying them out. If you end up in a situation where you have too many coroutines at the same time, you might need to double-check your design for solutions. Two or three coroutines in the same objects that really need them could be enough.

There are a lot of examples of using coroutines with WebRequest out there, but, in general, if you have to consume external resources that your project can’t control (like the time it takes a server to answer your request), it’s a good idea to use asynchronous methods instead of coroutines. This is because coroutines execute synchronous code and might use the main thread, resulting in a bad experience for your players.

I’m not saying that async/ await are better than coroutines in Unity, they both are great tools. It really depends on your design and choices about when and where to use them. A general rule of thumb could be that for internal processes, use coroutine and for external processes, use asynchronous methods.

Conclusion

Coroutines are a great tool to have on your belt. They can help you set up the level for your players in front of their eyes, make smooth transitions between events, or create new functionality for you to impress your players.

I hope you found this article useful and liked reading it as much as I enjoyed writing it!

Happy gamedev!

How I got into the Game Industry

2022-05-13T00:00:00+00:00

Hello, my name is Uriel, I’m a .Net Developer that recently changed jobs from Custom/Enterprise software development into Video Games after 9 years. This is how I did it.

Disclaimer: This is all from my perspective working 10 years as a Full Stack Developer in Mexico, then applying for Game Development jobs, and finally getting into a game company in Sweden.

A little background

I got into software development because I really liked computers, and most of all, I really love video games, I thought that if I got into software development I could end up making games someday.

The video game industry is hard, so unless a large AAA company in your country is accepting students or internship regularly, or you have the time/resources to fund your own games and are totally OK with not making any profits for awhile, it’s going to be difficult to break into the game industry, simply right after learning how to program.

So during college and after that I worked as a Software developer doing pretty much everything needed, so my skills were pivoting into Enterprise software development and my tech stack was C#, MS SQL Server and ReactJS, I ended up as a full stack developer.

During those times, I really wanted to make games, so I kept my day job as a web dev, and in my spare time, I started making my own games as a hobby.

It was great! I was using the skills that I learned during the day to do the actual stuff that I wanted to make during the night, I would come up with an idea for a small game and I would continue working on it until it was “good enough” to ship it to the Play Store.

Creating a portfolio

The hard truth is that if you want to work on games as a Software developer, you have to make games, there is no other way around it. So the best way to do it is making small games from start to finish. Ship those games and make it very accessible so others to play those games and give you feedback about it.

If you are saying you have experience making games, your best shot is to prove it having a portfolio where you have an easily accessible way of showing up the games you have worked on. Those games can be very small, like the ones you make on game jams, they can be very ugly, they can use placeholder art, the most important thing about those games is that the games are finished. Showing something complete is way better that showing something as a concept.

This of course doesn’t mean you can’t show a vertical slice of a game idea you have, those are totally great too!

Basically, what recruiters want to see on your portfolio is that you do what you say you can do.

Applying to Jobs

Once I got a portfolio I was comfortable with I started applying for a jobs in the game industry.

There are a lot of job boards with tons of opportunities online (Work with indies, Video Game Industry Jobs, Games Jobs Direct, LinkedIn), so make sure to check them out and see who they are hiring right now and where you could be a good fit, or what areas you should explore before applying for those opportunities.

A word of advice here, so you don’t make the same mistake I was making:

When I start applying for Game Dev jobs, I had experience working on Unity so I was applying for positions that used Unity like “Game Developer”, “Game Designer”, etc, all of this is very valid and you totally should bring it up if that’s your case too during an interview, but in order to work on those positions, it’s expected that you have some knowledge working in another studio full time in a professional manner. That wasn’t my case, all my game projects were made as a hobby on the side.

So your best chance of getting into an interview is looking into the open positions of the game studio you are aiming to get in, and see which position you could be filling translating your current experience with what they are looking for so you can be a better match for them.

This is not to discourage you, but it’s the easiest way to get you in, since as any industry, they are looking for people that can be building software in the shortest amount of time possible.

What I was looking for?

I’m acknowledging that I am privileged, I had a steady job in a great company doing web/power platform development and since I have a wife and a kid to take care of, It would be irresponsible for me to quit my day job and getting into indie game dev or taking the first opportunity that I could.

When I was looking for a job in games, I was looking for positions that had:

A promising career path.
Tech that I if learned it, It could be translated into other industries (something not super niche).
Greats benefits for me and my family, better that the ones I already had, this one was non-negotiable for me.
A great work environment and life/work balance.
Remote from Mexico or with relocation to a 1st world country that is not the United States.

Getting rejected, learn from it, try again

I knew that changing careers wouldn’t be easy, so I prepared for it and made myself a promise that I would get 100 rejections before quitting (and try again later), so between 2020 and 2021 I was applying to Game dev jobs if something was looking promising. I probably sent more than 100 applications, but I heard back with a negative response at least 70 times.

I really appreciate the feedback that I got, and even the times that it was an automatic message, having that closure was great, so I wouldn’t be worried that my application was still being reviewed or something.

Having feedback is great because it let you know where you can improve, I was tweaking my resume and portfolio according to the feedback I was receiving, and also I was studying more in the areas that I was having trouble during the interviews.

There is no way around it, you have to apply for jobs, get rejected, adjust your strategy and try again until you are done.

Turn yourself into the best candidate you can be

With rejections and feedback you can plan ahead your next move, for me, it was something like “I need to prove that I know what I’m talking about, even if I haven’t work in another game studio besides my own”

So i came up with a Road map, a spreadsheet to visualize what requirements the positions I was looking for needed and where I was standing regarding those requirements.

Here’s one of the first positions I was aiming for (orange means that I failed)

I would give 6 months between tries on the same company so I kept track on dates that I was applying to

Here are the requirements for that position, I put everything that I was comfortable with on green, and in orange stuff that I would need to study to.

Then I made a list of Activities that would help me understand those subjects, and a list of Deliverables and little steps that would help me learn it. It would also help me to feel a sense of accomplished when I was painting what it was done in green.

This exercise resulted in:

It helped me to study
It helped me creating my portfolio.
Gave the chance to start writing technical posts that I wanted to write.

Tips for the Interview process

I think for people looking to break into the video game industry and coming from smaller countries outside of the United States, China and the European Union, the biggest challenge is being considered for those jobs, even get your resume read by a human can be challenging, so I would recommend to remove any note of your Country/location from your resume before starting applying for jobs, obviously, your current country will come up during the process, but in doing so, you will avoid the automatic HR programs that discard candidates outside specific locations.

In the specific case of programming jobs, what you might expect for the process is something like:

An initial phone screening to check your background and get to know you better.
A second interview with the team or a technical interviews, sometimes the steps are different in different companies, sometimes the second interview is a chat with who might be your manager, and sometimes it’s a technical interview. You can always ask to your recruiter about what’s the next step going to look like and if they have tips about what kind of question they might ask. Let’s remember that the interviewer WANT you to be hired, so ask for as much help as you can.
Once you pass the technical interview, you are “almost” there, sometimes you will still need to have your Team fit interview, or you might already have it, so the next step is a chat with a manger regarding career goals or what to expect in that position. Just be confident with yourself and be honest about it, in this step you can also ask as much questions as you want, you are also interviewing them.
If everyone gives you the thumbs up, you will move forward and will be on the final step: The job offer, with your salary, benefits and everything about the position. We are not going to talk a lot about the offer because it’s an extensive subject that would need it’s own post.

In a technical interview you might be ask to solve 1 to 3 problems in the language of your choice or a language that’s relevant for the position you are applying to, they also might have a “take home” assignment, that’s basically a mini project that you need to finish by a certain date provided for them.

In a team fit interview they would pair you with one or two members of the team that you might be part of, this interview can include some technical or behavioral questions from the team to you, but remember that you can also ask questions about the organization and how the team handles specifics situations in the day to day job.

The goal of a team fit interview is to know that you are going to be a great part of the team as well as you are going to be comfortable working with team, remember that this step is a two way street, you can ask as many questions as you want if you have some time, they want to get to know you and make sure you are a good fit for them.

Conclusion

When you don’t have a full time job as a video game developer, changing into the video game industry can be hard, but not impossible. I think this is some of the core aspects that helped me switching careers.

English as a second language. Most of IT jobs out there require a medium to advance level of English, game development is not different, and it’s a great investment in your future.
Have something to show in your portfolio. Small Games, Vertical slices, video game reviews, tutorials, something made by you that can differentiate you from other candidates.
Networking. It doesn’t necessary mean assist to in-person events (although it can be fun!), but you can join different discord servers about game development until you find a community that’s a good fit for you.
Get involved. Besides networking, I helped our local branch of Unity User Group in setting up meetings (back when we still could!), I didn’t know a lot about Unity back in those days but I wanted to be part of the community so I was there listening to the speakers and helping them out in anything I could do.
Don’t be afraid to apply for jobs. Even if you don’t feel 100% qualified for a job, you’ll never know if you’re a good fit for them until you try. Employers have some leeway for a great candidate and I’m sure he’ll be an excellent one if he puts his mind to it. Being rejected can be daunting, but you’ll never learn if you never try.

If changing careers is something you feel like doing so, I wish you all the best, and hope that this have been helpful to you. Feel free to reach out if you have any questions!

Happy Gamedev!

Postmortem: Dots of War

2021-01-27T00:00:00+00:00

Originally published in spanish on Oct 17,2020

Dots of War is a fast online strategy game for mobile devices, it is based on the game Dots and Boxes and the objective is to conquer the majority of the map by connecting four lines to score points. Once you capture a part of the map, your player’s energy rises and with it you can make special abilities that will allow you to affect your opponent’s turn.

Dots of War was the first game that was made by the LunarCrown studio, an independent video game studio based in Hermosillo Sonora, Mexico founded by other local studios in an effort to professionalize our work and reach a wider audience.

Dots of War Trailer

How do we choose the theme?

Early game design sketches

Like most of the decisions that were made in the project, we relied on votes. At the beginning of the project, we asked ourselves to pitch 1 or 2 proposals that we would like to develop as the first game, then we explained them to the team and at the end we would vote for the one that seemed easier to implement, interesting to work on and that we would like to work on.

From all these pitches the winner was to recreate the game of Dots and Boxes and give it a twist by gaining power-ups to affect the rival.

Early game design sketches

After that a “mood board” (a board to inspire us) was made about the type of artistic decisions that would be made, something to point out about how we would like the game to look like, where several photographs were placed to inspire us, you can see the mood board here, the Professor Layton saga and Advance Wars were a great inspiration for the look and feel we gave to Dots of War.

How long do we though the project would last?

Initially we thought that the project would last around 3 months, however, once we had the art of the game we decided to extend the development time “a little bit longer” to deliver a better quality product, that would become a process of around 9 months.

How do we divide the work/time/tasks/talent on the project?

Initially the project began with 8 members, 3 programmers, 2 3D artists, 1 2D artist (who also had the task of art director), a person in charge of user experience and quality, and a person in Game Design and 2D art.

But like other decisions, each time the team made a proposal for change we took into account what was agreed by the majority, within each sub-team the final decision was left within them, taking into account the opinions that were gave, we did not want to influence decisions that we were not very sure of the opinion we were giving.

At the beginning, these positions did not exist but we let it be known what type of role we felt most comfortable to work during the project, taking into account the abilities of each person and the area in which we would like to collaborate.

From the beginning, we decided that this would be a project that we would have to complete in our spare time, when we were not attending our main responsibilities with our work and family.

Therefore, each week during a small call of 15–30 minutes, we would update our progress during the project and we would end up clarifying how many hours we were going to be able to dedicate to the project that week, normally, it would be 6 to 10 hours per week.

We respect each member’s time a lot and we didn’t want them to feel that a lot of time was being demanded from them, so we let each member take responsibility for their time.

To divide the tasks, we used Trello, where each member could select the task they wanted to work on based on their talents and what needed to be done at that time.

How do we calculate how much it costs to make a game?

At the beginning of the project, we asked everyone involved to calculate how much they would charge for an hour of their work, that amount would be multiplied by the hours worked in a week, we would take 4 weeks as a month, and that would be the cost of “a month of development”.

Given that Dots of War was a hobby project, that money would not come from any investor and would be “absorbed” by us, at the end of the day we wanted to know how much it would cost us to make a game of these features between the team. This excersie gave us an idea of the real cost of production for a game like this.

$ 27,650 Mexican pesos (about 1,370 USD) was the average cost per month to maintain the team, this without counting any other operating expenses, licenses or computer equipment, those 27 thousand virtual pesos would be exclusively to pay salaries.

If the project lasted 3 months, the calculation would be: 3 x $ 1,370 = $ 4,110 USD That would be the amount that the game should earn as profit to come out in black numbers if we had invested in real money wages.

Every month that we go overboard with the game’s release, $ 1,370 USD should be added to pay for that month’s wages.

Properly, in a real project, you should have a monetization strategy to try to earn 5 times the development cost, giving a total of: $ 20,550 USD which would keep LunarCrown with enough money to pay the salaries, licenses and the development of the following game.

As we will see throughout this article, we will find out how we failed to reach those goals.

Create an MVP

Once we had defined the idea of the game we wanted to do and the tasks that had to be completed to launch the game, we decided to make a Minimum viable product (MVP) or Proof of concept (POC) that is simply to implement the basic mechanics of the game to test it internally and see if it was actually fun.

First version of Dots of War

The player can connect two dots with a line
The player can make a square by connecting four points with lines
The game identifies that it is a “square” and gives a score to the player who closed it.
The game identifies when it is the turn of each of the two players.
The game ends when there are no more possible moves to make and determines which of the two players is the winner.
The player can choose to play again.

All this was done with very rudimentary placeholder art, a user interface that would not be the final but that would help us to know what was happening “behind the scenes” of our game.

Once we had the basic mechanics of the game, we knew that we could finish such a game and the next thing would be to polish the game to make it more fun and add the art.

Scope creep first signs and how to deal with them

Scope creep is a term used in projects when the scope of the project begins to extend from a small project to a larger and larger project.

It is very easy to get carried away by the hype of wanting to add more features to a game, but it is also part of the responsibility and professionalism of the members to know how to recognize when the project should be adjusted to what has been agreed to and respect the time of everyone in the team.

At LunarCrown, we care a lot about the team’s time, so we highly respect the time they put into the project and we like to know that we are making the most of it.

Once we had the MVP and had a Dots and boxes game that worked and was for two players, making it stand out was part of the next task.

This can be achieved thanks to amazing art, interesting visuals, or unique mechanics that would set it apart from the rest of the games of this genre.

But in each of those aspects, it’s easy to get carried away and want to add “just one more thing.”

For example, in Dots of War you can choose 3 different heroe classes to play, each class has at least 1 2D skin to represent it (with the option to buy additional skins) and 3 3D models to represent when they have captured an area in the game map.

Pre-Alpha build of Dots of War

It was very tempting for the team to say “Let’s add another class”, but that represents:

Create more 2D assets.
Balance the character selection user interface (or code a workaround for the selection menu that accommodates each new character, which would also take unbudgeted time)
Create 3 extra 3D models.
Make a complete regression test with the new combinations between classes.

At times like that we can ask ourselves as a team: Is it really necessary to add a new character? Will it add more value to our game? Is it worth the reward that we will receive in exchange for the effort that has to be made? Are there other pending goals that we could be achieving instead?

Game development is full of decisions that are not fun, but that have to be made in order for the project to be completed in the end.

At the start of the project, each class also had a “special ability”, this ability could be used when the player gained 3 energy points and those energy points were obtained by capturing adjacent squares, the amount varied depending on the class.

Aside from their special ability, all classes have a common ability called “block” that when used, the opponent cannot continue their turn after capturing a square.

Humans could spend their 3 energies to steal a square from the opponent.
Stonemen could lock their squares to be un-stealables.
Wizards could block a line so that only they could use it.

Having a special ability for each player was very attractive to the team and to the game, but that functionality had to be programmed individually by each class and tested several times against different combinations of players to balance them.

Wizard using his special ability

Special abilities became a very big problem, the game had to keep moving forward, the programming team had to finish implementing that functionality and test it to see if the mechanics were balanced and if the game became more or less fun with it.

Something that happens in game development is that we focus so much on the project that sometimes we can no longer trust if what we are trying over and over again is still fun, so we must constantly be testing with people outside the team to listen fresh feedback and opinions.

Explaining the mechanics of class abilities was so difficult for outside players that the best decision we had was to cut that aspect of the game.

We had invested a lot of time on this feature, and we still didn’t know if this other great piece of game design was going to fit in with the core mechanic or if it was going to have some detrimental effect when players realized that a certain class had an advantage over others.

There was an internal vote to talk about this feature, and an agreement was reached to remove it from the game and only leave the general blocking ability for all classes, at this point all classes are the same.

Make an online game

Some would think that the most difficult part of the project was the online mode, but thanks to plugins like Photon this part was relatively simple.

In the original scope of the project we wanted to make a game that was multiplayer online, no team member had done a project like this before and it was really challenging for us.

Very early in the design of the game (and several times it was recommended by acquaintances outside of game development) the option of creating our own client-server logic was contemplated to have a more complete control of the game. It was agreeded not to use our own solution since we didn’t have the estimated time for doing so, and at the end it wouldn’t add value of our end goal.

We built the online interaction to be scalable in case in future versions we decided to create our own API for it, but for now, no one was going to commit to leaving the development of the game to create those pieces, so we voted not to do it.

Photon is a tool that manages the logic of receiving and transmitting information from clients to servers.

It has a free plan that allows you 20 concurrent connections, if there are more than 20 players playing the game at the same time, it begins to deny the service to those who are arriving, but as an account administrator, you can decide at what time to upgrade your account and allow more concurrent connections.

We concluded that, for an MVP and as an initial version, the free version of Photon would serve us quite well, and that if we had the “problem” that more than 20 players were playing at the same time, it would be worth upgrading, but for now we would monitor the number of concurrent players and we would evaluate the situation according to the data we have.

The way we implement the logic for the online game is quite simple.

First we finished the whole game so that it could be played with only one person.
Then we did the logic for the game to be played with 2 people using the same device and thus see how the turns behaved.
Once we polish that part, we create the online mode, where a room is created and we wait for another player to connect, once inside the room the game begins and determines who is player 1 and who is player 2 .
The actions of each player are transmitted to the network, and the game is designed to receive the actions and show the same interaction regardless of the devices.

The devil is in the details

So what happens when you already have a game, the art is in place, and you already have the online game mechanics in place?

You have to finish the game.

That last 10% to finish a project of this type where you have to correct the bugs, finish doing the complete regression tests, create the images for the stores where the game will be published, prepare the optimized text with ASO (App Store Optimization) So that it has a good ranking in each store, do your best to translate your images and text into other languages, prepare a trailer, and a list of tasks that are not technical but have to be done.

It is hard to finish a game and when you have invested so much time in a project you can focus a lot on one aspect and start neglecting others, so it is important that team members have a clear goal of what they want to achieve.

The development of Dots of War began in July 2019 and by October we already had an MVP and from then on it would be a matter of polishing it.

We started the project with 3 programmers, but before the first three months the programming team was reduced to 1 since one programmer had to move to another city for a better job, and another was cut from his job and we understood that making games as a hobby it wasn’t going to be their priority for the next few months.

At LunarCrown we always think of people first before work, and at the end of the day, it was a joint time that we were giving for the project, so there were no misunderstandings, they remained part of the team and gave their feedback but they were not assigned tasks each week.

Do you know what happened in late 2019 and early 2020 too?

The COVID-19 pandemic affected all industries and all jobs included where 2 team members worked, they had to reduce staff, so one was fired, and the one who remained had to take the work from several positions.

So once again certain tasks were going to be put on hold while everything settled down and they had more free time to dedicate to the project.

I believe that at this point, more than one person would have put this project on hold and rethink the scope, or perhaps release a simpler game, or some other solution.

In our case, the art team had finished their assignments, and had done such a good job that it seemed like a waste not to finish Dots of War.

So we decided to go a little slower but still keep going. After all, the game was almost done, only that last 10% was missing.

The worst mistake we made

Optional Samurai Skin for Humans

We are a team that likes to share updates, bugs and other details during the development process of a game, Dots of War was no exception, we did not have a pre-established Marketing campaign apart from the diffusion that we gave to the game with acquaintances, relatives and on social networks.

We liked to participate in posts where progress was shared or in #screenshotsaturday.

Given the great progress we had, we made what I consider to be the biggest mistake during the entire project development process.

Commit to a game release date.

At the end of March 2020 we calculated what had to be done (include the purchases of skins in the game and do the whole submit process for iTunes) and we guess the date when we would have everything ready, so we implemented it and started the submission process to iTunes.

In this part I was going to comment on a long list of things that displeased me about the process that Apple has to submit its applications but I prefer to summarize it with:

I have nothing good to say about the app development process for Apple or its platform.

For people interested in publishing their game with Unity on iOs, here are some tips we learned the hard way.

Have a Mac on hand with the version of Unity you are developing on, there are options such as Unity Cloud build but if there is a slight possibility that you have to alter a configuration file for iOs, get a mac with someone you know or member of your team.
The change on status of your application take time, nobody knows how long they can take and you have no control over how long it may take.
Keep in mind that iOs is very selective with the plugins that you can use in your project, sometimes certain plugins can alter some permissions of your application that will give you a headache once they start rejecting your application and tracking the error code that apple sends you.

Why do I say that giving a release date was the worst mistake we made?

Because we really didn’t have the need to give a launch date, we could have launched in the same way on some other date and there would have been no problem or angry reviews, coming up with a launch date puts extra weight on the team and on this case it was a Hobby project, no one was asking or expecting one except us.

Burnout

During this project I had to take two breaks due to the burnout (or exhaustion / fatigue syndrome) that I felt, one in December to have the opportunity to spend more time with my family, and another in May, when the pandemic was on the rise and the stress I had from working manifested itself as a rash on the skin of my hands that so far has not completely gone away (constantly washing my hands and putting alcohol on them to prevent COVID doesn’t help either)

Right before launch we did the media outreach by sending personalized emails to about 200 websites to cover the launch, we fixed the latest bugs, and we were able to launch the game.

When you realize that the last 10% is actually the last 30%

Once we launched the game and had the external impressions, we noticed some minor bugs, and a major one (the skins could not be bought), we had a group of alpha users who helped us a lot during development, but we never tested directly that part with them, only internally.

At that time, since we saw that the effort to contact the press did not give the results we expected (we ended up being covered by some portals, but in general many websites ask you for money to cover your game, money that we did not have budgeted for, so we had to miss that opportunity) and having the whole team really tired, we decided to take a few days to rest, and return to the project with fresher eyes.

In the end the errors were corrected and the project was complete in its first version, we had made a game together with a 100% remote team and we finished Dots of War.

What to do in case of fire?

We had an entire marketing strategy planned before launch that included:

Attend local events
Attend national video game development events
Make public presentations where attendees could test the game, give us their comments, win prizes.

But any face-to-face activity was totally ruled out as of March 2020 here in Mexico when the quarantine plans officially began.

Being a team that already worked remotely, it did not affect us at the time of work but we were quite affected in other areas, both in our formal work and in our interpersonal relationships, there were months of a lot of personal stress so we didn’t asked anyone to do more work than they were comfortable with and we relaxed the notion of due dates quite a bit.

Even so, working your full shift from home, taking care of your family and working on a project like this, even if it is a hobby, takes a price on one, many team members experience burnout to a greater or lesser extent.

The best thing to do in these cases is to take a step back, take a deep breath and evaluate what your priorities are, take time to rest and when we are in a better state of mind, continue.

We are very grateful to be part of a team that understands and is responsible for its members, who knows how to demand results but who also really cares about the person who is delivering them, after all, we started as a group of friends. with a common goal, and our relationship is more important than any project.

What did we learn? How can we end this on a happy note?

The development of Dots of War is not a commercial or media success story, but it is a success story for game development on remote teams.

Any game that is completed is a success.

There are many opportunity areas in Dots of War, but we are also very happy with what we achieved, a precedent was made for this type of development, no funds, no third-party money injections, no loans or government aid, all valid ways to start making games, but not the only ones.

There will always be a way to move a project forward, and not even a pandemic or the end of the world can stop it.

What could have gone much worse?

Good and bad decisions were made during the development of Dots of War, some based on time and some based on money.

Long before starting this project, we talked to team members about creating a game for PC and consoles with a development model very similar to what we had (but including an office provided by a group of investors), in the middle of the development of Dots of War we realized that if we had committed ourselves to making that game with that much larger scope, it would have placed us in a much more difficult situation and not at all redeemable as this project was.

We are very happy with the results we had and with the decisions we made, but we are also very happy with the other decisions that we did not make.

What’s next?

As a final note, we want to thank everyone involved during the development of Dots of War, all beta and alpha testers, the Unity user group HMO community that supported us from the beginning, the people who found out about the project and they gave their words of encouragement to us and to all Dots of War players.

Thank you very much, we did the best we could at the time that we could.

Now as we recover from burnout, it becomes clear to us that there will always be more games to do, a next project to do and when you develop as a hobby and to learn, you do not have to be accountable to anyone.

It‘s OK to learn from our experiences and not think that they were a failure, it’s OK to take a step back or stay for a while to catch your breath, everyone advances at their own pace and we are very happy to know that we keep trying.

For LunarCrown there are surely more projects, but given the current situation, we do not know what form they may take in the immediate future, but we are sure that we will count on each other to continue supporting each other.

Credits

Game Design, 2D art

Arvin Valenzuela

UX-UI, Quality Assurance

Jose Miguel Angulo

Art Director, 2D art

3D art

Programming

Unity Best Practices

2021-01-10T00:00:00+00:00

In this post, we are going to list a series of Best practices to use while working on a Unity Project, please keep in mind that not all of these practices are the necesary to include in each project, and as you get more experience working on Unity, you will get a better judgment about when or which ones to use for your own projects.

Project Organization

Project Folders Try to keep your scripts in an organized way, something that can be easy for you to navigate to when looking for a specific script, having multiple folders inside your script folder is also a good way to keep your logic organized.

Some assets or pluggins from the Unity Asset Store, will include a Folder called “Scripts” whith their own scripts from another author, to prevent confusion, name the script folder for your project something that makes sense to you plus it’s easily described for your project (I go with “MyScripts” because those are scripts made by me)

Grouping Objects in the Hierarchy

To avoid clutter in your Hierarchy window, you can drag and drop Game Objects inside each other to group them, doing so let you expand the “parent” Game Object and still have control for the childs.

If you don’t want to have the parent-child relationship, you can add an Empty Object as a Holder for all the childs, just to have a cleaner look in your Hierarchy window.

General Tips

Use source control

Unity projects can get mesy really fast, and having the ability to “make everything as it was before” it’s a huge time saver.

I personally recomend Git and wrote another article about how to use it with Unity.

While working on a Team project, make some ground rules

Out of the box, Unity doesn’t really like that 2 or more persons are updating the same Scene or Prefab at the same time. Make sure that everyone that it’s going to interact with the scene has the latest version and will only change something specific and push their changes to the repository.

Have somebody in charge of putting all together in case that a merge conflict it’s in place. After the merge conflict is resolved, talk with your team about it in order to prevent those, everyone should be on the same page regarding what’s need to be changed.

A general rule of thumb is, if you update something, and other stuff got updated but you didn’t intend to update it, leave it out of your commit, and reverse it.

Keep the same version of Unity for your project across your team

If somebody has a newer or lower version of the team that the rest, this might cause unnecesary and unexpected behavior while other member tries to open the project, Unity will try to update the version of the project and this might cause something to broke, it’s relative easy to fix, but this is totally unnecesary.

Using the latest long-term support release of Unity (LTS) it’ recommended for most projects, unless you are planing to use some super-specific feature that is in an unstable version, or not fully integrated to the Edior yet, thats totally not a bad thing!, but just keep in mind that everyone is aware of the version that your project is using.

While in mid-project, updating to a newer version should be done if that’s absolutely necesary. Unity Hub let’s you handle multiple versions of the Editor, so you can have for example, One project that started with Unity 2019, and it will stay with that version until completion, and having newer projects with Unity 2020. It’s up to the team to decide.

Working with Prefabs

Prefabs are your friends

Prefabs make it easier to make changes without changing the scene, try to work with prefabs as much as posible.

Prefabs reference

While reference an instance of Game Object, this should be made from a Prefab to Prefab and not between instances on the scene.

That’s it for today, Happy gamedev!

Unity Multiplayer Tutorial using Photon PUN

2020-12-27T00:00:00+00:00

Photon is a networking engine and multiplayer platform that can handle all the requests on their servers, and through the Unity (or other game engines) we can consume it, add the logic in our projects, focus on gameplay and features and let the part of the networking to Photon.

PUN (Photon Unity Networking) is one out of the box solution for handling multiplayer on Unity Projects, in this tutorial, we are going to lear how to:

Create a Room for other players to connect to
Having up to 20 players connect to the same game
Learn how can the players can interact with each other through custom actions and affect our game.

At the end of this tutorial, we are going to learn how to create a simple game with this features, and learn how we can scale it to add more features in the future.

I recommend that you check out the Github repository for this tutorial if you want to get more details as you read by, but we are still going to go step by step about how to achieve a Unity game with a multiplayer feature, you can also check out a live version of this tutorial here

First, we would need to create a Photon account over here

Once we are done with that, we can go To Dashboard > Public Cloud > Your Applications and we are going to click on “Create a New App”

We are going to choose “Photon PUN” for “Photon Type” and write a unique name on the field, after that we can fill out the rest of the optional fields and click on “Create”

This will create our Application on Photon, that we will need for the next steps on this tutorial, whate we want from here is the “App ID” if we click on the numbers, the rest of the Id will show up, and we can copy it for later use.

Here on the dashboard we can also get access to the metrics of how the app has been used, how many CCU (Concurrently Connected Users) have been connected accross all the rooms in your game.

Photon have a free tier that lets us test it (or go live if we want) with 20 CCU and we can choose to upgrade whenever we want, I personally think this is a great deal as Proof of concept and small games (that’s what we end up using on Dots of War), also if you want to upgrade to 100 CCU the Photon PUN 2+ Unity asset includes 100 CCU for 60 months at $95 USD you can also check out the pricing plans on their official website.

And if you feel the need to have more control over what’s going on on the server side of things, they have a solution for Self-Hosted servers, the same implementation but instead of going to theirs servers, it goes to yours.

Anyway, let’s go back to the tutorial, Let’s open up Unity and create a new 3D project.

Part 1: Creating a Lobby

Go to Window > Asset Store (make sure you are logged in), and search for “Photon Pun” in the searchbar. Here we are goint to select “PUN 2 - Free” and Import it to our Project.

Once we finish up importing the package, a window like this will show up:

In the AppId we are going to paste the AppId we got from the Photon platform that we just created, and we are going to click “Setup project”, this will link our Unity app with our Photon app.

If we go to Window > Photon Unity Networking > Highlight Server Settings we can configure our Unity app a little more.

For this Tutorial, I changed the “Fixed Region” property to “us” (United states) that will make all the connection to my Unity Game throught that region.

The way regions works on Photon is that it will evaluate which region is the best fit for the player that is connecting on our Game, that way it can reduce the lag and have an overall better experience in-game for all players.

However, since this is a demo, and it can happen that somebody in Australia and somebody in Canada can connect at the same time, if we leave the “Fixed Region” as blank, it will evaluate that the each person will be part of different region,and they wouldn’t be able to be part of the same Room and thus, not being able to play together.

You can read more about Photon Regions over here.

Creating a multiplayer game from scratch can be overwhelming, so for this Tutorial, we are going to use some of the pre-made assets from this package, and implment the bare minimum in our own in order to make it easier to diggest.

Let’s re-name our default scene as “Lobby”

In the lobby, there is going to be 5 elements to a Canvas.

“Number Of Players” and “Status Text” are going to be replaced with their values at runtime, being the number of players that are connected to the app at the same time (CCU) and “Status text” will help us to show up in which part of the process our game is on, this is helpful because when we are debugging multiplayer games ourselves, we need a builded version of the game and our Editor version.

“Enter your Name…” it’s an input text that will write up a PlayerPref with our name to differentiate when we are online.

“Join Room” will start the process of Joining or Creating a Room, and if everything works right, will change us to the gameplay scene.

“Leave Room” will disconnect us from the current Room.

For creating this simple menu, I Right clicked on the Hierarchy Window, and select UI > Canvas and inside of the canvas I added the rest of the controllers.

On The Hierarchy Window, create an empty object by right clicking on it and click on “Create Empty”. Rename it to “NetworkController” and look for a component called “NetworkController” (From the Photon assets) and attach it to your empty GameObject.

The NetworkController class will connect to Photon at the Start() event using our configured settings.

All our Scripts for this tutorial will be on the Assets > Scripts Folder.

Let’s create an Empty Object and Rename it PhotonLobby, and add the Script from that Folder called PhotonLobby.cs, we are going to fill it out with elements from our Canvas.

Now, let’s add the “OnClick” events from our btnJoin Button and btnLeave Button like this:

btnJoin Button OnClick Event

btnLeave Button OnClick Event

Also, let’s make sure our “Name InputField” looks like this in the inspector

“Player Name Input Field” is a script in the Photon Folder

The PhotonLobby class it’s commented so feel free to read the explanation of each method, but basically it show and hide the btnJoin/btnLeave button as needed in order to prevent trying to connect multiple times at the same Room.

It also:

Show up the number of players connected to our Unity game
Try to Join a Random Room, but if it fails to do so (because there is none or otherwise) it will Create a new Room.
If it fails to create a Room, it will try again.

Let’s create a new Empty GameObject and rename it to “PhotonRoom”, and add the component “PhotonRoom” to it from the Assets > Script Folder, and configure it like so:

The PhotonRoom class will activate once we are connected to a Room. It takes as properties indexes from the scenes of the projects, being Current Scene (the Lobby) Index 0, and “Multiplayer Scene” 1 (our GameScene scene that we will create in a bit)

This class waits for the event “OnJoinedRoom” to be triggered when we sucessfully connect to or Create a Room. And loads up which scene is the one with the actual game on it.

That’s the first part, creating the Lobby, now let’s create a new Scene and call it “GameScene”

Part 2: Creating a Game Scene

Since this Tutorial is focused on how to implement PUN, we are going to use some of the Prefabs for the Gameplay part of this demo.

Let’s create an Empty Game Object in our GameScene Hierarchy window, and we will add the Component GameManager.cs to it

Let’s add on “Player Prefab” a Prefab made by Photon called “My Robot Kyle -done-” that is on the Assets/Photon/PhotonUnityNetworking/Demos/PunBasics-Tutorial/Resources Folder.

This is Kyle

On GameScene, let’s create a Plane on Position 0,0,0 so kyle don’t end up falling once it’s spawned.

I ended up creating a basic scene with a plane and walls so the players don’t fall over

Now, we are going to change a little bit GameManager.cs , we are going to change the name of the scenes in the script to match the ones we have in our project like so:

GameManager makes sure that the player is connected to a room, if it’s not, it will load up the “Lobby” scene where we connect to a Room. If it it’s connected, it will load up the “GameScene” scene.

So now, before testing, let’s go to File > Build Settings and make sure our scenes are added to the Settings like so and hit the Play Button on Unity.

We are going to be redirected to the Lobby like this:

And if we fill out the Name input with our name and click Join Room, we will see something like this:

That is, if we made a ground for our robot to land on.

Want to see something cool?

Let’s test the game with two players connected at the same time, for this, we will need to build our game, I recommend trying with a standalone windows or mac version first since it’s easier to iterate that with other builds, but Photon is platform agnostic, so it any platform should be working the same.

So let’s go to File > Build Settings we choose the PC, Mac & Linux Standalone platform and we click on “Build”, and we wait for the build to be complete.

Left Unity Editor, Right Standalone Build.

Then we launch the .exe project and the editor at the same time. That’s pretty much what’s needed for having two or more players connected to the same Game with Unity using Photon PUN.

You might have noticed those extra buttons I added on the GameScene, that’s the final topic I would like to talk about.

How can players interact with each other?

In this tutorial, we have different players in the same room, but what about interacting with each other through the game?

To achieve this, we will need something like:

A Player does an action
The action get’s sended over to the server
All the rest of the Players (clients) receive the info of that action and it get’s replicated on their own game.

This is what’s called a Remote Procedure Calls or RPC this is basically a way for a method to be invoked on the clients of the same room.

For this tutorial, we are going to do a really simple and quick example of an RPC Method, and you can learn about all the other options for them or came up with different implementation reading the official documentation.

On our GameManager object, let’s add our own script from Assets > Script called GamePlayController to it, we also are going to txtNumberToIncrease Text GameObject from the Canvas to it, and add a Photon View Component with the Add Component button while selected.

You GameManager GameObject should look like this:

In the Canvas, I also added a new UI Button and called it btnAction, and on their OnClick Event I set it up to the IncreaseNumber Method from the GamePlayController class referenced by the GameManager GameObject

The GamePlayController Class have a very simple implementation:

It References the PhotonView Component at the Start() Event, needed in order to call and receive RPC
It reflects the globalNumber variable in the Update() Event to show always the latest value.
The IncreaseNumber() Method will locally call our RPC Method (marked with [PunRPC], the second parameter “RpcTarget.AllViaServer” refers that it will call the RPC_IncreaseNumber() Method for all the clients, but firstly will reach out the main server, so all the clients will receive the same message in order.
Finally the RPC_IncreaseNumber Method will be called by Photon to execute the order, in this case, increasing the globalNumber variable.

While clicking on any of the “Increase Number” buttons, the Number to increase goes up for all the clients

That’s it! you just created a multiplayer game!

Where to go from here?

RPC are super powerfull, and need to be designed in a way that makes sense for your game, you can pass parameters to it, serialize information through clients, and make all kinds of actions with them, this tutorial just cover the very basic for it just to get you started and not feel overwhelm by all this new information.

While designing your game you should take into consideration what kind of actions would the player be able to do, and how would the rest of the players in the room are going to be affected by those actions.

What’s something to keep in mind while using Photon?

As you can see, implementing Photon in your Unity game is very easy, you have your free tier to prototype and play around with it, but you should also think on the way it can scalate and design a business plan on how the game could be profitable to pay for the plans if there is need of increasing the number of CCU in your game.

Personally, I think it’s a great service, having the option to relay on a third party service to handle all the networking events, scalability, downtimes, responses, regions, match making, it’s truly a great way to get started in the world of multiplayer games, that doesn’t mean that you can’t implement your own solution instead of using the ones on Photon, it’s not an all-or-nothing, you can implement some features and having the rest of the features being handled by yourself.

I hope that this tutorial has been helpful, and if you want to check out the source code for it, feel free to do so in the Github Repository.

Happy gamedev!

Unity Cinemachine + Timeline Tutorial

2020-12-22T00:00:00+00:00

Unity has some major features regarding handling animation and Cinemachine and Timeline are modules that will give you the tools to create cinematics in your game, camera switching, custom mini-animations, or whole projects that are just animation like The Heretic short film.

In this tutorial, we are going to create the basics of a little cinematic animation, using Cinemachine and Timeline with 3 different shots and angles to familiarize with the process.

You can think of Timeline like where all the planification of the shot takes place, it handles the animation events, can trigger sounds, keep track of changes and switches the objects, and can be used to interpolate between changes in the camera for smoother transitions.

Cinemachine it’s a set of tools that enhance the Unity cameras with different features, make them dynamic, smart and without the need of adding extra code, and works great with timeline out of the box too!

You can follow along to create your first project with Cinemachine and Timeline, or you can download my repository to see how it was implemented.

Creating a cinematic

First, let’s open Unity, we are going to create a new empty 3D project.

Then, we need to enable Cinemachine and timeline for your new project. By going to Window > Package Manager, and make sure that Timeline and Cinemachine are “Selected” on the right checkbox, any version should work, but I would recommend the latest stable.

If you don’ see Cinemachine at first, you can search the package in the “in Project” tab, and change it to “Unity Registry” that will make the other optional packages to show up, and you can search for Cinemachine from the list.

After this, and since we were going to upload our project to Github, I decide to not use assets that I didn’t have the license to re-publish in other platforms, so today’s example it’s going to be with a 3D cube , so let’s add a 3D cube to our scene, by right clicking the Hierarchy window and select 3D object > Cube.

I ended up adding a 3D Object > Plane too, just to give a little more of sense and I scale it up to look like a ground where the 3D cube will be on.

The hero of our next big hit

Let’s re-name our cube by right-clicking the cube and selecting “Rename”, I rename it to “AnimatedCube”.

Then, we are going to start animating our cube directly on the timeline, to do so, Open up the Timeline window by going to Window > Sequencing > Timeline.

And let’s create an Empty GameObject in our Hierarchy Window, by right clicking and select “Create Empty”. Let’s rename that new empty Game Object to “Timeline”, that would work as the controller of our scene.

While having our “Timeline” object, go to the Timeline window and click on “Create” on the following option.

Then, as you do with making new animations, a prompt will show up asking you to name your .playable object and save it in a location within your project, you can name it as you want, I name it “cutscene”.

Once created, click on the three dots that appear in you animator by default, and delete it

Then, right click on that space and create a new “Animation Track”. This track on Timeline, will handle the animations in our cube. Since this is an entirely new project, the cube doesn’t have animation, so in this example we are going to animate it ourselves.

Drag and drop your 3D cube into the “GameObject {Animator}” of the Animation Track. This will assign the 3D cube to the track and will let us animate it.

If we hit the red circle in our track, we are going to “Record” whatever it happens with our 3D cube, in this example, hit the Record button, and move the 3D cube around every 40 or 60 frames, then change directions.

Please not that at the bottom, the keyframes are marked where the movement stoped and continue.

Now we are using Timeline, if we wanted to involve more objects in our shot, we would need to add more “Tracks” and add the animation when needed.

Now, to add Cinemachine to our project. We need to select our “Main Camera”, and in the Inspector window, click on “Add Component” and look for “CinemachineBrain”

We don’t need to do anything else with our Main Camera, but this will be used as the “Main controller” of the rest of our Cinemachine cameras.

What we are going to do, as in cinema, when there is an important scene and there is some shots from different angles, and different cameras at the same time, we are going to create those extra cameras and let them know what we want from them.

Let’s create our first Virtual Camera, by right clicking our Hierarchy Window and select Cinemachine > Virtual Camera.

Note: This might cause that your main camera end up not where it was before, but you can re position it whenever you want, let’s move around the Virtual Camera in an angle you like, and you will notice that there is a component on the Inspector Window called “CinemachineVirtualCamera”, let’s add our animated 3D cube to the “Follow” and “Look At” properties by drag and drop our cube into those fields.

You might notice that in the “Game” Window, when you have your virtual camera selected it might look something like this:

Those guidelines will help you in the composition of your shot, and the red border it’s a guide to let you know that the object will be harder to see in those places.

Now, if you click Play in Unity, you will notice that your 3D cube moves around for the animation, and the virtual camera follow it around.

That’s a very easy example of how to use Cinemachine, now for mix it up with Timeline, let’s select the “Timeline” game object from our Hierarchy Window, and Drag and drop our “Main Camera” object to create a Cinemachine Track.

Then, we can adjust where the virtual camera will come into play during the shot and by how long, but the fun begins when we add more virtual cameras.

Let’s add two more Virtual cameras by right clicking the Hierarchy window and select Cinemachine > Virtual Camera

Position your second virtual camera where you pleased and on the CinemachineVirtualCamera of that second virtual camera, let’s make it just “Look At” our cube, but not follow it

This will give the effect of a stationary Camera that just follows a target in movement.

And for the Third virtual camera, I position it in a different place in the scene and gave it this properties

It will work like the first Virtual Camera but from a different angle.

Now, if we go back to the Hierarchy Window, and select our “Timeline” game object, we can add the rest of the virtual cameras to our “Cinemachine Track”

And if we adjust the duration of the virtual cameras in the Cinemachine Track, we can get some very interesting result, if we try to overlap two virtual cameras, it will result on Timeline, interpolating thos two cameras into a smooth transition. Let’s see the result:

That’s it, you just created your fist cinematic using Unity Cinemachine and Timeline.

From now on you can play around with these basic concepts and explore the different types of Cameras from Cinemachine, and Tracks from Timeline to get some really impresive results.

Hope you had like it this little tutorial and remember that you can get the whole project in my github repository.

Happy gamedev!

Unity Cloud Build Tutorial.

2020-12-14T00:00:00+00:00

Cloud build is a service included on Unity Teams Advance that let you set up your existing source control repository to automate the compiling, deployment and tests of your games so you can iterate quickly with your team.

Basically you can set up a branch on your repository that Unity Cloud Build will pick up and deploy to the target platform/s of your choosing, you can set up different platforms (like Desktop, iOs, Android, Web) and configure an email alert that will let you know once the build has been completed of if there were some errors with it.

The advantages of using Unity Cloud Build is that all of that workflow is handled by the service, giving you more time to use your local hardware in more usefull stuff (or taking a well deserved rest).

What do you need?

A Unity Teams Advance license ($9 USD per month, which include 3 team seats and 25GB of Cloud storage) or a Unity Pro license.
A Source control repository (like Git)

How do you set it up?

You can lear how to set up Unity Cloud build in this super easy to follow official tutorial

Does this mean I can build for iOs without a Mac?

This is a tricky question. The short answer is no (sorry, I would also like this to be a Yes). But let’s elaborate on that.

Yes, you can build for the iOs platform on Unity Cloud Build, but to do that, you will need the certificates that will sign up your iOs build to upload it to the App Store. So at least you will need to get access to a Mac once to get those certificates.

After that, you can continue using Unity Cloud Build to make new versions of that project without the need to use a Mac. But please note that for uploading your project to the App Store, you will need to do so through XCode, so you will also need access to a Mac for that.

Personally, I have been down that rabbit hole before, and comming up from a Microsoft/Windows based background, this transition was hard for me. Some stuff that I learnead along the way:

You can rent a virtual mac if you don’t want to spend the money on one for you on MacInCloud to get the certificates and you can pay by the hour.
The process of uploading your game to the App Store can be long (not in time, but on multiple back and fort with the process of getting your game accepted on the App Store), so if you can get a friend or co-worker with a Mac that can help you with this process it’s super recomendable.

Advantages and Disadvantages of using Unity Cloud Build.

Advantages:

It let you focus on the important things, like improving your game.
It’s a very straightforward way to deliver continuosly, once it’s set up, it’s done and will work until you decide to do some other changes in the way to present the build.
Building can be very time consuming, and if’s made in another computer it’s a time saver.

Disadvantages:

Working with Unity and adding third party assets can mess up your automatic builds. Sometimes it can work on the editor, and in your local build, but on the remote build will fail, luckily Unity Cloud Build count with a very good log system that will let you know where the error is.

This has been a very basic approach to Cloud Build but in general this is a very good way to standarize your project and get to know how continuos integration work with Unity.

Hope you like it and happy gamedev!

Game Development Notes

C# in Depth

Points in its favor:

Topics I hoped would be better explained: LINQ

Would I recommend it?

Update vs. FixedUpdate vs. LateUpdate in Unity

What is a frame in Unity?

Explaining the update functions

Update functions order

FixedUpdate

Update

LateUpdate

Where to use each update function

FixedUpdate

Update

LateUpdate

Final thoughts

How to use streaming assets in Unity

What are streaming assets?

Let’s build an easy example of streaming assets

Using a coroutine to fetch a video from an external source

Final thoughts

Using coroutines in Unity

What are coroutines?

When to use coroutines

An example of a coroutine

Implementing a coroutine that never stops

How to stop a coroutine

Pausing games with coroutines

Using multiple coroutines and stopping them all at once

Coroutines vs. threads

Additional thoughts

Conclusion

How I got into the Game Industry

A little background

Creating a portfolio

Applying to Jobs

A word of advice here, so you don’t make the same mistake I was making:

What I was looking for?

Getting rejected, learn from it, try again

Turn yourself into the best candidate you can be

Tips for the Interview process

Conclusion

Postmortem: Dots of War

How do we choose the theme?

How long do we though the project would last?

How do we divide the work/time/tasks/talent on the project?

How do we calculate how much it costs to make a game?

Create an MVP

Scope creep first signs and how to deal with them

Make an online game

The devil is in the details

Do you know what happened in late 2019 and early 2020 too?

The worst mistake we made

Commit to a game release date.

Why do I say that giving a release date was the worst mistake we made?

Burnout

When you realize that the last 10% is actually the last 30%

What to do in case of fire?

What did we learn? How can we end this on a happy note?

What could have gone much worse?

What’s next?

Credits

Unity Best Practices

Project Organization

Grouping Objects in the Hierarchy

General Tips

Working with Prefabs

Unity Multiplayer Tutorial using Photon PUN

Part 1: Creating a Lobby

Part 2: Creating a Game Scene

Want to see something cool?

How can players interact with each other?

Where to go from here?

What’s something to keep in mind while using Photon?

Unity Cinemachine + Timeline Tutorial

Creating a cinematic

Unity Cloud Build Tutorial.

What do you need?

How do you set it up?