Dim lights at night create a gloomier, scarier atmosphere. These scenarios can be accomplished using the correct lights in the Unity Game Engine, and an important concept when using Unity lights is baking.

What does baking lights in Unity mean?

Lights in video games involve computer calculations to simulate their behavior in the real world.

These calculations take more time as the number of lights in your Unity game increases, and too many lights can significantly increase the calculations, negatively impacting the game’s performance.

Since most objects in a game don’t move throughout the level, these lighting calculations can be completed ahead of time and stored, freeing up computer resources to handle other tasks, such as animations and visual effects.

The process of calculating lighting data before the game runs is called baking lights, and the precomputed lighting data is stored in a special texture called a lightmap.

What are lightmaps in Unity used for?

Consider this scenario. Look at the environment around you. Chances are, you’re in a room with a chair on which you sit, and a table where you’ve placed your computer.

Maybe there’s a cup of coffee nearby and some books. The room has some light coming from somewhere, illuminating a significant part of it.

If the time of day never changed, and the room’s light remained constant, the lighting in the room would be the same forever.

The bright parts would be bright, the semi-bright parts would remain semi-bright, and the dark parts would remain dark.

Now, pretend for a moment there’s a dark room next to the one you’re in that has the same things but is completely black.

If you could strip away the surface of every object in the lit room, along with its current brightness, and then place it on the matching object in the dark room, the two rooms would end up looking the same.

That’s what happens when you bake lights in the Unity Game Engine.

Unity “turns on the lights” in your level to see what it would look like when lit up, places a large, digital, plastic sheet over all the static objects in a scene (like the plastic that fits snuggly around wrapped food), stores the lighting data in that sheet, peels off the sheet, “turns off the lights”, and places the sheet back exactly the same way in the dark level, making it look like it’s lit up but without worrying about the lights being on.

The lightmap (digital plastic sheet) stores the lighting data when baking lights and is placed over the objects in your game’s scene, making them look like they’re illuminated.

Tip: Even if you remove the light source after baking lights, the scene will still appear lit because of the precomputed light data. You can clear the baked data to restore the scene’s initial appearance.

Unity lights have three light modes:

• Realtime

• Mixed

• Baked

Realtime lights are lights whose calculations are done when the game is running. These lights cast dynamic shadows for moving objects in your game.

Realtime lights only work with direct lighting, i.e., light coming from the source and landing on an object directly.

Baked lights are lights whose calculations are done before the game runs, and the light data is stored in a lightmap. These lights don’t cast dynamic shadows without some additional tools.

Baked lights work with direct and indirect lighting. Indirect lighting is light that bounces off a surface and then lands on an object.

Mixed lights blend the properties of baked and realtime lights. They work with direct lighting when the game is running and baked indirect lighting, which is precomputed.

Mixed lights also cast dynamic shadows on moving objects.

Tip: Unity uses a group of techniques called global illumination to achieve realistic lighting results.

Which light you choose will depend on your goals. Do you have many moving objects that need light? Realtime or mixed lights are a good choice. The same applies to a moving light source, such as a flashlight.

Is most of the scene static? Baked lights will save you some performance.

Why You Should Bake Lights

Regardless of which light mode you choose, it’s still worth baking lights for a couple of reasons.

Accurate Lighting

Even though realtime lights simulate how light works in the real world better than baked lights, by default, they only work with direct light.

Light bounces in many different ways and indirectly lights up objects, and this behavior can be achieved by baking lights in the Unity Game Engine.

Performance Gains

Baking lights saves you precious resources that can be used to enhance your game even further compared to doing the light calculations when the game is running.

Flexibility

You can adjust the lighting settings in the Lighting window to bake lights at different resolutions and complexity.

This flexibility lets you make the necessary adjustments to ensure your game runs at a steady frame rate and maintains optimal performance, even under stress.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

Does baking lights affect reflections in Unity?

Reflections occur when light bounces off a smooth surface. Reflections in Unity are obtained by placing reflection probes in different areas of your scene.

Reflection probes take snapshots of the environment in an area you define and store them in a cubemap.

A cubemap is like a hollow box surrounding the reflection probe, and the inside walls of the cubemap are where the snapshots are stored.

The area a reflection probe covers can be adjusted for the best results in your game. When a reflective object moves in that area, the probe looks through the snapshots it took and applies the correct one to the object’s surface as a reflection.

There are three types of reflection probes in Unity:

• Realtime

• Baked

• Custom

Realtime reflection probes update reflections for dynamic objects in your game’s scene, such as the player. The result is more realistic reflections, but it also has a bigger performance impact.

Baked reflection probes are baked together with lights and work with static objects. Moving objects in the scene won’t update reflections on shiny surfaces if you use baked reflection probes.

Custom reflection probes let you use a custom cubemap for reflections.

You can use baked reflection probes and baked lights to precompute all the lighting data in your game’s scene for realistic lighting and reflections while saving on performance.

This can be useful for low-end devices, such as mobile phones, VR headsets, or low-end computers.

Tip: Even though a mirror has reflections, adding one to a game often requires more work than placing reflection probes in a scene.

A hybrid approach of baked lights and some realtime reflection probes can also work. It all depends on your game’s needs.

The single source of truth will always be the game’s performance when you test it using Unity’s profiler.

Indirect Lighting and Dynamic Objects in Unity

You can use light probes in your game to leverage the performance gains of baked lights in addition to more realistic bounced light on dynamic objects.

Light probes store light information as it passes through empty spaces, while lightmaps store light information when it hits an object’s surface.

If you have a dynamic object in the scene, such as a vehicle, you can place light probes in empty areas to store the bounced light information from static objects.

For example, if the car is driving past a blue building, the shadow cast on it from a realtime or mixed light should be slightly blue because of the bounced light.

Without light probes, the shadow will still be dark, but with light probes, the indirect light is calculated correctly, and the shadow cast is slightly blue.

Cons of Baking Light in Unity

Even though baking lights saves you performance when the game is running, there are still costs associated with it.

Long Bake Times

Lights in the Unity Game Engine can be baked at varying degrees of accuracy. The more accurate the light, the longer it’ll take to bake.

Long bake times are a common challenge for many game developers, but there are settings you can adjust to improve them.

Some of the settings you can change in the Lighting window include the number of times light bounces when it hits a surface, the number of light samples to use when generating lightmaps, or the size of the lightmap.

Larger, higher-resolution lightmaps for lights that bounce many times will take longer to bake than smaller, lower-resolution ones for lights that bounce a few times.

Noisy Lightmaps

Some lightmaps can produce noisy results due to the lighting settings or geometry in your game.

A lightmap is noisy when it produces smudges and other strange shapes or discolorations on the surface of objects.

This Unity Lights Troubleshooting Guide can help you find the problem and provides potential solutions.

Inaccurate Shadows

Realtime lights and mixed lights cast sharper, crisper shadows compared to baked lights.

Baked lights may save some performance beforehand, but they sometimes produce softer shadows that aren’t always convincing.

In Closing

Now that you have a better understanding of baking lights and what it can do for your game, you’re ready to learn how to bake lights in the Unity Game Engine.

They add realism to your game by simulating bounced light and how it lights up different areas in the scene.

Coupled with reflection probes and light probes, you can achieve realistic lighting at a fraction of the cost.

This guide walks you through all the things you need to do before baking lights in the Unity Game Engine and provides additional useful information to achieve your desired lighting setup.

If you’re reading this article on a smaller device, right-click on the images (long-press on touch devices) and select Open image in new tab to view them at full size.

Set Up Process

If you’re new to Unity and don’t know the basics, such as the Hierarchy window, Inspector window, or how to work with assets, watch this introductory video to get up to speed.

The first step in preparing your models for light baking is to ensure they can generate lightmap UVs.

Remember that baked lights work best with static objects in your scene, such as the walls in a house, immovable furniture, or props the player can see but can’t interact with.

If you imported the 3D model from the Unity Asset Store, it will likely be inside a folder named Models, Meshes, FBX, or something similar. If you dragged it into Unity from your computer, it’ll show up as is.

Remember that 3D models end in .fbx, so don’t confuse them with other similar-looking files, such as prefabs that end in .prefab or materials, which end with .mat.

Once the 3D model has been imported using Unity’s Package Manager window or dragged and dropped into the Project window from your computer, click it and observe the Inspector window.

Tip: If you can’t find a window, click on the Window option in the navbar at the top of the screen and check the dropdowns.

Click the Model tab in the Inspector window and check the box next to Generate Lightmap UVs. Click Apply to apply the settings.

Checking this box ensures the 3D model will generate lightmap data when baking lights. Repeat this for the other static objects in the level you’re building.

Next, drag the 3D model into the Scene window, turning it into a GameObject.

Once the model is in the scene, the Inspector window will display new information related to GameObjects. Check the box at the top right beside Static to let Unity know the model won’t move at any point in the level.

If you modeled the GameObject using ProBuilder, it will likely have a ProBuilder MeshFilter component with a Lightmap Static checkbox that’ll be automatically checked when you check the Static checkbox.

The GameObject should have a Mesh Renderer component in the Inspector. Click it to unfold the dropdown, revealing other dropdowns.

Tip: If you don’t see this component, it might be on one of the GameObject’s children. You can check for children in the Hierarchy window.

The one you’re most interested in is the Lighting dropdown. Click it to reveal the lighting options.

Check the box next to Contribute Global Illumination so the GameObject influences lightmaps and light probes when baking lights.

Tip: Checking Contribute Global Illumination without marking the GameObject as Static will automatically check the Static box.

Enabling global illumination will reveal another dropdown named Lightmapping. These settings inside it can be left as is, unless you want even finer control over the lightmapping process.

Leave the Receive Global Illumination dropdown at Lightmaps since the GameObject will be illuminated by the lighting data from the lightmap.

If you don’t want the GameObject to cast shadows or only want shadows from a particular direction, you can change the Cast Shadows option.

Repeat these steps with any new GameObjects you add to the scene as you’re designing your level.

Types of Light in Unity

There are different light types in the Unity Game Engine, so the one you choose will depend on how you want the light to affect the scene.

Directional Light

Directional lights are good for light coming from a source very far away, such as the sun or the moon. They don’t have a physical location in the scene, so you can place them anywhere, and the lighting will be the same. One is often enough per level.

Point Light

Point lights are good for lights that light up an area in a radius, such as light from candles, a lantern, or a fire.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

Spot Light

