 📌 I've been using Git for over 10 years and it is my recommended version control system for the vast majority of projects. It empowers parallel development through branching and local repositories and is a great solution for projects with many mergeable files.
📌 For beginners, Git basically allows you to track and share versions of your project with the ability to rollback and check out any previous version you committed. An example: I implement a jump attack in the morning and commit my changes in Git. Another developer, Jeb pulls my changes but accidentally deletes some of my code. I can use Git to recover my changes without deleting Jeb's other changes. 📌 Git command line. After all these years, I have yet to find a Git GUI which can compete with the speed, power, and flexibility of the command line. Imagine pushing a branch to a remote origin while naming the branch a different name, this can all be done with one line. GUI's on the other hand, can be great for resolving merge conflicts. 📌 Binary conflicts are a common issue with Git. In game development, this is a common pain point since game projects have large binary assets. Git LFS supports large files and even has locking support, however locking is more complicated and harder to use than SVN or Perforce. It's common for a developer to use a Git GUI that does not support locking in the UI.
0 Comments
 Yes, this is a thing. Hold onto your butts and welcome to Tabs vs Spaces. The contrived but important argument.
📌 The thing to stress here is consistency and you should adhere to the standard for whatever project you're working on. 📌 For new projects, you should define a clear standard of whether tabs or spaces will be used. Alignment issues can be caused when you mix the two, just ask Python. 📌 Tabs can easily be customized by programmers, setting them to two, four, or please don't, eight space width. If you're not careful with your coding style, changing this setting may break text alignment in your codebase. e.g. function parameters being aligned with tabs and spaces. 📌 A programmer with poor eyesight may use larger font sizes and a smaller tab width to save screen space. This kind of adjustment can't be done using spaces. 📌 Spaces set a visual standard that will be consistent among all editors and external tools. You don't have to worry about 8 space tabs in your diff tool or Github. 📌 Tabs saving disk-space is negligible in 2020. 📌 Smart tabs can be used in may IDE's, allowing you to hit tab and automatically insert x amount of spaces for you. ⭐️ I've used both in different projects for many years and didn't find any real productivity boost from either. ⭐️ I've grown to really dislike alignment coding styles that you can use with spaces. I prefer indentation. ⭐️Many legacy projects and third party libraries have text alignment and use spaces. Dive into external code and it may appear incorrectly if you a different tab-width. ⭐️ Headaches come from people using different tab space width. Even with a style guide, alignment issues and spaces will slip through the cracks with many devs working on the same project over time. ⭐️ After 15 years of programming, my preference is smart tabs, tab-width 2. However, I'm flexible on the matter. Use the best tool for the job.  Writing your first script is like entering an unknown world. Whether you have programming experience or not, here are some general tips that can help you.
📌 When writing a MonoBehavior, the name of your class must match the filename exactly. If your script file is not named "PlayerController", then Unity will be unable to find the script. This becomes apparent when you can't add the script. 📌 GetComponent results need to be cached. GetComponent is not a performant call and thus you do not want to be calling it multiple times every frame. The better strategy is to cache your component in Awake or Start and then use the cached reference in the rest of the code. 📌 Attribute SerializedField allows you to reveal private variables in the Unity Editor. There is no need to make all your variables public. C# coding styles and good programming standards still apply. 📌 Serializing variables should only be done for objects that need to be linked through the Unity Editor. Whether it's playing an animation on an Animator or applying a force to a Rigidbody, this is how you will reference and control GameObjects in code. 📌 When things don't work, the first place to look is the Console in the Unity Editor. Forgot to link your serialized _rigidBody variable in the Editor, then Unity will throw an exception when that variable is dereferenced. 📌 Understand the dangers of static variables. MonoBehaviors are created and destroyed with the GameObject they are associated with. Any static variables you set may persist even after that object is destroyed. Be sure to clean up static variables. 📌 Make a Prefab: Scripts, like Prefabs, may be reused and added to many GameObjects. Most likely you'll be building a hierarchy of GameObjects with your script on the root GameObject. Try making a prefab and dropping multiple in your scene.  📌 Installation: Make sure all the correct modules are installed. Open Unity Hub, select a version of unity, select add modules, install Android Build Support, and be sure to toggle subfields Android SDK, NDK, and OpenJDK.
📌 If you run into any issues with the SDK path, you can always download and set the paths manually in the Preferences → External Tools. 📌 Target Android by going to File → Build Settings and switching your active target to Android. 📌 Player Settings will need to be set. Fill your company and product name. The version should be something like "1.0.0". 📌 Default Icon will be used if no other icons are set. However, you can easily set the icons for Adaptive, Round, and Legacy. Just drag an image into the highest resolution and Unity will automatically generate the lower resolution icons. 📌 Prevent your app for rotating to portrait or landscape inside the Resolution and Presentation settings. More global app settings can be found here. 📌 Other Settings contains the SDK version and graphics settings. It's here where you will define what graphics API's are supported, the minimum API level, and much more. Familiarize yourself with these settings because they'll determine what devices your game can run on and even how they will perform. 📌 Publish Settings - If you wish to upload to Google Play or Oculus, you'll need to use a custom keystore. Google Play has a feature that will automatically sign when you upload your APK, however, I still like to create my own keystore. This is easily done inside of Unity, just open Keystore Manager, and create a new keystore. 📌 Testing in Editor while targeting Android is very important. It is your first line of defense for detecting platform-specific issues. When targeting Android, platform-specific C# code will be compiled for Android, while code wrapped in directives like UNITY_IOS, will not be compiled. 📌 Build and deploy directly to a device within the build settings. Make sure Export Project is disabled, and you can build directly to an APK. 📌 When export project is enabled, it will not build an APK, but instead, create an Android Studio project. This is good for more advanced build pipelines, where you can not set all your desired settings in the Unity post-build scripts.  📌 Rigidbodies control an object's position and rotation through physics simulation.
📌 Simulating physics for a specific GameObject is as simple as adding a rigidbody component. 📌 Paired with a collider, modify the properties on your rigidbody to get it to behave as intended. 📌 Set the Mass, Drag, Angular Drag, and toggle gravity through the inspector windows. 📌 Is Kinematic - When enabled, forces, collisions, or joints will not affect the rigidbody. Movement must be controlled manually through a script. This is more advantageous than a collider alone because interpolation options are available and velocity is readable from the rigidbody. 📌 Interpolate - Allows you to smooth out the effect of running physics at a fixed frame rate. This means, the transform position and rotation will be updated every frame to be (smoothed out), however, the rigidbody won't be updated until the next physics frame. 📌 Collision Detection - Allows you to trade performance for better collision detection between physic frame updates. Use this for fast-moving objects or objects that constantly penetrate through thin walls or colliders. 📌 Moving a rigidbody is different from moving a transform. Rigidbodies can be teleported by setting rigidbody.position and you can interpolate between positions by using Rigidbody.MovePosition. Normal transform position adjustments will not update the rigidbody. It's easy to call the wrong method here, so make sure to move objects according to your needs. 📌 Constraints allow you to lock an object's rotation for a positional or rotational axis. This is a great feature for 2.5d games. 📌 Position, velocity, force, max velocity, and much more can be controlled through scripting. If learning, I recommend you create a scene with some objects and rigidbodies, and play around with them, it's fun.  Rating: 5/5 📌
This is a great book, it provides real coding examples along with various design patterns for game AI. It also covers how to balance AI that appears smart, but not too smart that it'll prevent the user from progressing. 📌 Mat Buckland, the author has a way with words and makes it easy to understand what he is saying. This book even has a math review/primer at the start, making it a great book for game dev beginners. 📌 Finite State Machines are commonly used in game development, and you'll find them in examples in this book. Equipped with a message-passing system and steering behaviors you'll see how the two interact together to make agents move in your game world. 📌 Agent-based design reveals how to create "agents" in your game environment, showing you how they sense their environment and make decisions using their own AI logic. 📌 Graphs are extensively covered in this book and although it was a review from college, you'll cover Dijkstra, A*, and graph navigation. Essential tools to building your own nav mesh or traversing it effectively. 📌 Goal-Driven Agent Behaviors is my favorite design pattern pulled from this book. Essentially you learn how to structure a high-level goal using a hierarchy of smaller goals. For example, if an agent wants to "Buy Sword", then the goal will add all prerequisite goals, like"Get Gold" and "Go to Blacksmith", and those goals will do the same until all the smaller executable goals are completed. 📌 C++, this is a pro for me but may be a con for you. The book provides all examples in C++, which is great because C++ is my favorite language. The code is very readable but outdated and you may quickly find yourself in a quick C++ tutorial if you don't have much experience. 📌 I read this early in my game development career and it resonated with me very well. I recommend it to game developers of all kinds.  Coroutines allow you to execute a sequence of code over multiple frames and empower you to write procedural animations and events over time.
📌 A normal method call, will run and return immediately when finished. 📌 A coroutine method call, can run, pause, run more later, and run to completion in later frame updates. Coroutines always execute on the main unity thread. 📌 Coroutines are great for coding a sequence of events over time. e.g. Playing an end screen animation: fill progress bar, wait, fly coins to the top, wait, fade in buttons. 📌 Coroutines have performance overhead, so you don't want to be starting hundreds every frame. However, invoking them once or twice per UI screen gives you all the benefits without the performance hit. 📌 yield return null - Pauses the coroutine and starts execution again the next frame, right after the Update call. 📌 yield return WaitForEndOfFrame - Pauses the coroutine and starts execution once the camera and GUI's are rendered this frame. 📌 yield return new WaitForSeconds - Pauses the coroutine and starts execution after x amount of seconds has passed. 📌 A common mistake is to abuse Coroutines and use them everywhere in your game. I rarely use Coroutines for anything besides the occasional UI animation sequence. 📌 Alternatives to Coroutines are Unirx, Async Methods, DOTween, and State Machines. 📌 Coroutines have gotten a bad wrap due to misuse. But they're a powerful tool when you invoke them carefully in your codebase.  📌 Stay organized by creating one class per file. Nested classes and structs are an exception.
📌 Use Pascal and Camel Case naming conventions: DoSomethingMethod() and localVariableName. 📌 Method names should inform the programmer exactly what they are doing: DashForward() and FireWeapon() 📌 Use arrays for sets of data that do not need to change in size. 📌 Use List<> for sets of data that change over time. Understand that methods like Insert() can have poor performance. 📌 Opt for a HashSet<> when you need an ordered set of keys. 📌 Dictionary<> should only be used when you have both key/value pairs. 📌 Strings are immutable, which means every string every created will allocate its own set of memory. 📌 StringBuilder should be used when concatenating strings in a loop. 📌 string.IsNullOrEmpty should be used instead of a null check. 📌 Use string interpolation to concatenate short strings: string message = $"Hello {nameList[n].FirstName}"; 📌 Shorten your conditional statements by using the operator ? 📌 Higher-level methods most likely mean less performance. LINQ provides powerful functionality like Where() and Select() which can be slow. 📌 Minimize Garbage Collection. Know which calls allocate on the heap; you probably don't want them called in tightly looped operations.  📌 In Unity, Time.deltaTime is the competition time in seconds since the last frame. Using deltaTime in your game is critical to getting things to move and update properly when the framerate fluctuates.
📌 Unity will execute at X frames per second (the default is 60). This means Update() and rendering will occur 60 times each second. For every frame, deltaTime is the time since the last frame. 📌 Time.timeScale can be assigned to slow down or speed up time. A value of 0.5 will cause your game to run 50% slower. In real-time, your game will still execute at 60 fps, however, Time.deltaTime will be increasing at 50%. 📌 Slow-motion effects can easily be invoked by assigning Time.timeScale and using Time.deltaTime in your calculations. 📌 Time.time is the seconds since the start of the game. Like Time.deltaTime, this value is affected by the timeScale. 📌 Time.unscaledDeltaTime is the interval in seconds since the last frame, however, this value is not affected by timeScale. This is great for updating objects that you don't want to be affected by slow-motion, like camera movement or HUD animations. 📌 Time.unscaledTime is the seconds since the start of the game, but unaffected by the timeScale. 📌 Time.fixedDeltaTime and Time.fixedTime are used specifically for physics, which typically runs at a different framerate. FixedUpdate() methods should use these values. 📌 Using the wrong deltaTime can lead to some funky behavior, whether it's player movement behaving inconsistently among different devices, you must learn to master Time in Unity.  📌 Tweening provides a limited but powerful form of animation. Allowing interpolation between two values for different types of animations that can be easily invoked with much less overhead than the Unity animation system.
📌 Tweens allow you to remove code from Update and Coroutines, and simply instruct a Transform to move with a single call. 📌 DOTween is a powerful and free solution for Unity. You can quickly invoke a Transform to move, scale, or rotate over time with literally a few lines of code. A set of easing methods are also provided, allowing you to accelerate, bounce, shake, wiggle a GameObject. 📌 DOTween Pro offers an extended feature set on top of DOTween. With the ability to tween on Materials, TextMeshPro, and use visual components, DOTween Pro is well worth the cost if you're seriously developing video games ($15 one-time). 📌 LeanTween is another popular tweening solution for Unity. It has a comparable feature set to DOTween and is very performant; I've seen conflicting benchmarks over the years, some favoring DOTween, and some LeanTween, both are great solutions. 📌 Tweening can boost your game performance and decrease your development time. It's great for a wide range of uses cases and is definitely a must-have for serious game developers. |
Me First Games is an independent game studio dedicated to creating unique and bizarre video games.
Red MatterStar Impact is an upcoming adventure platformer coming to PC, Mac, and Linux.
Archives
August 2020
Categories |
RSS Feed