Spot lights work well with lights projected in one direction in a cone shape, such as you’d see from flashlights or search lights.

Area Light

Area lights emit light uniformly from a circular or rectangular area. These are great for indoor lights and other smaller sources of light.

Adding Lights in Unity

Once the level looks the way you envisioned, it’s time to add some lights.

Click the “+” in the Hierarchy window > Light > Select the light you want to add.

You can change the lighting mode from Realtime, Mixed, or Baked based on which looks good to you.

Realtime and mixed lights have crisper, dynamic shadows but have a bigger impact on performance.

Baked lights are the best for performance but don’t update the lighting when they’re moved and don’t cast dynamic shadows for moving objects.

Tip: You can bake lights in Unity for all three light types to improve your game’s appearance. You don’t have to use realtime lights only.

You can control each light’s intensity, color, range, and shadows cast by changing the options in the Light component in the Inspector window.

Once you’ve added all the lights and the scene looks good to you, it’s time to bake them.

Baking Lights in Unity

First, open the Lighting window if it’s not open: Window > Rendering > Lighting.

Under the Lighting Settings in the Scene tab, you’ll need to create a new Lighting Settings Asset. This is a file that stores the level’s lighting settings and ends with .lighting.

You don’t have to adjust any values initially after creating the asset, but it’s required to change the lighting settings.

Ensure the Baked Global Illumination box is checked, and select Shadowmask or Baked Indirect for the Lighting Mode option. You can tinker with these later to see which works better for your game.

Click the button at the bottom of the window labeled Generate Lighting to bake lights and wait until the countdown timer at the bottom right of the screen reaches 0.

If you followed the steps correctly, the objects in your level should have more realistic lighting. If not, read the Unity Lights Troubleshooting Guide to help triage the problem.

Baking lights in Unity can take a long time, so you can turn down some of the lighting settings to speed it up.

Here’s a breakdown of some of the settings and how they affect light baking:

• Lightmapper: Determines which piece of hardware you’ll use to bake lightmaps, either the CPU or GPU. Try switching between them if one takes too long to bake lights.

• Direct Samples: Samples used for direct light calculations. Higher values improve the lightmap quality but increase bake times. Changes in predefined steps, between 1 and 256.

• Indirect Samples: Samples used for indirect light (bounced light). Higher values improve the lightmap quality but increase bake times. Changes in predefined steps, between 1 and 256.

• Max Bounces: Maximum number of light bounces used in calculating indirect lighting. Higher values improve indirect lighting but may increase bake times.

• Lightmap Resolution: Controls the lightmap’s resolution. Higher values improve the lightmap’s resolution but increase bake times.

Tip: You can hover over each setting, and a tooltip will appear explaining what it does.

In Closing

You now know how to bake lights in the Unity Game Engine, and what’s left is to tweak the settings until you achieve the desired lighting in your level.

You can go a step further and adjust the final appearance of your game using post-processing to achieve things like glowing objects or effects like film grain for games set in older times.

There are several reasons for the lengthy bake times, which can take hours in some cases, but there are adjustments you can make to prevent this.

This article assumes you know how to bake lights in Unity and explores the settings you can change to improve bake times.

If you’re reading this article on a smaller device, right-click on images (long press on touch devices) and select Open image in new tab to view them at full size.

Progressive Updates

The Progressive Updates option in the Lighting window determines if the lightmapper should prioritize baking what’s visible in the scene view.

Checking the box next to it will update the objects in the scene gradually as the light is baking. Objects will initially appear dark and slowly brighten.

Turning off Progressive Updates alone can significantly reduce light baking times.

My internal tests on a fairly simple scene have shown that bake times reduced from over 15 minutes to under 2 minutes when I turned off Progressive Updates.

Lightmapper

The Lightmapper option in the Lighting window determines which system is used to bake lights.

There are currently two options: Progressive CPU and Progressive GPU.

If you’re experiencing long bake times using the Progressive CPU, switch to the Progressive GPU.

The CPU is already handling other tasks, such as running the Unity Editor and any other open programs, so offloading some of the work to the GPU can help speed up bake times since it doesn’t normally handle as many tasks as the CPU.

A simple internal test using Windows’ built-in Task Manager revealed that baking lights using the Progressive CPU consumed up to 100% of the CPU for an extended period.

The Progressive GPU fluctuated between 40% and 100% of the GPU’s processes.

The difference between the two is that if Unity is using 100% of the CPU, little is left over to perform other tasks on the computer. Even trying to take a screenshot resulted in noticeable delays.

The GPU being under such high loads hardly affects regular computer operations. Furthermore, the load doesn’t consistently stay at 100%.

Samples

The lightmapper uses samples to determine lighting calculations. There are three samples in the Lighting window:

• Direct Samples: Used for direct lighting calculations.

• Indirect Samples: Used for indirect lighting (bounced light) calculations.

• Environment Samples: Used for environment lighting calculations.

These settings are adjusted in predefined steps, ranging from 1 to 256. Higher values for these settings result in higher-quality lightmaps but increase the time it takes to bake lights in the Unity Game Engine.

Internal tests revealed that a value of 256 for each setting with Progressive Updates turned off is a good starting point for baking lights.

These values, with Progressive Updates turned off and all other settings at their default, resulted in bake times of roughly one minute for a modestly detailed scene.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

Lightmap Resolution

The Lightmap Resolution setting in the Lighting window determines the lightmap’s resolution in texels per unit.

A higher resolution results in higher-quality lightmaps and improved lighting in your game at the cost of increased bake times.

That being said, you’re probably curious what the best lightmap resolution is for your game.

For smaller levels, such as interiors with few objects and simple lighting, a lightmap resolution between 50 and 75 should suffice.

For more realistic lighting, a lightmap resolution above 75 is a good starting point.

You can always lower the lightmap resolution if the time it takes to bake lights becomes too long.

Tip: Increasing the lightmap resolution may solve smudges on walls and other artifacts caused by noisy lightmaps.

Lighting Mode

Unity has three lighting modes for mixed lights listed below in order of their effect on performance.

1. Distance Shadowmask & Shadowmask (most expensive)

2. Baked Indirect

3. Subtractive (least expensive)

The visual fidelity of your game will determine the lighting mode you’ll use when baking lights.

Distance Shadowmask and Shadowmask offer more realistic lighting but with a higher performance cost. Distance Shadowmask is more costly compared to Shadowmask.

Baked Indirect also offers realistic lighting and realtime shadows. The main difference between it and the Shadowmask lighting modes is that Baked Indirect only casts shadows up to a specified Shadow Distance.

Subtractive offers simple lighting and low-fidelity shadows. This is a great option for low-poly games or games with stylized art.

Using the Subtractive lighting mode may improve the light baking times, but the other modes may not have a big impact if the level’s lighting is set up correctly.

Bonus

• Adding many lights to a level can increase the time it takes to bake lights in Unity. Instead of using multiple light sources, you can use fewer lights with a longer range and higher intensity to light up more areas.

• Many reflection probes may also negatively impact bake times. Use fewer reflection probes in larger, open areas where fewer objects appear in a reflection. Reducing the reflection probe’s resolution also helps.

• Too many light probes may affect light baking times. Use fewer, spaced-out light probes in open areas and more, condensed light probes in areas with many objects where light will often bounce, leading to more complex lighting calculations.

• In some cases, baking lights might be taking too long because of hardware limitations, so you’ll need parts that are more capable of handling all the lighting computations you require.

What are the best light settings in Unity?

There’s no one-size-fits-all solution to lighting settings in the Unity Game Engine. The best light settings are obtained through adjustments until the game developer is satisfied with the results.

Regardless, if you’re unsure of where to start and are looking for some general settings that will bake lights in under 2 minutes with decent results for a modestly detailed scene, try the following. All the other settings remain at their default option.

• Lighting Mode: Baked Indirect

• Lightmapper: Progressive GPU

• Progressive Updates: Off

• Direct Samples: 256

• Indirect Samples: 256

• Environment Samples: 256

• Max Bounces: 2 or 4

• Lightmap Resolution: 50

• Max Lightmap Size: 1024

In Closing

The tests and settings used in this article were on a computer with the following relevant specs:

• GPU: NVIDIA GeForce GTX 1660 6GB VRAM

• CPU: Ryzen 5 2600

• RAM: Dual-channel 16GB

• OS: Windows 11

Computers with better hardware will perform better, while those with poorer hardware might experience degraded performance.

If you’re still experiencing trouble with lights, read the Unity Lights Troubleshooting Guide to help you diagnose the problem.

From footstep sounds when the character is walking to the birds chirping in a forest scene, good audio can take any game to a whole new level.

Good audio doesn’t always come cheap, but there are places where you can find good music and sound effects at no extra cost.

Here are five websites where you can download free music and sound effects for your game made in the Unity Game Engine.

Pixabay

Pixabay has thousands of royalty-free music and sound effects you can use in your games or trailers.

The sound effects include gunfire, footsteps, monster sounds, user interface (UI) sounds, and more.

You can start downloading audio without creating an account, but the option is available for anyone who expects to use the platform often.

If you love a particular track or sound effect, you can donate to the artists, or, if they’re available for hire, hire them to create more audio for your game.

The platform is community-driven, so if you or someone you know creates music and sound effects, you can create an account and start uploading your content.

It offers additional resources, including illustrations, vectors, and photos, that may be useful for game development.

Mixkit

Mixkit offers a rich library of music and sound effects you can download and use without any attribution.

There’s a search bar where you can type in the type of sound effect you want, and the results will be revealed shortly.

Although it’s not as vast as Pixabay, Mixkit remains a viable alternative if you don’t find what you’re looking for on Pixabay.

You don’t have to create an account to get started and can download audio right away.

Mixkit is tailored towards video editors, so you’ll find other resources there, such as stock video footage and templates for video editing platforms, such as DaVinci Resolve or Adobe Premiere Pro.

Streambeats

Streambeats began as a provider of free royalty-free background music for live streaming on platforms like Twitch and YouTube, but has expanded its catalog in recent years.

Most of the tracks are in the lo-fi genre, perfect for laid-back games aiming for calm, relaxed vibes.

What Streambeats lacks in sound effects, it makes up for in hundreds of audio tracks you can use for free without attribution.

Some of the other genres include rock, electronic, and chiptunes that would be perfect for 2D pixel art games.

There are no accounts or sign-ups necessary to use music from Streambeats. You can download the music directly from the website.

The website doesn’t include previews of the music, but you can listen to them on Spotify by searching for an artist by the same name.

Unity Asset Store

The official Unity Asset Store remains one of the best places for any assets you’ll need to make a game in the Unity Game Engine.

It’s curated for game developers seeking assets ranging from free to hundreds of dollars, all with varying quality.

The Asset Store offers audio and sound effects for multiple video game genres. Whether you’re looking for chip tunes for a pixel art game or sci-fi explosions for your sci-fi first-person shooter, you’ll most likely find it in the Asset Store.

You can also save any assets you like but don’t currently need for later. Once you find one, add it to your assets and download it inside the Unity Game Engine.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

YouTube

YouTube might not be the top place to look for music and sound effects to use in a game, but there are some channels offering royalty-free, no-copyright music you might be interested in.

Some of these channels include Audio Library and Audio Library - Free Music.

A simple search for royalty-free or free sound effects should reveal more channels offering the kind of audio you’re looking for.

Bonus

If you’re a fan of the AI hype train, you can leverage one of the AI models to generate music and sound effects for your Unity game.

There’s been some friction between artists and AI companies over the use of their work to train AI models and the ethics behind it, but the argument remains unresolved.

This article focuses on the Unity Game Engine, but the content in some of these YouTube channels applies to other engines, such as Godot or Unreal Engine.

Whether you’re a hobbyist game developer or a student intent on working in a AAA studio, these channels should be useful at some point or another.

Expand the table of contents below for an overview of the categories they are grouped under.

Art

Saultoons

Saultoons teaches pixel art, from setting up Aseprite, a popular pixel art tool, to pixel art animation.

The channel’s owner, commonly referred to as Saul, also specializes in hand-drawn art and has attended art school.

Saultoons’ content is beginner-friendly with a touch of comedy while covering topics such as hue-shifting, the twelve principles of animation, and color palettes.

The community is active and participates in the annual Septembit Challenge, where aspiring game artists and developers create pixel art from 30 prompts in 30 days.

Blender Guru

Blender Guru specializes in making 3D content using Blender, a popular, free, and open-source tool widely used in the video game industry.

This channel is responsible for the well-known donut tutorial on YouTube, which you may have heard about.

If you’re interested in creating 3D environments or characters, knowing how to use a 3D tool like Blender is crucial. Blender Guru is a YouTube channel that can help.

Brandon James Greer

Brandon James Greer’s channel focuses on creating and animating pixel art.

The content also focuses on pixel art challenges, such as using obscure color palettes on different sprites to see how far they can be pushed.

If you’re interested in learning pixel art while diving deeper into the design choices behind popular video game characters, Brandon James Greer is the channel for you.

Honorable Mentions

MortMort, regarded highly in the pixel art world, is one of the first YouTube channels dedicated to pixel art. It covers everything from pixel art techniques to advanced brushes in Aseprite.

Pixel Pete is another popular pixel art YouTube channel known for its Pixelart 101 series exploring various aspects of pixel art, including grass, furniture, and trees.

Shaders

Ben Cloward

Ben Cloward is an industry veteran specializing in shader creation using Unity’s shader graph and code.

His deep knowledge of shader creation spans almost two decades and is a rich source of information for any aspiring game developer interested in shaders.

The channel covers shaders in both the Unity Game Engine and Unreal Engine.

Ben’s content ranges from beginner to advanced, so there’s something for game developers of all skill levels.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

Dan Moran

Dan Moran’s channel is a treasure trove of shader case studies for popular video games like Overwatch, Dishonored, and No Man’s Sky.

The shader content is primarily for the Unity Game Engine, but Dan also mentions what applies in Unreal Engine for anyone interested.

The videos on the channel are well-structured and well-paced, with a light comedic touch that doesn’t distract from the main topic.

Daniel Ilett

Daniel Ilett’s channel explores shaders in Unity built using Unity’s Shader Graph in the Universal Render Pipeline (URP).

The channel’s tutorials cover popular shader effects, including holograms, outlines, dissolves, and cel shading.

It also recreates cool effects from popular video games such as Metal Gear Solid, The Legend of Zelda, and Pokémon.

Honorable Mentions

Freya Holmér discusses mathematics and its application to shaders and video games in general, using creative and easy-to-understand math graphics.

Although it’s not a YouTube channel, gamemath.com is a helpful site for anyone struggling to understand vectors, world space vs. local space, among other video game math concepts.

C# & Scripting

Height Above Sea Level

Height Above Sea Level is a beginner-oriented channel dedicated to teaching aspiring game developers how to code in C#, the scripting language of the Unity Game Engine.

It has a playlist covering the fundamental C# concepts you’ll apply when making your game in Unity.

There are bi-weekly questions posted on the Posts tab to help reinforce your C# knowledge, along with scores of short videos for quick reminders of things you forgot or may have missed.

Jason Weimann (GameDev)

Jason Weimann’s channel is code-oriented, specifically with the Unity Game Engine.

Its content ranges from writing tests for Unity games to common design patterns game developers should know.

Jason Weimann also has podcast-style videos where developers come together to discuss industry news, best practices, and other game development-related topics.

Turbo Makes Games

Turbo Makes Games is a code-oriented YouTube channel dedicated to advanced Unity game developers.

The content covers Unity’s flagship Data-Oriented Technology Stack (DOTS) and the Entity Component System (ECS), designed to build large games while maintaining good performance.

Beginners will struggle to grasp most of the concepts discussed, but advanced Unity game developers intending to build larger games will likely reap the most.

Honorable Mentions

Despite being away for quite some time, Infallible Code still offers useful insight into writing and debugging video game code using the Unity Game Engine.

Animation

iHeartGameDev

iHeartGameDev’s channel covers the animation process in Unity, from setting up the 3D model to creating state machines.

The content is beginner-friendly and includes C# code along with the animation. Most of the videos are over three years old, but are still applicable today.

FImpossible Creations

FImpossible Creations is one of the few YouTube channels that teaches how to work with animations for animals and other multi-legged creatures.

The content covers inverse kinematics, an important concept in animation you’ll encounter if you want the characters in your game to pick up objects or interact with swords and other weapons.

If the game you’re making in the Unity game engine has animals or non-humanoid characters, FImpossible Creations is a gold mine that’ll help you animate them.

Video Game Artificial Intelligence (AI)

Holistic3D

Led by Dr. Penny de Byl, Holistic3D tackles simple artificial intelligence (AI) in video games to complex non-player character (NPC) systems.

Dr. Penny earned a PhD in Artificial Intelligence in Computer Games, and her courses have been featured on the official Unity Learn website.

The content is structured a lot like a university course, and you’ll be learning from someone who’s an experienced university professor in real life.

AI and Games

AI and Games discusses artificial intelligence in popular video game titles, such as Alien Isolation and Hitman.

The content is more theory-oriented and doesn’t include making a game in any game engine, but it’s still a valuable resource for understanding what makes good AI and why.

AI and Games is a great channel if you’re looking for inspiration for the AI in your game or want to learn more about how AI in games has evolved over the years.

Visual Effects (VFX)

Gabriel Aguiar Prod.

Gabriel Aguiar Prod. covers visual effects in the Unity Game Engine, Unreal Engine, and Godot.

The visual effects range from muzzle flashes to anime water commonly found in stylized games.

If you’re an aspiring game developer who enjoys the artistic side of game development, particularly VFX, this is a YouTube channel worth checking out.

All-in-One

Brackeys

Certain YouTube channels cover a broad range of topics and are best viewed as an all-in-one solution.

Brackeys is arguably the largest game development channel on YouTube, with content dating back as far as twelve years ago.

Its content covers shaders, animation, lighting, audio, 3D modeling, C#, and more.

Brackeys also hosts multiple game jams each year with thousands of participants, so if you’re looking to flex your game development skills in a jam, this is a great place to do it.

The Official Unity YouTube Channel

The official Unity YouTube channel is the best place for the most accurate and up-to-date content on the Unity Game Engine.

Updates to the engine, upcoming conferences, show reels, tutorials, and more are posted on the channel. The content also covers popular topics like cameras, 2D games, shaders, and more.

Game Design

Game Maker’s Toolkit (GMTK)

Game Maker’s Toolkit is one of the most popular YouTube channels covering game design principles in video games.

Some of the videos also explore level design and environmental design, so there’s something for any aspiring game developer interested in the design aspect of game development.

Game Maker’s Toolkit, commonly referred to as GMTK, is another channel with regular game jams if, for some reason, you miss out on Brackeys’ game jams.

Mobile Game Development

Creauctopus

Creauctopus, headed by mobile game developer Ivan, teaches you about mobile game development, monetizing your mobile game, and all the details involved with publishing to the Google and Apple app stores.

Ivan is an indie developer whose mobile games have been downloaded over a million times across Android and iOS devices.

The channel also shares revenue earned from various mobile games and how to maneuver through different ad platforms.

Publishing/Industry Knowledge

Thomas Brush

Thomas Brush’s channel features podcast-style interviews with successful indie game developers and industry veterans.

The majority of the content focuses on the path to publishing your indie game, life as a solo game developer, and revenue earned from indie games.

If podcasts are your thing, you’ll probably enjoy the content on Thomas Brush’s channel.

Game Development Challenges

Dani

Dani’s YouTube channel is filled with wacky, over-the-top, and funny content of video games and game development.

He’s well known for recreating Among Us in 3D, Fall Guys, and multiple other video game genres using the Unity Game Engine.

If you’re in for a bit of entertainment, Dani’s channel is sure to provide it. Just ask his 3.56 million subscribers.

Blackthornprod

Initially starting as a channel focused on teaching art and using Unity, Blackthornprod has pivoted to game development challenges involving multiple developers.

Its most popular videos involve challenging game developers to make a game without communicating in a specified timeframe.

The challenges are both entertaining and provide good insight into the concessions that are made when there are deadlines but no interactions.

Mix and Jam

Mix and Jam is a channel that recreates game mechanics from popular video game titles in the Unity Game Engine.

Some of the videos include mechanics from games such as Overwatch, Balatro, The Legend of Zelda, and Red Dead Redemption.

These are some of the current game development content creators, and the number will grow as more people start creating content.

It’s also common to reduce the player’s health whenever they take damage. These are operations that will require operators.

Operators can be used to perform mathematical operations such as addition and subtraction, or compare different values to check if they’re equal.

This article assumes you have some knowledge of variables, constants, and numbers, but if you don’t, read the linked articles to get up to speed.

If you’re a visual learner, you can watch the video version below.

What is an operator?

Operators are symbols used to perform various operations in C#. The five most common ones you’ll use are:

1. Arithmetic operators

2. Comparison operators

3. Equality operators

4. Assignment operators

5. Logical operators

Arithmetic Operators

Arithmetic operators are used to perform the common mathematical operations you’ve encountered in your daily life:

• Addition

• Subtraction

• Multiplication

• Division

Addition

You can add two or more numbers using the (+) operator.

This is useful in actions in your Unity game that increase a number. For example, if the player harvests some wood, the wood counter in the user interface should increase.

Alternatively, collecting health pick-ups should replenish the player’s health after they’ve taken damage.

var woodInInventory = 20;
var woodCollected = 10;

var totalWood = woodInInventory + woodCollected;

Debug.Log(totalWood); // Logs '30'.

sbyte health = 90;
sbyte healthOrb = 10;

Debug.Log(health + healthOrb); // Logs '100'.

If your game involves the player collecting coins, C# has an operator that can increase the total coins collected by exactly 1, since that most likely will be the value of each coin.

This operator is called the increment operator, and it’s written using two plus signs: (++).

When placed after a variable, which is how you’ll use it most often, the increment operator increases the variable’s value on the next line.

When placed before a variable, the increment operator increases the variable’s value on the same line.

var coinsCollected = 7;

// Assume the player just picked a golden coin.

Debug.Log(coinsCollected++); // Logs '7'.
Debug.Log(coinsCollected); // Logs '8'.

var ammo = 19;

// Assume the player just picked a bullet.

Debug.Log(++ammo); // Logs '20'.
Debug.Log(ammo); // Logs '20'.

Warning: This is one of the quirks of using the operator that may leave you wondering why the coin counter isn’t increasing when it should, so use it with discretion.

Subtraction

Taking damage should reduce the player’s health. Similarly, using a magic potion should reduce the total potions in the player’s inventory.

You can subtract one number from the other using the (-) operator.

Let’s say taking a hit reduces the player’s health by 25 hit points (HP). This is what the code would look like.

var magicPotions = 10;

// Assume the player just used a magic potion.

Debug.Log(magicPotions - 1); // Logs '9'.

byte health = 100;

// Assume the player just took some damage.

Debug.Log(health - 25); // Logs '75'.

A similar operator to the increment operator exists in subtraction: the decrement operator (--).

Unlike the increment operator, this operator decreases the variable by exactly 1.

It decreases the variable on the next line when placed after the variable, or on the same line when placed before the variable.

var magicPotions = 10;

// Assume the player just used a magic potion.

Debug.Log(magicPotions--); // Logs '10'.
Debug.Log(magicPotions); // Logs '9'.

byte health = 100;

// Assume the player just took a small hit.

Debug.Log(--health); // Logs '99'.
Debug.Log(health); // Logs '99'.

Tip: Only the addition and subtraction operators have a unique variation of them.

Multiplication

If the game you’re making in the Unity game engine has damage multipliers, you can use the multiplication (*) operator to implement them.

This operator multiplies two or more numbers together, so you could store the damage booster in a constant and then multiply that by the current damage to triple it.

const int DamageMultiplier = 3;

var currentDamage = 50;

var boostedDamage = currentDamage * DamageMultiplier;

Debug.Log(boostedDamage); // Logs '150'.

Division

Some games have debuffs that negatively impact the player, such as slowing down their movement.

Let’s say there’s an evil wizard in your game that casts a spell on the player, reducing their movement speed by 50%.

You can divide the player’s speed by 2 to get the new speed when the debuff is applied using the division (/) operator.

var speed = 100;
var speedPenalty = 2;

var slowedSpeed = speed / speedPenalty;

Debug.Log(slowedSpeed); // Logs '50'.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

Remainder

The remainder operator (%) is used to get the remainder after dividing a number.

For example, 10 divided by 4 results in a remainder of 2 because 4 can only go into 10 a maximum of two times.

int ten = 10;
int four = 4;

var remainder = ten % four;

Debug.Log(remainder); // Logs '2'.

Let’s say you want to create a pattern in your Unity game where the odd-numbered tiles are white and the even-numbered tiles are black.

You could use the remainder operator to divide all the numbers by 2. If there’s a remainder, then the number is odd. If there’s no remainder, the number is even.

var tileOne = 1;
var tileTwo = 2;
var tileThree = 3;
var tileFour = 4;

Debug.Log(tileOne % 2); // Has remainder. Is odd, so white tile.
Debug.Log(tileTwo % 2); // No remainder. Is even, so black tile.
Debug.Log(tileThree % 2); // Has remainder. Is odd, so white tile.
Debug.Log(tileFour % 2); // No remainder. Is even, so black tile.

Comparison Operators

Comparison operators compare two numbers to check which is bigger, smaller, or if the two numbers are equal.

These operators use the common mathematical symbols:

• >: greater than

• <: less than

• >=: greater than or equal to

• <=: less than or equal to

If your game has a rage mode, you can check if the current rage meter has reached or exceeded a certain number, then activate it.

var currentRage = 95;

const sbyte RageTrigger = 100;

if (currentRage >= RageTrigger)
{
    Debug.Log("Rage mode enabled. AARGH!!");
    // Increase damage, speed, and health in this code block.
}

Equality Operators

Equality operators check if two numbers are equal.

== checks if two values are equal, while != checks if two values aren’t equal.

You can use them to check if a player has taken damage before trying to replenish their health when they collect a health orb to prevent exceeding the maximum health they can have.

var health = 75;
var healthOrb = 10;

// Only add HP if health is not full.
if (health != 100)
    Debug.Log(health + healthOrb); // Logs '85'.

if (health == 100)
    Debug.Log("Max health reached."); // Doesn't log anything. Can you guess why?

Assignment Operators

Assignment operators assign values to a variable. The most common one is the single = sign.

A variable is often assigned a value during creation, but this can be delayed until later in your game’s code.

The = can be combined with arithmetic operators to assign variables new values.

• +=: assigns a new value to the variable, where the number to its right is added to the variable’s old value.

• -=: deducts the number to its right from the variable’s old value, then updates the variable.

• *=: multiplies the number to its right by the variable’s old value, then updates the variable.

• /=: divides the variable’s old value by the number to its right, then updates the variable.

int shields = 100;

shields += 25; // Player picks up '25'shields.

Debug.Log(shields); // 'shields' are now at '125'.

var health = 100;

health -= 20; // Player has taken '20' damage.

Debug.Log(health); // 'health' is now at '80'.

// The same applies to '*=' and '/=' operators.

Logical Operators

Logical operators are used on values that are either true or false. These are known as booleans.

They’re commonly used in conditional statements, a topic discussed in more detail in a separate post, to toggle different parts of your Unity game’s code on or off.

Let’s say you want to give the driver in your racing game 500XP if they finish first in the race.

The two conditions for them to get the XP are:

1. They have to finish the race.

2. They have to finish the race in first place.

You can use the && operator to achieve this.

It lets you chain multiple conditions, so the code in the if statement only executes if all the conditions are met.

If even one condition isn’t met, the code does not execute.

var hasFinishedRace = true;
var finishPosition = 1;

if (hasFinishedRace && finishPosition == 1)
    Debug.Log("Driver has received 500XP!");

Alternatively, you could give the driver 100XP if they finish the race in any position or pass through 5 checkpoints.

The two conditions are:

1. Finishing the race, or…

2. Passing through 5 checkpoints.

The difference this time is that only one condition must be met for the code to execute.

You can use the || operator to achieve this. The two symbols are called a double pipe.

var hasFinishedRace = true;
var checkpointsPassed = 3;

if (hasFinishedRace || checkpointsPassed == 5)
    Debug.Log("Driver has received 100XP!");

The ! operator inverts a true or false value. For example, !true is read as “NOT true”, while !false is “NOT false”.

It’s useful when working with predefined Boolean variables that the player controls and can change at any time.

You can use it to check if the player is not on the ground before playing a flying kick animation.

This ensures the flying kick animation only plays when the player is airborne because they can choose to stay grounded or jump at any time.

bool isPlayerGrounded = true;

if (!isPlayerGrounded)
{
    // If player is NOT grounded, this is logged to the console.
    Debug.Log("The player is airborne.");
}

Debug.Log(!true); // Logs 'false'.
Debug.Log(!false); // Logs 'true'.

Recap

• Arithmetic operators are for mathematical operations, such as addition and subtraction.

• Comparison operators check if one number is larger, smaller, or equal to another.

• Equality operators check if two numbers are equal or not.

• Assignment operators assign or re-assign values to variables.

• Logical operators chain conditions together or reverse a Boolean value.

This post is the fourth in a series breaking down common C# concepts used in game development with the Unity Game Engine.

The next one discusses how to use strings to work with text.

Here’s the full list of posts in the series:

1. A Game Developer’s Guide to Variables in C#
2. A Game Developer’s Guide to Constants in C#
3. A Game Developer’s Guide to Numbers in C#
4. A Game Developer’s Guide to Operators in C# (you are here)
5. A Game Developer’s Guide to Strings in C#
6. A Game Developer’s Guide to Booleans in C#
7. A Game Developer’s Guide to Enums in C#
8. A Game Developer’s Guide to Conditional Statements in C#
9. A Game Developer’s Guide to Loops in C#
10. A Game Developer’s Guide to Classes in C#
11. A Game Developer’s Guide to Access Modifiers in C#
12. A Game Developer’s Guide to Fields & Properties in C#
13. A Game Developer’s Guide to Methods in C#
14. A Game Developer’s Guide to Lists & Arrays in C#
15. A Game Developer’s Guide to Dates & Times in C#

Strings store and manipulate text. They’re the foundation of the majority of text-related code you’ll write for your game made in the Unity Game Engine.

This article assumes you have some knowledge of variables, constants, and operators, but if you’re not familiar with them, read the linked articles first.

If you’re a visual learner, you can watch the video version below.

How do you use strings?

You’ll first need to create a string variable before you can use it.

String variables are written using double quotes and, optionally, some text between them.

string legend = "Wraith";

var game = "Apex Legends";

Most characters are allowed between the double quotes, but there are some special ones called escape characters you should be aware of, which are discussed later in the post.

What’s the difference between a char and a string?

A char is a type in C# that’s similar to a string but is not identical. Here are some of the differences.

char letter = 'H';
var grade = 'B';

// ❌ Strings in C# must use double quotes (" ").
string acronym = 'HASL';

// ✅ A 'string' can have multiple characters.
string letters = "HA";

// ❌ 'char' can only store one character.
char multipleLetters = 'HA';

Tip: When looping through a string, each character in the string will be of type char.

Working with Strings

Strings in C# are immutable - once you create them, you can’t change them.

Let’s say the player in your game can carry a sword that deals elemental damage; the elements being fire, ice, and electricity.

They can toggle each element by pressing a button, and the UI should update accordingly.

If you have a string variable called activeElement that displays the active element, changing it from Fire to Ice doesn’t update the string - it creates a new one and assigns it to activeElement.

var elementalDamage = "Fire";

// Assume player changed element.

elementalDamage = "Ice"; // ❔ This creates a new string.

// Assume player changed the element again.

elementalDamage = "Electricity"; // ❔ Another string is created.

A new string is created because strings are immutable - you can’t change them - so you now end up with two strings in your Unity game’s code, but are only using one.

Constantly changing strings in this way can harm your game’s performance because unused strings still consume resources.

You could store the elements in the three different constants, then switch between them instead of constantly updating one string variable.

// Enums can work too, but that's covered later.

const string Fire = "Fire";
const string Ice = "Ice";
const string Electricity = "Electricity";

// Classes are covered in detail later, but
// just go with this for now.
var viking = new Player();

// Assume the player changed the element.

viking.ElementalDamage = Fire;

// Player changed element again.

viking.ElementalDamage = Ice;

An enum could also work in this case, but that is covered in more detail in a separate article.

StringBuilder

C# has a built-in type called a StringBuilder you can use for many string changes with a significantly reduced performance cost.

For example, if you want to add up to 5 stars at the end of the player’s name if they complete a level perfectly, you can use StringBuilder to append the stars next to the player’s name.

using System.Text; // This line is required.

var sonicResult = new StringBuilder("Sonic");

// A loop can work here.
// Lines below are repeated for demo purposes.

sonicResult.Append("⭐");
sonicResult.Append("⭐");
sonicResult.Append("⭐");

Debug.Log(sonicResult); // Logs 'Sonic⭐⭐⭐'.

The process of joining strings together is called concatenation.

Aside from StringBuilder, you can also use the + operator to join two or more strings.

Using the operator is fine for joining a few strings, but it isn’t as performant as StringBuilder for many string operations.

var firstWord = "San";
var space = " ";
var secondWord = "Andreas";

// Logs 'San Andreas'.
Debug.Log(firstWord + space + secondWord);

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

Interpolated Strings

Let’s say you have the word “wood” and a number next to it in your Unity game’s UI. Every time the player collects some wood, the number should increase.

You can use an interpolated string to display both the number and the word “wood” such that as the number changes, the string shows the updated number.

Tip: Interpolated strings are part of format strings - strings whose content is determined dynamically when the game is running.

Interpolated strings must begin with a $, and the variable counting wood collected must be surrounded by curly braces “{ }”.

var totalWood = 10;

// Logs 'You have 10 wood in your inventory'.
Debug.Log($"You have {totalWood} wood in your inventory.");

totalWood += 20; // Player picked up '20' wood.

// Logs 'You have 30 wood in your inventory'.
Debug.Log($"You have {totalWood} wood in your inventory.");

This is different from assigning a string variable a new value and doesn’t have as big a performance hit.

Escape Characters

If you try writing double quotes inside a string, you’ll get an error because C# doesn’t understand all the double quotes you’re using - all it knows is that a string should only have double quotes at the beginning and end.

You may also notice that pressing Enter when creating a string variable doesn’t move the text to the next line in your game.

These unique characters that behave differently when placed inside a string are called escape characters.

Tip: Pressing Enter, Space, or Tab creates a character. You can’t see it, but it’s there.

To use them in a string, you must place a backslash “\” before them.

For example, you can add a backslash to the double quotes in your string variable so it’s displayed correctly when the NPCs in your game are quoting words someone else said.

If you want text to move to the next line, you can add \n where you want the new line to begin.

// ❌ Doesn't work! You must escape double quotes inside string.
var npcDialogue = "The dragon said, "Bring me a sacrifice!"";

// ✅ No errors here.
var npcDialogue = "The dragon said, \"Bring me a sacrifice!\"";

Debug.Log(npcDialogue); // The dragon said, "Bring me a sacrifice!"

The act of adding a backslash before characters is called “escaping the characters”.

If you want to include a literal backslash in your string variable, you’ll also need to escape it.

Verbatim Strings

If placing backslashes sounds tedious, you can use a string variation known as a verbatim string.

Replace the backslash before a double quote in a string with another double quote in a verbatim string, and both work the same.

You can also press Enter to move text to the next line instead of writing \n.

var regularString = "The dragon said, \"Bring me a sacrifice!\"";

// ❔ Verbatim string doesn't need '\'. It replaces it with an extra double quote.
var verbatimString = @"The dragon said, ""Bring me a sacrifice!""";

Debug.Log(regularString);
Debug.Log(verbatimString);

// Both these strings will log the following:
// The dragon said, "Bring me a sacrifice!"

If you want to eliminate most of the extra formatting, you can use a raw string literal that lets you write escape characters as usual.

Raw string literals start and end with three double quotes.

// ✅ '\' doesn't need to be escaped.
var rawStringLiteral = """Backslash can be put in here: \""";

// ❌ Causes an error. '\' must be escaped i.e. written as '\\'.
var regularString = "Backslash can be put in here: \";

Raw string literals have some rules you’ll need to follow to prevent causing errors in your game’s code.

Tip: You can also insert variables inside verbatim strings and raw string literals by starting with $ and wrapping the variable in curly braces “{ }”.

Some Useful String Methods

Methods are covered in more detail in a separate post, but it’s worth mentioning some of them now to give you more context on how to better work with strings.

Here are some useful built-in string methods you’ll use when making a game in Unity.

• StartsWith(): checks if a string starts with a specified character or word.

• EndsWith(): checks if a string ends with a specified character or word.

• Trim(), TrimEnd(), TrimStart(): removes spaces from the string’s beginning and end, the end alone, or the beginning alone, respectively.

• Split(): splits the string into words or characters.

• ToUpper(), ToLower(): converts all the letters to uppercase or lowercase, respectively.

var game = "Stardew Valley";

Debug.Log(game.StartsWith("v")); // Logs 'false'.
Debug.Log(game.EndsWith("y")); // Logs 'true'.

Debug.Log(game.ToUpper()); // Logs 'STARDEW VALLEY'.
Debug.Log(game.ToLower()); // Logs 'stardew valley'.

var assassin = " Ezio Auditore ";

Debug.Log(assassin.TrimEnd()); // Logs ' Ezio Auditore'.
Debug.Log(assassin.TrimStart()); // Logs 'Ezio Auditore '.
Debug.Log(assassin.Trim()); // Logs 'Ezio Auditore'.

Recap

• Strings in C# are used when working with text.

• They are immutable - once you create them, you can’t change them.

• Use the StringBuilder class when making many string changes for better performance.

• Escape characters in a string are characters that must have a backslash “\” before them to work correctly.

• You can use interpolated strings for values that change while the game is running.

This post is the fifth in a series breaking down common C# concepts used in game development with the Unity Game Engine.

The next one discusses how to use booleans and is a prerequisite for working with conditional statements.

If you feel comfortable with strings and are ready for the next challenge when working with text, check out regular expressions.

Here’s the full list of posts in the series:

1. A Game Developer’s Guide to Variables in C#
2. A Game Developer’s Guide to Constants in C#
3. A Game Developer’s Guide to Numbers in C#
4. A Game Developer’s Guide to Operators in C#
5. A Game Developer’s Guide to Strings in C# (you are here)
6. A Game Developer’s Guide to Booleans in C#
7. A Game Developer’s Guide to Enums in C#
8. A Game Developer’s Guide to Conditional Statements in C#
9. A Game Developer’s Guide to Loops in C#
10. A Game Developer’s Guide to Classes in C#
11. A Game Developer’s Guide to Access Modifiers in C#
12. A Game Developer’s Guide to Fields & Properties in C#
13. A Game Developer’s Guide to Methods in C#
14. A Game Developer’s Guide to Lists & Arrays in C#
15. A Game Developer’s Guide to Dates & Times in C#

Numbers in C# can be generally categorized into two types: whole numbers, also known as integers, and decimal numbers, also referred to as floating-point numbers.

This article assumes you have a basic understanding of variables and constants. If you’re not familiar with them, read the linked posts first.

If you’re a visual learner, you can watch the video version below.

How do you create a number in C#?

Numbers already exist in C#, so you don’t have to re-create them.

A common approach is to store them in variables or constants and use them in mathematical operations like addition, subtraction, etc.

int one = 1;

int two = 2;

var three = 3;

const float Four = 4.0f;

Mathematical operations are discussed in more detail in the operators article.

Whole Numbers (Integers)

Whole numbers in video games work well with anything that increases or decreases in fixed steps of one or more, such as ammo, player lives, or coins collected.

If the player fires their gun, the remaining ammo decreases by one.

If they hold down the fire button to empty the clip, the ammo continuously decreases by one until it reaches zero, and they run out of ammunition.

When the player picks up ammo, the number jumps to a fixed whole number, such as 25, not 25.5. The same applies to losing and gaining lives.

There are multiple integer types in C# you can use, but the following are the five most common ones that will most likely apply to the Unity game you’re building.

sbyte

An sbyte is one of the smaller integer types that stores numbers from -128 to 127. Trying to store any number less than -128 or greater than 127 will result in an error.

sbyte age = 23;

var remainingLives = 3; // ❌ You have to use 'sbyte' instead of 'var'.

const sbyte Health = 100;

public class Elf
{
    private sbyte _mana = 100;

    // ... Other code about the class goes here.
}

sbyte shields = 200; // ❌ 'sbyte' can only go up to 127.

If the player in your game can have at most 3 lives, an sbyte would be a good option because it covers the range of lives, 0 to 3, while taking up little space: 1 byte.

You could also use it for character ages in a role-playing game since humans rarely live past the age of 127.

byte

A byte is another small integer type capable of storing numbers from 0 to 255.

It also takes up 1 byte of space.

byte shields = 200;

var speed = 25; // ❌ You have to use 'byte' instead of 'var'.

const byte DamageMultiplier = 150;

public class Dwarf
{
    private byte _maxAge = 250;

    // ... Other code about the class goes here.
}

byte income = 1000; // ❌ 'byte' can only go up to 255.

If you want a little more breathing room than an sbyte offers without using up too much extra space, a byte is a good choice.

For example, if your fantasy characters can live up to 250, then you can store their age in a byte instead of an sbyte.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

short

A short, sometimes written as Int16, has a capacity of -32,768 to 32,767.

This could be useful if, for instance, the maximum amount of wood or steel the player can harvest is 20,000 units.

short woodCollected = 732;

Int16 potatoesCollected = 658;

var steel = 800; // ❌ You have to use 'short' instead of 'var'.

const short MaxDamage = 1500;

public class SteelMill
{
    private short _capacity = 20000;

    // ... Other code about the class goes here.
}

short missionReward = 50000; // ❌ 'short' can only go up to 32,767.

Simply put, if you need a number that can reach the low thousands, a short is a good candidate.

It takes up 2 bytes of space.

int

An int, also written as Int32, is one of the most commonly used integer types. It has a capacity of about -2.1 billion to around 2.1 billion.

Its large capacity makes it ideal for games with giant economies where numbers can reach the billions.

int income = 100000;

Int32 grenades = 20;

// ✅ You can use 'var' with a WHOLE number only for 'int' type.
var steel = 800;

const int MaxSpeed = 250;

public class Bank
{
    private int _capacity = 200000000;

    // ... Other code about the class goes here.
}

It takes up 4 bytes of space, so if your game is performance-critical and you don’t need the large range, one of the smaller types would be a better choice.

long

A long, also written as Int64, is another one of the larger integer types, surpassing the billions.

long totalXP = 1000;

Int64 weaponSkill = 5;

// ✅ You can use 'var' only with numbers BIGGER than what an 'int' can hold.
var regionIncome = 8000000000;

const long MaxLevel = 200;

public class City
{
    private long _totalPopulation = 100000000;

    // ... Other code about the class goes here.
}

A long takes up 8 bytes of space due to its much larger range compared to the other integer types.

You may notice some performance dips as your video game grows when working with numerous long type numbers, so use it with discretion.

You’ll more often than not be fine using an int over a long.

Decimal Numbers (Floating-point Numbers)

Decimal numbers in video games work well when dealing with numbers that require greater precision, such as health bars in the user interface or aiming angles.

If the player in your game needs to throw an object, it’s a much better experience if they can aim in small, fine movements instead of janky, snappy motions, in some games at least.

C# has three floating-point types to help you achieve this.

Tip: You can still use floating-point types with whole numbers, but you can’t use integer types with decimal numbers.

float

Probably the easiest to remember since it uses the same first four words as floating, a float, also known as a Single, is the smallest of the three.

A float number must end with an “f” or “F” if it’s a decimal, but the suffix can be omitted when using whole numbers.

float currentProgress = 76.8f;
float inventoryItems = 30;
float angle = 22.5; // ❌ Number must end with 'f'/'F' if it's a decimal.

Single checkpoints = 10;
Single healthRemaining = 1.7F;

// ✅ You can use 'var' ONLY if the number ends with 'f'/'F'.
var xpLost = 20000f;

const float Rotation = 45.0f;

public class Throwable
{
    private float _defaultArc = 63.5F;

    // ... Other code about the class goes here.
}

It has a capacity in the billions on the positive and negative sides and uses up 4 bytes of space.

This is the least accurate of the three, but it works fine for the majority of games you’d want to make in Unity.

double

A double is larger than a float and is the default type used with decimal numbers that don’t end with a letter.

double airplaneYaw = 76.8d;
double totalFuel = 1000;

// ✅ Adding 'd'/'D' to decimal numbers is optional.
double remainingDistance = 22.5;

// ✅ Decimal numbers default to 'double' type
// if there's no letter after the number.
var fuelCostPerMile = 200.50;

const double BankingAngle = 75.0D;

public class Airplane
{
    private double _cost = 200000000.00d;

    // ... Other code about the class goes here.
}

It has a capacity exceeding the billions and uses up 8 bytes of space. A double type number can optionally end with “d” or “D”.

You can think of it as a middleground between the float and decimal, balancing precision and performance.

It could work in your game, but the extra precision might be an unnecessary trade-off for the extra space it consumes.

decimal

The most accurate of the three, a decimal type, is great for games with elaborate banking systems and economies that need numbers to be as precise as possible.

decimal housingCost = 100000.00m;
decimal interestRate = 32.625M;

// ❌ Numbers must end with 'm'/'M'.
decimal profitMargin = 1.0923;

// ✅ You can use 'var' if the number ends with 'm'/'M'.
var losses = 147325.098321m;

const decimal RevenuePerCustomer = 22.76530M;

public class Country
{
    private decimal _debt = 200000000.525m;

    // ... Other code about the class goes here.
}

A decimal type, in exchange for the extra precision, uses up the most space at 16 bytes. This extra memory consumption is more noticeable as your game grows.

Numbers of type decimal must end with an “m” or “M”. The accuracy is most noticeable when rounding decimal numbers.

If accuracy is fundamental to the Unity game you’re building, the tradeoff could be worth it.

float vs. double vs. decimal: Which to Use?

The one you choose will depend on how accurate you want your numbers to be versus how performant your game is.

A float is sufficient for most games, ranging from simple platformers to complex 3D adventure games. The added accuracy of the other types won’t always add value to your game.

A decimal is great in money-oriented games for an extra layer of realism, but this extra detail may go unnoticed, and you end up using up more resources for something that could’ve used less had you gone with a different type.

Tip: If you don’t assign a value to a number variable, whole or decimal, the number defaults to 0.

Why can’t you use commas to separate big numbers in C#?

Commas are used to separate a group of items in lists, arrays, and other types. Using them to separate large numbers in C# will cause an error.

You can use an underscore in place of the commas to separate large numbers into a more human-readable format.

int oneBillion = 1,000,000,000; // ❌ Doesn't work!

int oneBillion = 1_000_000_000; // ✅ No issues here.

The underscore is a digit separator. The computer will still read the number correctly if you use it.

Recap

• Numbers in C# can generally be classified as whole (integer) or decimal (floating-point) numbers.

• sbyte, byte, short, int, and long are used with whole numbers only.

• float, double, and decimal are used with decimals, but can also be used with whole numbers.

• The larger its range or the more accurate a number is, the more space it uses up.

• A decimal number created with var and no suffix defaults to the double type.

This post is the third in a series breaking down common C# concepts used in game development with the Unity Game Engine.

The next one discusses how to use numbers in mathematical operations, such as addition and subtraction, using operators.

Here’s the complete list:

1. A Game Developer’s Guide to Variables in C#
2. A Game Developer’s Guide to Constants in C#
3. A Game Developer’s Guide to Numbers in C# (you are here)
4. A Game Developer’s Guide to Operators in C#
5. A Game Developer’s Guide to Strings in C#
6. A Game Developer’s Guide to Booleans in C#
7. A Game Developer’s Guide to Enums in C#
8. A Game Developer’s Guide to Conditional Statements in C#
9. A Game Developer’s Guide to Loops in C#
10. A Game Developer’s Guide to Classes in C#
11. A Game Developer’s Guide to Access Modifiers in C#
12. A Game Developer’s Guide to Fields & Properties in C#
13. A Game Developer’s Guide to Methods in C#
14. A Game Developer’s Guide to Lists & Arrays in C#
15. A Game Developer’s Guide to Dates & Times in C#

As the name suggests, a constant is a value that stays the same after it is created. It can only be updated in one place: where you created it.

If the player in your game can only carry a maximum of 20 items in their inventory, you can store that number in a constant so you don’t accidentally change it somewhere else in the code.

Constants are fundamental to any video game and are often used with variables, whether in handwritten code or visual scripting tools.

How do you create a constant in C#?

There are four simple steps to creating a constant.

1. Write the keyword const.
2. Write the constant’s type.
3. Write the constant’s name.
4. Give the constant a value.

// 'int' is the type.
// 'MaxAmmo' is the name.
// '30' is the value.
const int MaxAmmo = 30;

const int Lives = 3;

const string Name = "Ellie";

const bool IsFirefly = true;

The constant’s type can be any of the built-in types in C#, such as int, string, or bool. Unlike variables, you can’t use a class you created as a constant’s type.

Tip: The act of creating a constant is also known as “declaring a constant”.

The name you give a constant can be anything, but there are limitations and naming conventions you should be aware of. These are discussed below.

A constant is assigned a value using one equal sign (=) after the constant’s name, followed by the value. The type will determine how the value is written.

String Constant

A string constant is written using two double quotes (“”) and, optionally, characters between them. Strings in C# are used to work with text.

const string Hero = "Doomfist";

const string Role = "Tank";

const string Ultimate = "Meteor Strike";

Boolean Constant

A boolean constant is written using either the true or false keywords. Booleans are like on/off switches that toggle different parts of your code on or off.

const bool IsPlayerOne = true;

const bool HasStealthCamo = false;

const bool ShouldAttack = true;

Number Constant

A number constant is written as a regular number with no extra formatting.

const int DamageMultiplier = 3;

// 'decimal' is a type used with decimal numbers.
// It usually ends with an 'm'.
const decimal Income = 250.00m;

const int MaxItems = 10;

Numbers are used with anything that needs to be counted or when you need to perform mathematical operations like adding, subtracting, etc.

Where should you put constants?

Constants can be written in methods or inside a class’s body.

Unlike variables, constants declared in a class’s body are still constants - they don’t have a special name.

// Classes you create will often be in a separate file.
// It's included here with the other code for demo purposes.

public class Enemy
{
    // A constant inside the 'Enemy' class.
    const int Health = 50;

    public void Attack()
    {
        Debug.Log("Enemy swung their sword.");
    }
}

// The class below is a 'Player' script created in Unity.
public class Player : MonoBehaviour
{
    void Start()
    {
        // A constant inside the 'Start' method.
        const string StartupMessage = "The game has started.";
    }
}

Assume you opened a script in Unity called Player.cs in your preferred editor: Visual Studio, Visual Studio Code, or JetBrains Rider.

public class Player : MonoBehaviour
{
    void Start()
    {
        const string name = "Crash Bandicoot";

        Debug.Log(name);
    }
}

You can create a constant inside the Start method and log it to the Unity console. Try doing so and observe the console after pressing play.

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

Variables vs. Constants: What’s the Difference?

Constants and variables have many similarities but are not identical.

• You have to explicitly type const before every constant.

You can use the var keyword with variables in place of the type, but constants follow a stricter format where both the word const and the type must be included.

var sbyte MaxLives = 3; // ❌ Can't use 'var' with constants.

const sbyte MaxLives = 3; // ✅ The correct way to declare a constant.

• Constants can’t be changed after they’re created.

A variable can be assigned a new value at a different part of your game’s code, but a constant cannot.

If you want to update a constant’s value, you can only do so where the constant is declared.

const int MaxAmmo = 40;

// Assume the player just picked up some ammo.

MaxAmmo = 50; // ❌ Won't work. You'd have to change it above.

• Constants are named using Pascal Case notation.

Variables are named using camel case notation, while constants use Pascal case notation.

In Camel Case notation, the first letter of the first word is lowercase, and the first letter of every word after is uppercase e.g. rotationSpeed.

In Pascal Case notation, the first letter of every word is uppercase.

const int MaxInventoryItems = 20;

const string Rank = "Elite";

const decimal MinSpeed = 5.0m;

• You can’t use classes as a constant’s type.

A variable can use both the built-in types in C# and classes you create as the type, but a constant can only use the built-in types.

public class Enemy
{
    public void Attack()
    {
        Debug.Log("Enemy swung their sword.");
    }
}

Enemy ogre = new Enemy(); // ✅ Class type works with variables.

const Enemy Cyclops = new Enemy(); // ❌ Causes an error.

• Constants must have a value when they’re created.

A variable can be declared without assigning a value to it, while a constant must have a value when you create it.

You’ll need to assign a value to the variable at some point, but this difference shows the fluidity you have with variables compared to constants.

int healthPotions; // ✅ Can be declared without value.

var magicPotions; // ❌ Can't use 'var' without assigning a value.

const int FireDamage; // ❌ Constants must have a value.

Debug.Log(healthPotions); // ❌ Error: Use of unassigned variable.

Variables work better for values you want to adjust through certain actions in your Unity game, such as the player’s speed, health, or ammo.

Constants work better for values you want to stay the same throughout the entire game, such as the player’s jump height in a realistic game, or the maximum number of enemies that can spawn in an area.

How do you use constants in C#?

Since constants “store” values temporarily, you can reference that “stored” value any time by typing the constant’s name.

Let’s say you’re making a game where the player has a fixed health amount, and picking up armor increases it temporarily.

You’ll first create a constant called PlayerHealth and set it equal to any number. Let’s use 100 for this example.

Next, log the number to the console three times while adding a separate number representing the strength of each armor piece picked up.

The output on the console will be as follows.

const int PlayerHealth = 100;

// Assume the player just picked up light armor worth 25HP.

Debug.Log(PlayerHealth + 25); // Logs '125'.

// Assume the player just picked up medium armor worth 50HP.

Debug.Log(PlayerHealth + 50); // Logs '150'.

// Assume the player just picked up heavy armor worth 75HP.

Debug.Log(PlayerHealth + 75); // Logs '175'.

Using a constant here gave you three benefits:

1. You didn’t have to repeat 100. You can use the PlayerHealth constant where the number should be, and it’s like the actual number is there instead.
2. The constant’s name provided more context. Repeating 100 raises questions. Why is that number used in multiple places? What is it for? Why is it not another number like 50 or 90?
3. You don’t have to worry about accidentally changing the player’s health. Using a constant ensures the player’s health will always be 100.

If you tried changing the PlayerHealth constant, for example, by setting it equal to 125, you’ll get an error, and the code won’t run.

const int PlayerHealth = 100;

// Assume the player just picked up light armor.

PlayerHealth = 125; // ❌ Not allowed!

Debug.Log(PlayerHealth); // This won't be executed.

Tip: Hover over a constant’s name in Visual Studio or Visual Studio Code to see its type. This is useful in larger projects with many constants, and you want to know a particular constant’s type.

Best Practices When Working with Constants

• Ensure your constants are written using Pascal Case notation.

This makes your game’s code consistent with C# best practices and makes it easier to collaborate with other game developers since you’ll be using a convention they’re familiar with.

• Avoid naming constants after special keywords in C#.

You can’t name a constant after one of the special keywords in C#.

If you adhere to the Pascal case naming convention, you can name constants after special keywords in C#, like return or foreach.

If you ignore it and use lowercase letters for your constant names that are identical to special keywords, you’ll get an error, and your video game’s code won’t run.

const int return = 100; // ❌ Doesn't work!

const int Return = 100; // ✅ Works fine.

You often don’t need to name a constant after a keyword, so this won’t be an issue 99.9% of the time.

In the extreme case you have no choice but to name a constant after a special keyword, you’ll need to add an underscore at the beginning so C# doesn’t confuse it with the special keywords.

• Give your constants meaningful and descriptive names.

Avoid naming constants using one letter or a combination of letters that makes no sense.

For example, if you have a constant representing the player’s health, name the constant Health instead of just H.

A letter may work as a constant name when the constant represents a coordinate, such as the z-axis; however, a more effective approach is to use the letter and the word “axis”.

Tip: Try to keep constant names one to three words long. When in doubt, a longer descriptive constant name is always better than a shorter one that makes no sense.

const int H = 100; // ❌ Avoid! What does 'H' stand for??

const int Health = 100; // ✅ Clearer and more descriptive.

const decimal CurrBal = 1000.00m; // ❌ Needs work. Not clear enough.

const decimal CurrentBalance = 1000.00m; // ✅ There you go!

const int z = 20; // ❔ Might work, but still vague.

const int ZAxisDisplacement = 20; // ✅ Splendid!

• A constant’s name cannot begin with a number or be composed of numbers alone.

Doing so will result in an error, and the code won’t run.

If you must use a number, it should be at any position other than the beginning. There are some limitations when using special characters in constant names.

const string 1Player = "Phoenix"; // ❌ Causes an error!

const string Player1 = "Phoenix"; // ✅ Number can be at the end.
const string Pla2yer = "Fade"; // ✅ Number can also be in the middle.
const string P3layer = "Brimstone"; // ✅ Or as the second character.

const string G#ame = "Valorant"; // ❌ Special characters not allowed anywhere...

const string G_ame = "Valorant"; // ✅ except underscores and...

const string @Game = "Valorant"; // ✅ an '@' sign at the BEGINNING ONLY.

• Boolean constants often start with “is” or “has”.

A boolean constant can only be true or false, so appending “is” or “has” at the beginning makes it look like a question whose response is one or the other.

Given that booleans are like on/off switches to enable/disable different parts of your Unity game’s code, they’ll need to change often, so a variable might be a better choice.

Regardless, if you find a scenario where you need a boolean constant, it’s good practice to append “is” or “has” to its name.

const bool IsOnMission = true;

// A sneak peek into conditional statements.
if (IsOnMission)
    Debug.Log("Good luck, Soldier.");

You don’t always have to start boolean constants with “is” or “has” - it’s merely a recommendation for the sake of consistency.

If using these prefixes makes the constant more confusing or if a different name works better, you can name it something else.

For example, you can name the constant PlayerIsAlive instead of IsPlayerAlive if you prefer, or use Enraged instead of IsEnraged.

You’ll see how these names make understanding code easier when you start working with conditional statements.

What’s the difference between a constant and a readonly variable?

You can only mark a variable as readonly when it’s declared inside a class’s body and not inside a method. These kinds of variables are known as fields.

A readonly variable is similar to a constant in that its value also cannot be changed after creation - in most places, at least.

The main difference is that a constant’s value can’t be changed anywhere in your game’s code except where it’s declared, while a readonly variable’s value can be changed in two places:

1. Where it’s declared.
2. In the class’s constructor.

public class Enemy
{
    // This is a variable in the class's body i.e. a field.
    private readonly string _type;

    const int Health = 50;

    // This is a class's constructor.
    public Enemy()
    {
        _type = "Tank"; // ✅ 'readonly' variable can be changed here.

        Health = 100; // ❌ Constant can't be changed here.
    }

    public void Attack()
    {
        _type = "Assault"; // ❌ Can't change it in a method.

        Health = 200; // ❌ Can't change constant here either.

        Debug.Log("Enemy swung their sword.");
    }
}

Classes, fields, and modifiers, such as readonly, are discussed in more detail in separate articles.

Recap

• Constants are like mini-storage locations to store temporary data.

• They’re named using Pascal Case notation.

• A constant’s value can only be changed where it’s declared but remains the same throughout your game.

• Constants can be declared inside methods or in a class’s body.

• They must start with the word const.

This article is the second in a series breaking down common C# concepts used in game development with the Unity Game Engine.

The next one discusses numbers and their role in your game’s code.

Here’s the complete list:

1. A Game Developer’s Guide to Variables in C#
2. A Game Developer’s Guide to Constants in C# (you are here)
3. A Game Developer’s Guide to Numbers in C#
4. A Game Developer’s Guide to Operators in C#
5. A Game Developer’s Guide to Strings in C#
6. A Game Developer’s Guide to Booleans in C#
7. A Game Developer’s Guide to Enums in C#
8. A Game Developer’s Guide to Conditional Statements in C#
9. A Game Developer’s Guide to Loops in C#
10. A Game Developer’s Guide to Classes in C#
11. A Game Developer’s Guide to Access Modifiers in C#
12. A Game Developer’s Guide to Fields & Properties in C#
13. A Game Developer’s Guide to Methods in C#
14. A Game Developer’s Guide to Lists & Arrays in C#
15. A Game Developer’s Guide to Dates & Times in C#

Variables are fundamental to any video game and make up a large percentage of the code you’ll write, whether by hand or using visual scripting tools.

If you’re a visual learner, you can watch the video version of this post below.

How do you create a variable in C#?

There are three simple steps to creating a variable.

1. Write the variable’s type.

2. Write the variable’s name.

3. Give the variable a value.

// 'int' is the type.
// 'number' is the name.
// '1' is the value.
int number = 1;

int anotherNumber = 2;

string name = "Tom";

bool isLearning = true;

The variable’s type can be one of the pre-existing types in C#, such as int, string, or bool, otherwise known as primitive types, or types you create via classes.

Tip: The act of creating a variable is also known as “declaring a variable”.

Even though you can give the variable any name you want, there are certain restrictions to keep in mind and naming conventions you should be aware of. These are discussed below.

A variable is assigned a value using one equal sign (=) after the variable’s name, followed by the value. Different types have their values written in different ways.

String Variables

A string is written using two double quotes (“) and, optionally, characters between them. Strings in C# are used to work with text.

string name = "Kratos";

string hometown = "Sparta";

string son = "Atreus";

Boolean Variables

A boolean value is written using either the true or false keywords. Booleans are like on/off switches that toggle different parts of your code on or off.

bool isOnline = true;

bool isCooking = false;

bool hasInternet = true;

Number Variables

A number value is written as a regular number with no extra formatting.

Numbers are used with anything that needs to be counted or when you need to perform mathematical operations like adding, subtracting, etc.

int lives = 3;

// 'float' is a type used with decimal numbers.
float speed = 0.0f;

int attackDamage = 499;

Custom Variable Types

The types you create will often be from the classes you also create.

For example, if you create a Weapon class to handle weapons in your game, you can store one “copy”, commonly called an instance, in a variable.

// Classes you create will often be in a separate file.
// It's included here with the other code for demo purposes.
public class Weapon
{
    private int _damage;

    public void Upgrade()
    {
        Debug.Log("Weapon upgraded to Level 2 damage.");
    }
}

// The class below is a 'Player' script created in Unity.
public class Player : MonoBehaviour
{
    void Start()
    {
        // 'axe' and 'sword' are variables.
        Weapon axe = new Weapon();
        Weapon sword = new Weapon();
    }
}

Classes are discussed in more detail in a separate post.

Where should you put variables?

Variables are often written inside methods, but they can also be created inside a class’s body. Variables created in a class’s body have another name: fields.

public class Weapon
{
    // This is a variable in the class's body i.e. a field.
    private int _damage;

    public void Upgrade()
    {
        // A variable in the 'Upgrade' method's body.
        int currentLevel = 1;

        Debug.Log("Weapon upgraded to Level 2 damage.");
    }
}

Fields are often used with properties, another type of variable in the class’s body, to make games in Unity. These two are discussed in more detail in separate posts.

Speaking of Unity, the following code is what you see whenever you open a script in Visual Studio, Visual Studio Code, or JetBrains Rider. Assume the script you created is called Player.

public class Player : MonoBehaviour
{
    void Start()
    {
        string name = "Captain Price";

        Debug.Log(name);
    }
}

You can create a variable inside the Start method and log it to the Unity console. Try doing so and observe the console after pressing play. What do you think this code will log?

Interested in making games in Unity? Become a patron on Patreon and gain access to cheat sheets, behind-the-scenes content, advanced scripting videos, and more.

What is var? Why is it used with variables?

var is one of the special keywords in C#. It’s used when creating variables as a shorter and less repetitive way compared to constantly repeating a variable’s type.

Let’s say you wanted to create three strings to store a character’s first, middle, and last name.

You’d have to declare the string type before each of the variables, but with var, you don’t need to repeat it. You can also use it with other types, such as numbers and booleans.

string firstName = "Elena";
string middleName = "Joelle";
string lastName = "Fisher";

// Rewritten using 'var' keyword.
// These are all still 'string' types.

var firstName = "Elena";
var middleName = "Joelle";
var lastName = "Fisher";

Using var instead of manually writing each variable’s type comes down to personal preference.

If you’re working on a project with others, there might be documentation outlining which approach to use, so it’s best to consult it.

If you’re working on a personal project, you can use var, explicitly declare the types, or use a mix of both. Using both is safe and won’t cause bugs.

By using var, you’re telling the C# compiler to figure out what the variable’s type is based on what you write on the right side of the equal sign.

If you used the correct syntax, for example, double quotes for strings, the compiler will recognize that you want to use a string and assign the type for you behind the scenes.

Tip: Hover over a variable’s name in Visual Studio or Visual Studio Code to see its type. This is useful in larger projects with many different variables when you want to know a particular variable’s type.

Some of the other special keywords in C# include return, used in methods, for, while, and foreach, used in loops, and public, used to modify access to different parts of your code.

How do you use variables in C#?

Since variables “store” values temporarily, you can reference that “stored” value any time by typing the variable’s name.

Let’s say you want to log different variations of a speed multiplier to the Unity console, for example, the number multiplied by two, three, four, etc.

You’ll first create a variable called speedMultiplier and set it equal to any number. Let’s use 1 for this example.

Next, log the number to the console three times while multiplying it by a separate number each time. The output on the console will be as follows.

// Can you guess what type this variable is?
// Hint: Look at the previous code in this post.
var speedMultiplier = 1;

Debug.Log(speedMultiplier * 2); // Logs '2'.

Debug.Log(speedMultiplier * 3); // Logs '3'.

Debug.Log(speedMultiplier * 4); // Logs '4'.

Using a variable here gave you two benefits:

1. You didn’t have to repeat 1. You can just use the speedMultiplier variable where the number should be, and it’s like the actual number is there instead.

2. The variable’s name provided more context. Repeating 1 raises questions. Why is that number used in multiple places? What is it for? Why is it not another number like 12 or 91?

You can also change variables any time if you want. Let’s say the speed multiplier is supposed to increase to 3 every time the player picks up a speed booster.

To do so, update the speedMultiplier by changing the number to the right of the equal sign. This is also called “assigning it a new value”.

var speedMultiplier = 1;

// Assume the player just picked up a speed booster.

speedMultiplier = 3;

Debug.Log(speedMultiplier); // Logs '3'.

Variables can be used in multiple ways, but these two are common and provide a good starting point for using variables during game development in the Unity Game Engine.

Best Practices When Working with Variables

• Variables in C# are written using camel case notation, where the first letter of the first word is lowercase, and the first letter of each word after that is uppercase.

string title = "Big Boss";

float gameProgress = 46.7f;

var assaultRifle = new Weapon();

• You can’t name a variable after one of the special keywords in C#.

Trying to do so will result in an error, and your video game’s code won’t run.

You often don’t need to name a variable after a special keyword, so this won’t be an issue 99.9% of the time.

In the extreme case you have no choice but to name a variable after a special keyword, you’ll need to add an underscore at the beginning so C# doesn’t confuse it with the special keywords.

int return = 2; // ❌ Doesn't work!

int _return = 5; // ✅ Much better.

• Give your variables meaningful and descriptive names.

Avoid naming variables using one letter or a combination of letters that makes no sense.

For example, if you have a variable representing a player’s speed, name the variable speed instead of just s.

A letter may work as a variable name when the variable represents a coordinate, such as the x or y axis; however, a more effective approach is to use the letter and the word “axis” e.g. xAxis.

Tip: Try and keep variable names one to three words long. When in doubt, a longer descriptive variable name is always better than a shorter one that makes no sense.

float s = 10.0f; // ❌ Avoid! What does 's' stand for??

float speed = 10.0f; // ✅ Cleaner and more descriptive.

int ammCnt = 100; // ❌ Needs work. Not clear enough.

int ammoCount = 100; // ✅ Now we're talking!

int x = 25; // ❔ Might work, but still vague.

int xAxisDisplacement = 25; // ✅ Perfect!

• A variable’s name cannot begin with a number or be composed of numbers alone.

Doing so will result in an error, and the code won’t run.

If you must use a number, it should be at any position other than the beginning.

There are some limitations when using special characters in variable names.

string 1name = "Ikora"; // ❌ Causes an error.

string name1 = "Ikora"; // ✅ Number can be at the end.
string na1me = "Rey"; // ✅ Number can also be in the middle.
string n1ame = "Destiny"; // ✅ Or as the second character.

var n?me = "Ikora"; // ❌ Special characters not allowed anywhere except...

var n_ame = "Destiny"; // ✅ when the character is an underscore...

var @name = "Destiny"; // ✅ or an '@' sign at the BEGINNING ONLY.

• Boolean variables often start with “is” or “has”.

Given a boolean variable can only be true or false, appending “is” or “has” at the beginning makes it look like a question whose response is one or the other.

For example, if you want to know if the player has picked a power-up, you can create a boolean variable called hasPowerUp.

If the player hasPowerUp, then the variable is true, and you can boost the player’s attack damage.

If the player doesn’t have a power-up, then the answer to the “hasPowerUp?” question is false, so the player’s attack damage stays at the default number.

var attackDamage = 5;

var hasPowerUp = false;

// Here's a sneak peek into conditional statements.
if (hasPowerUp)
    attackDamage = 10;

You don’t always have to start boolean variables with “is” or “has” - it’s merely a recommendation for the sake of consistency.

If using these prefixes makes the variable more confusing or if a different name works better, you can name them something else.

For example, you can name the variable playerIsGrounded instead of isPlayerGrounded if you prefer, or use powerUpPicked instead of hasPowerUp.

You’ll see how these names make understanding code easier when you start working with conditional statements.

How can I practice using variables in C#?

You can practice using variables by logging different types of variables to the console and seeing how they appear, doing simple arithmetic and logging the result, or updating them in different ways.

Variables are one of the many concepts in the interconnected world of C#, so you’ll see more use cases the more you use the programming language.

Recap

• Variables are like mini-storage locations to store temporary data.

• They’re named using Camel Case notation.

• You can use var instead of a variable’s type when creating it.

• Variables are often declared inside methods but can be declared within a class’s body.

• Boolean variables often start with “is” or “has”.

Once you feel you have a good grasp of variables, read the next article on constants in C#.

This article is the first in a series breaking down common C# concepts used in game development with the Unity Game Engine.

The next one discusses constants and their role in your game’s code.

Here’s the complete list:

1. A Game Developer’s Guide to Variables in C# (you are here)
2. A Game Developer’s Guide to Constants in C#
3. A Game Developer’s Guide to Numbers in C#
4. A Game Developer’s Guide to Operators in C#
5. A Game Developer’s Guide to Strings in C#
6. A Game Developer’s Guide to Booleans in C#
7. A Game Developer’s Guide to Enums in C#
8. A Game Developer’s Guide to Conditional Statements in C#
9. A Game Developer’s Guide to Loops in C#
10. A Game Developer’s Guide to Classes in C#
11. A Game Developer’s Guide to Access Modifiers in C#
12. A Game Developer’s Guide to Fields & Properties in C#
13. A Game Developer’s Guide to Methods in C#
14. A Game Developer’s Guide to Lists & Arrays in C#
15. A Game Developer’s Guide to Dates & Times in C#