Improve content of game developer roadmap (#7561)

* Phase 1 for Long Running...

* Phase - 2

* Phase - 3

* Phase - 4

* Phase - 5

* Phase - 6

* Phase - 7

* Phase - 8

* Phase - 9

* Phase - 10 (Final)

src/data/roadmaps/game-developer/content/2d@Wq8siopWTD7sylNi0575X.md

@@ -0,0 +1,8 @@
+# 2D
+
+2D Game Development involves creating games in a two-dimensional plane, utilizing flat graphics and typically making use of x and y coordinates. From classic arcade games of the ’80s and ’90s to the rich array of indie games today, 2D game development is a vibrant and diverse sector of the gaming industry. Not only are 2D games visually appealing and nostalgic, but they’re also often more accessible for developers to create due to the simpler mechanics compared to 3D game development.
+
+Visit the following resources to learn more:
+
+- [@article@2D and 3D Game Development](https://hireindiandevelopers.medium.com/2d-and-3d-game-development-a-comprehensive-guide-7d22c4fdd706)
+- [@article@How to Make a 2D Game](https://gamemaker.io/en/blog/how-to-make-a-2d-game)

src/data/roadmaps/game-developer/content/aabb@aTeYGd4JlPr5txNPyBezn.md

@@ -1,3 +1,7 @@
 # AABB
 
 `AABB`, short for Axis-Aligned Bounding Box, is a commonly used form of bounding volume in game development. It is a box that directly aligns with the axes of the coordinate system and encapsulates a game object. The sides of an AABB are aligned with the axes, which is helpful when carrying out certain calculations, as non-axis-aligned boxes would require more complex math. AABBs are primarily used for broad-phase collision detection, which means checking whether two objects might be in the process of colliding. Although AABBs are relatively conservative and can have more bounding volume than oriented bounding boxes (OBBs), they are simpler and faster to use in collision detection.
+
+Visit the following resources to learn more:
+
+- [@article@Axis-Aligned Bounding Box](https://gdbooks.gitbooks.io/3dcollisions/content/Chapter1/aabb.html)

src/data/roadmaps/game-developer/content/ab-pruning@KYCi4d475zZfNwlj6HZVD.md

@@ -1,3 +1,8 @@
 # AB Pruning
 
 `Alpha-Beta pruning` is an optimization technique for the minimax algorithm used in artificial intelligence (AI) programming, such as game development. It cuts off branches in the game tree that don't need to be searched because there's already a better move available. It uses two parameters, alpha and beta, which represent the minimum score that the maximizing player is assured of and the maximum score that the minimizing player is assured of, respectively. During the traversal of the game tree, branches of the tree that cannot possibly influence the final decision are not explored. This process 'prunes' the minimax tree, saving computational time and resources.
+
+Visit the following resources to learn more:
+
+- [@article@AB Pruning](https://en.wikipedia.org/wiki/Alpha-beta_pruning)
+- [@article@Alpha-Beta Pruning: A Deep Dive into its History](https://dev.to/vedantasati03/alpha-beta-pruning-a-deep-dive-into-its-history-implementation-and-functionality-4ojf)

src/data/roadmaps/game-developer/content/acceleration@ejZMnxZ0QrN-jBqo9Vrj8.md

@@ -1,3 +1,7 @@
 # Acceleration
 
 **Acceleration** refers to the rate of change in velocity per unit time. This physical concept is translated into game dynamics where it impacts the movement and speed of game characters or objects. For example, when a character starts moving, there is usually a slight delay before they reach their top speed, which then continues as long as the move button is held down. This is caused by acceleration. Conversely, when the button is released, the character doesn't stop instantly but slows down gradually - this is due to deceleration, which is negative acceleration. By mastering acceleration and deceleration, game developers can create more realistic and interesting movements for their characters.
+
+Visit the following resources to learn more:
+
+- [@article@Simple Acceleration in Games](http://earok.net/sections/articles/game-dev/theory/simplified-acceleration-games)

src/data/roadmaps/game-developer/content/advanced-rendering@CDYszS1U4v95GozB_drbt.md

@@ -1,3 +1,8 @@
 # Advanced Rendering
 
 **Advanced rendering** is a sophisticated technique used in game development that involves translating a 3D model or scene into a 2D image or animation. Advanced rendering techniques can involve various complex methods such as physically-based rendering, ray tracing, global illumination, subsurface scattering, caustics, and volumetric rendering. The use of advanced rendering can result in highly realistic graphics, as it uses complex calculations to depict how light behaves in the real world. Advanced rendering often requires powerful hardware resources and specialized software tools in order to achieve the desired images and animations.
+
+Visit the following resources to learn more:
+
+- [@article@Advanced Rendering](https://www.advances.realtimerendering.com/)
+- [@article@Advances in Real Time Rendering](https://www.advances.realtimerendering.com/s2024/index.html)

src/data/roadmaps/game-developer/content/affine-space@r5TcXQsU9s4NlAQIPvZ3U.md

@@ -1,3 +1,8 @@
 # Affine Space
 
 In the context of game mathematics, an **Affine Space** is a fundamental concept you should understand. It is a geometric structure with properties related to both geometry and algebra. The significant aspect of an affine space is that it allows you to work more comfortably with points and vectors. While a vector space on its own focuses on vectors which have both magnitude and direction, it does not involve points. An affine space makes it easy to add vectors to points or subtract points from each other to get vectors. This concept proves extremely useful in the field of game development, particularly when dealing with graphical models, animations, and motion control.
+
+Visit the following resources to learn more:
+
+- [@article@Affine Space](https://en.wikipedia.org/wiki/Affine_space)
+- [@article@Understanding Affine Space](https://brilliant.org/wiki/affine-spaces/)

src/data/roadmaps/game-developer/content/affine-transformation@SkCreb6g4i-OFtJWhRYqO.md

@@ -1,3 +1,8 @@
 # Affine Transformation
 
 An **affine transformation**, in the context of game mathematics, is a function between affine spaces which preserves points, straight lines and planes. Also, sets of parallel lines remain parallel after an affine transformation. In video games, it's typically used for manipulating an object's position in 3D space. This operation allows game developers to perform multiple transformations such as translation (moving an object from one place to another), scaling (changing the size of an object), and rotation (spinning the object around a point). An important feature of affine transformation is that it preserves points uniqueness; if two points are distinct to start with, they remain distinct after transformation. It's important to note that these transformations are applied relative to an object's own coordinate system, not the world coordinate system.
+
+Visit the following resources to learn more:
+
+- [@article@Affine Transformation](https://www.gamedevs.org/uploads/affine-transformations.pdf)
+- [@article@Understanding Affine Transformations](https://code.tutsplus.com/understanding-affine-transformations-with-matrix-mathematics--active-10884t)

src/data/roadmaps/game-developer/content/angular-velocity@Y7HYY5eq7OG42V9yQz0Q1.md

@@ -1,3 +1,8 @@
 # Angular Velocity
 
 Angular velocity, denoted by the symbol 'ω', is a measure of the rate of change of an angle per unit of time. In simpler terms, it corresponds to how quickly an object moves around a circle or rotates around a central point. Angular velocity is typically measured in radians per second (rad/s). If you think of an object moving in a circular path, the angular velocity would be the speed at which the angle changes as the object travels along the circumference of the object. Angular velocity is a vector quantity, implying it has both magnitude and direction. The direction of the angular velocity vector is perpendicular to the plane of rotation, following the right-hand rule. It plays a crucial role in game development, especially in physics simulation and character control.
+
+Visit the following resources to learn more:
+
+- [@article@Angular Velocity](https://allenchou.net/2013/12/game-physics-motion-dynamics-fundamentals/)
+- [@article@Understanding Angular Velocity](https://math.libretexts.org/Bookshelves/Precalculus/Book%3A_Trigonometry_(Sundstrom_and_Schlicker)/01%3A_The_Trigonometric_Functions/1.04%3A_Velocity_and_Angular_Velocity)

src/data/roadmaps/game-developer/content/artificial-neural-network@AoH2r4EOHyZd8YaV24rBk.md

@@ -1,3 +1,9 @@
 # Artificial Neutral Network
 
 Artificial Neural Networks (ANN) are a branch of machine learning that draw inspiration from biological neural networks. ANNs are capable of 'learning' from observational data, thereby enhancing game development in numerous ways. They consist of interconnected layers of nodes, or artificial neurons, that process information through their interconnected network. Each node's connection has numerical weight that gets adjusted during learning, which helps in optimizing problem solving. ANNs are utilized in various aspects of game development, such as improving AI behavior, procedural content generation, and game testing. They can also be used for image recognition tasks, such as identifying objects or actions in a game environment.
+
+Visit the following resources to learn more:
+
+- [@article@Artificial Neural Networks (ANN)](https://www.geeksforgeeks.org/artificial-neural-networks-and-its-applications/)
+- [@article@What is ANN?](https://www.coursera.org/articles/artificial-neural-network)
+- [@article@What is Neural Network?](https://www.ibm.com/topics/neural-networks)

src/data/roadmaps/game-developer/content/behavior-tree@ztoW8fBY73Es624A_tjd7.md

@@ -5,3 +5,4 @@ The **Behavior Tree** is a decision-making system used in game development, prim
 Visit the following resources to learn more:
 
 - [@video@Unreal Engine 5 Tutorial - AI Part 2: Behavior Tree](https://www.youtube.com/watch?v=hbHqv9ov8IM&list=PL4G2bSPE_8uklDwraUCMKHRk2ZiW29R6e&index=3&t=16s)
+- [@article@Open Behavior Tree](https://sterberino.github.io/open-behavior-trees-documentation/index.html)

src/data/roadmaps/game-developer/content/bezier@DUEEm9sAaZqSI-W-PFZ8f.md

@@ -4,4 +4,5 @@
 
 Learn more from the following resources:
 
+- [@article@Bezier Curves for Your Games](http://devmag.org.za/2011/04/05/bzier-curves-a-tutorial/)
 - [@video@Bezier Curves Explained](https://www.youtube.com/watch?v=pnYccz1Ha34)

src/data/roadmaps/game-developer/content/board-game@eoK70YRCz73GmzbNhh5kg.md

@@ -1,3 +1,7 @@
 # Board Game
 
 **Board Games** represent a type of tabletop game that involves counters or pieces moved or placed on a pre-marked surface or "board", according to a set of rules. Some games are based on pure strategy, but many contain an element of chance, and others are purely chance, with no element of skill. Games usually have a goal that a player aims to achieve. Early board games represented a battle between two armies, and most modern board games are still based on defeating opponents in terms of counters, winning position, or accruement of points. With the digitalization of board games, developers use various **Game APIs** to create engaging and interactive board game experiences. An API defines a set of rules and protocols for building and interacting with different software applications. Game APIs allow developers to integrate with game-specific features like game mechanics, player statistics, achievements, and more.
+
+Visit the following resources to learn more:
+
+- [@article@What is a Board Game?](https://code.tutsplus.com/how-to-learn-board-game-design-and-development--gamedev-11607a)

src/data/roadmaps/game-developer/content/bounding-volume@PLR_4yoRifoTzkOR4c7ym.md

@@ -1,3 +1,8 @@
 # Bounding Volume
 
 `Bounding Volume` is a simple shape that fully encompasses a more complex game model. It is less expensive to check for the intersection of bounding volumes when compared to checking for intersection of the actual models. Some commonly used types of bounding volume in game development include Axis-Aligned Bounding Boxes (AABBs), Bounding Spheres, and Oriented Bounding Boxes (OBBs). AABBs and Bounding Spheres are simple to implement and work well with static objects, while OBBs are slightly more complex and are often used with dynamic objects that need to rotate.
+
+Visit the following resources to learn more:
+
+- [@article@Collision Detection in 3D Games](https://developer.mozilla.org/en-US/docs/Games/Techniques/3D_collision_detection)
+- [@article@Visualizing Bounding Volume](https://www.haroldserrano.com/blog/visualizing-the-boundary-volume-hierarchy-collision-algorithm)

src/data/roadmaps/game-developer/content/broad-phase@AKd2UpITqBZV7cZszSRps.md

@@ -1,3 +1,7 @@
 # Broad Phase
 
 **Broad Phase Collision Detection** is the first step in the collision detection process. Its primary function is to identify which pairs of objects might potentially collide. Rather than examining the entire body of every object for possible collision, it wraps up each one in a simpler shape like a bounding box or sphere, aiming to reduce the number of calculations. The output of this phase is a list of 'candidate pairs' which are passed onto the next phase, often referred to as the narrow phase, for in-depth overlap checks.
+
+Visit the following resources to learn more:
+
+- [@article@Broad Phase Collision Detection](http://buildnewgames.com/broad-phase-collision-detection/)

src/data/roadmaps/game-developer/content/bump@r4UkMd5QURbvJ3Jlr_H9H.md

@@ -2,9 +2,8 @@
 
 `Bump` is very similar to texture. It is, as a matter of fact, a type of texture itself. If you take the texture of a bricked wall, it will becoming increasingly obvious that the amount of detail present inside the wall, if geometrically processed would be incredibly demanding and wasteful. In order to combat this ineffeciency, the `bump` maps were created. Traditionally, a flat texture would just be an image of something called a `color map`, that is to say, where does each individual color of the pixel should be to represent a texture. When you take the picture of your floor, wall, or any object, that image in essence is the color map. The bump map is different as it informs the texture about it's `normal` values. So, if you take a flat 2D mesh and apply a bump map on it, it will render the same 2D mesh with all the normal values baked into the flat 2D mesh, creating a graphically effect mimicking 3-dimensionality.
 
-There is also something known as a normal map, and displacement maps.
-
 Learn more from the following resources:
 
+- [@article@Bump Maps](https://developer.valvesoftware.com/wiki/Bump_map)
 - [@video@Normals, Normal maps and Bump maps](https://www.youtube.com/watch?v=l5PYyzsZED8)
 - [@video@Bump, normal and displacement](https://www.youtube.com/watch?v=43Ilra6fNGc)

src/data/roadmaps/game-developer/content/buoyancy@WzcmdW_fKHv3gwdBnvI0_.md

@@ -1,3 +1,7 @@
 # Buoyancy
 
 **Buoyancy** refers to a specific interaction in physics where an object submerged in fluid (such as a game character in water) experiences an upward force that counteracts the force of gravity. This makes the object either float or appear lighter. In game development, implementing buoyancy can enhance realism particularly in games that involve water-based activities or environments. Buoyancy can be manipulated through adjustments in density and volume to create various effects - from making heavy objects float to sinking light ones. Calculating it typically requires approximating the object to a sphere or another simple geometric shape, and using this in Archimedes' Principle. This principle states that buoyant force equals the weight of the fluid that the object displaces. In the realm of video games, programming buoyancy can involve complex physics equations and careful testing to achieve a balance between realism and playability.
+
+Learn more from the following resources:
+
+- [@article@Buoyancy in Game Development](https://www.gamedeveloper.com/programming/water-interaction-model-for-boats-in-video-games-part-2)

src/data/roadmaps/game-developer/content/bvh@FCc5xwb_G3VsDRXOcg3hV.md

@@ -1,3 +1,7 @@
 # BVH
 
 BVH, or Bounding Volume Hierarchy, is an algorithm used in 3D computer graphics to speed up the rendering process. It organizes the geometry in a hierarchical structure where each node in the tree represents a bounding volume (a volume enclosing or containing one or more geometric objects). The root node of the BVH contains all other nodes or geometric objects, its child nodes represent a partition of the space, and the leaf nodes are often individual geometric objects. The main objective of using BVH is to quickly exclude large portions of the scene from the rendering process, to reduce the computational load of evaluating every single object in the scene individually.
+
+Visit the following resources to learn more:
+
+- [@opensource@UnityBoundingVolumeHeirachy](https://github.com/rossborchers/UnityBoundingVolumeHeirachy)

src/data/roadmaps/game-developer/content/c@Ph3ZqmSnwwzUBUC-6dgf-.md

@@ -1,3 +1,8 @@
-# C#
+# C Sharp
 
 **CSharp (C#)** is a modern, object-oriented programming language developed and maintained by Microsoft. It's primarily used for developing desktop applications and, more prominently, for Windows applications within the Microsoft.Net framework. However, the language is versatile and has a wide range of uses in web services, websites, enterprise software, and even mobile app development. C# is known for its simplicity, type-safety, and support for component-oriented software development. It's also been adopted by Unity, a widely used game engine, thus making it one of the preferred languages for game development.
+
+Visit the following resources to learn more:
+
+- [@official@Learn C#](https://learn.microsoft.com/en-us/dotnet/csharp/)
+- [@article@C Sharp Programming Language](https://en.wikipedia.org/wiki/C_Sharp_(programming_language))

src/data/roadmaps/game-developer/content/cascaded@Lu38SfZ38y89BffLRMmGk.md

@@ -0,0 +1,7 @@
+# Cascaded
+
+Cascaded usually refers to cascaded shadow maps, a technique for rendering realistic shadows over a large area.
+
+Visit the following resources to learn more:
+
+- [@article@Cascading Shadows](https://www.gamedev.net/forums/topic/632574-cascading-shadow-maps-best-approach-to-learn/4988720/)

src/data/roadmaps/game-developer/content/catmull-rom@N9GoA3YvOaKwYjljj6NZv.md

@@ -1,3 +1,8 @@
 # Catmull-Rom
 
 The **Catmull-Rom** spline is a form of interpolation used in 2D and 3D graphics. Named after Edwin Catmull and Raphael Rom, it offers a simple way to smoothly move objects along a set of points or, in terms of graphics, to smoothly draw a curve connecting several points. It's a cubic interpolating spline, meaning it uses the cubic polynomial to compute coordinates. This makes Catmull-Rom ideal for creating smooth and natural curves in graphics and animation. It also has a feature called C1 continuity, ensuring the curve doesn't have any abrupt changes in direction. However, if not managed properly, it can create loops between points.
+
+Visit the following resources to learn more:
+
+- [@article@Catmull Rom](https://gamedev.net/forums/topic/535895-catmull-rom-in-shmups/)
+- [@article@Catmull Rom Spline - Game Development](https://gamedev.stackexchange.com/questions/47354/catmull-rom-spline-constant-speed)

src/data/roadmaps/game-developer/content/cc@jsq0UXnIIC0Z_nbK2w48f.md

@@ -4,4 +4,7 @@
 
 On the other hand, **C++** follows the paradigm of both procedural and object-oriented programming. It was developed as an extension to C to add the concept of "classes" - a core feature of object-oriented programming. C++ enhances C by introducing new features like function overloading, exception handling, and templates.
 
-Both of these languages heavily influence modern game development, where they often serve as the backend for major game engines like Unreal. Game developers use these languages for tasks related to rendering graphics, compiling game logic, and optimizing performance.
+Visit the following resources to learn more:
+
+- [@article@The C Programming Language](https://www.iso.org/standard/74528.html)
+- [@article@C++ Programming Language](https://en.wikipedia.org/wiki/C%2B%2B)

src/data/roadmaps/game-developer/content/ccd@1yK8TH4Pn7Ag8VQoug54i.md

@@ -1,3 +1,7 @@
 # CCD
 
 **CCD (Continuous Collision Detection)** is a sophisticated technique used in detecting collisions within games, more advanced than the traditional discrete collision. Rather than checking for collisions at designated time frames, CCD checks for any possible collisions that may happen during the entire time period or motion path of the moving object. This can prevent instances of "tunneling", where an object moves so fast that it passes through walls or obstacles undetected by discrete collision detection due to being at different points in one frame to another. Although more computationally heavy than discrete detection, CCD offers an increased accuracy in collision detection, making it vital in games where precise movements are needed.
+
+Visit the following resources to learn more:
+
+- [@article@Continuous Collision Detection](https://docs.unity3d.com/Manual/ContinuousCollisionDetection.html)

src/data/roadmaps/game-developer/content/center-of-mass@HWtU4q-YPXxSi64t43VNF.md

@@ -1,3 +1,7 @@
 # Center of Mass
 
 The **center of mass** is a position defined relative to an object or system of objects. Typically denoted by the symbol \(COM\), it refers to the average position of all the parts of the system, weighted according to their masses. For instance, if you have a uniformly dense object, the center of mass would be in the geometric center of that object. In gaming, the center of mass of an object can have a significant impact on how the object behaves when forces are applied to it. This includes how the object moves in response to these forces, and can affect the realism of the physics simulations in a game.
+
+Visit the following resources to learn more:
+
+- [@article@Center of Mass](https://medium.com/@brazmogu/physics-for-game-dev-a-platformer-physics-cheatsheet-f34b09064558)

src/data/roadmaps/game-developer/content/client-side-development@rQArtuVKGVgLn_fw9yO3b.md

@@ -1,3 +1,7 @@
 # Client Side
 
 In game development, the term "Client Side" refers to all the operations and activities that occur on the player's machine, which could be a console, computer, or even a phone. The client side is responsible for rendering graphics, handling input from the user and sometimes processing game logic. This is in contrast to the server-side operations, which involve handling multiplayer connections and synchronizing game states among multiple clients. On the client side, developers need to ensure performance optimization, smooth UI/UX, quick load times, and security to provide an engaging, lag-free gaming experience. Security is also crucial to prevent cheating in multiplayer games, which can be tackled through measures like Data obfuscation and encryption.
+
+Visit the following resources to learn more:
+
+- [@article@Client Side Architecture](https://gabrielgambetta.com/client-server-game-architecture.html)

src/data/roadmaps/game-developer/content/clipping@xP_VDMu1z9jiVnZaBFKJQ.md

@@ -1,3 +1,7 @@
 # Clipping
 
 `Clipping` is a fundamental technique in computer graphics primarily used for efficiently rendering a three-dimensional scene. This process involves eliminating certain parts of objects in the scene that are out-of-view or obstructed by other objects. Clipping can occur in various ways, one of the most common methods being `View-frustum culling` where objects completely outside of the camera view are discarded. The aim of clipping is to optimize the graphic rendering pipeline by reducing the number of polygons that the graphic hardware needs to process. Consequently, this helps in improving the speed and overall performance of the rendering process.
+
+Visit the following resources to learn more:
+
+- [@article@Clipping in Games](https://www.haroldserrano.com/blog/what-is-clipping-in-opengl)

src/data/roadmaps/game-developer/content/collision-detection@AdOfOJtLtNgDwuABb6orE.md

@@ -1,3 +1,7 @@
 # Collision Detection
 
 **Collision Detection** is a critical aspect in game physics that handles the computer’s ability to calculate and respond when two or more objects come into contact in a game environment. This is vital to ensure objects interact realistically, don't pass through each other, and impact the game world in intended ways. Techniques for collision detection can vary based on the complexity required by the game. Simple methods may involve bounding boxes or spheres that encapsulate objects. When these spheres or boxes overlap, a collision is assumed. More complex methods consider the object's shape and volume for precise detection. Several libraries and game engines offer built-in support for collision detection, making it easier for developers to implement in their games.
+
+Visit the following resources to learn more:
+
+- [@article@Collision Detection in Games](https://developer.mozilla.org/en-US/docs/Games/Tutorials/2D_Breakout_game_pure_JavaScript/Collision_detection)

src/data/roadmaps/game-developer/content/computer-animation@1RdyzTI_TXqmct2bIbNh9.md

@@ -1,5 +1,8 @@
 # Computer Animation
 
-## Computer Animation
-
 Computer animation refers to the art of creating moving images via the use of computers. Increasingly, it's becoming a critical component in the game development industry. Essentially, it's divided into two categories, 2D animation and 3D animation. 2D animation, also referred to as vector animation, involves creation of images in a two-dimensional environment, including morphing, twining, and onion skinning. On the other hand, 3D animation, also known as CGI, involves moving objects and characters in a three-dimensional space. The animation process typically involves the creation of a mathematical representation of a three-dimensional object. This object is then manipulated within a virtual space by an animator to create the final animation. Software like Unity, Maya, and Blender are commonly used for computer animation in game development.
+
+Visit the following resources to learn more:
+
+- [@article@Computer Animation](https://www.adobe.com/uk/creativecloud/animation/discover/computer-animation.html)
+- [@article@What is Computer Animation?](https://unity.com/topics/what-is-computer-animation)

src/data/roadmaps/game-developer/content/computer-graphics@lIb5MeDoqVj6HycveOgTS.md

@@ -4,4 +4,6 @@ Computer Graphics is a subfield of computer science that studies methods for dig
 
 Visit the following resources to learn more:
 
+- [@article@What is Computer Graphics?](https://www.geeksforgeeks.org/introduction-to-computer-graphics/)
+- [@article@Introduction to Computer Graphics](https://open.umn.edu/opentextbooks/textbooks/420)
 - [@video@How do Video Game Graphics Work?](https://www.youtube.com/watch?v=C8YtdC8mxTU)

src/data/roadmaps/game-developer/content/concave@jslk7Gy58VspO1uXGDgBp.md

@@ -1,3 +1,7 @@
 # Concave
 
 In game development, a shape is said to be "concave" if it has an interior angle greater than 180 degrees. In simpler terms, if the shape has a portion "inwards curved" or a "cave-like" indentation, it's concave. Unlike convex shapes, a straight line drawn within a concave shape may not entirely lie within the boundaries of the shape. Concave shapes add complexity in game physics, especially in collision detection, as there are more points and angles to consider compared to convex shapes. These shapes are commonly seen in game elements like terrains, mazes, game level boundaries and gaming characters. Let's remember that the practical application of concave shapes largely depends on the gameplay requirements and the level of realism needed in the game.
+
+Visit the following resources to learn more:
+
+- [@article@What is Concave Shape?](https://dev.to/fkkarakurt/geometry-and-primitives-in-game-development-1og)

src/data/roadmaps/game-developer/content/conservation-of-energy@H3hkafXO9zqEnWuwHa38P.md

@@ -1,3 +1,7 @@
 # Conservation of Energy
 
 In the realm of physically-based rendering, **translucency** and **transparency** act as key aspects in creating visually authentic and compelling images. Transparency refers to the property of an object that allows light to pass through it unhindered, hence making the object clear or invisible. This is commonly seen in materials such as glass, clear plastic, and water. On the other hand, translucency describes how light interacts with a semi-transparent object. Instead of passing directly through, light enters the object, travels within for some distance and then exits at a different location. Common examples of such surfaces include human skin, marble, milk, or wax, which exhibit a soft, diffused lighting effect when light rays pass through them. The technique to achieve this effect in graphics involves subsurface scattering, where incoming light is scattered beneath the object's surface, illuminated it in a way that showcases the material's internal structure.
+
+Visit the following resources to learn more:
+
+- [@article@What is Concave Shape?](https://dev.to/fkkarakurt/geometry-and-primitives-in-game-development-1og)

src/data/roadmaps/game-developer/content/convex-decomposition@bgP9NpD0DJGqN4VCt65xP.md

@@ -1,3 +1,7 @@
 # Convex Decomposition
 
 `Convex Decomposition` represents a process within game development that involves breaking down complex, concave shapes into simpler, convex shapes. This technique considerably simplifies the computation involved in collision detection, a critical aspect of any game development project that involves physical simulations. In concrete terms, a concave shape has one or more parts that 'cave in' or have recesses, while a convex shape has no such depressions - in simplistic terms, it 'bulges out' with no interior angles exceeding 180 degrees. So, Convex decomposition is essentially a process of breaking down a shape with 'caves' or 'recesses' into simpler shapes that only 'bulge out'.
+
+Visit the following resources to learn more:
+
+- [@article@Convex Decomposition for 3D](https://colin97.github.io/CoACD/)

src/data/roadmaps/game-developer/content/convex-hull@jixffcPBELkhoG0e7Te8g.md

@@ -1,3 +1,7 @@
 # Convex Hull
 
 The **Convex Hull** is a foundational concept used in various areas of game development, particularly in the creation of physics engines and collision detection. Essentially, it is the smallest convex polygon that can enclose a set of points in a two-dimensional space, or the smallest convex polyhedron for a set of points in a three-dimensional space. It can be thought of as the shape that a rubber band would take if it was stretched around the points and then released. In computational geometry, various algorithms like Graham's Scan and QuickHull have been developed to compute Convex Hulls rapidly. Using Convex Hulls in game engines can drastically improve the performance of collision detection routines as fewer points need to be checked for overlap, which in turn helps in creating smoother gameplay.
+
+Visit the following resources to learn more:
+
+- [@article@Convex Decomposition for 3D](https://colin97.github.io/CoACD/)

src/data/roadmaps/game-developer/content/convex@pG_V12qhS4HevoP_KHTvh.md

@@ -1,3 +1,7 @@
 # Convex
 
 The term "convex" in game development relates primarily to shapes and collision detection within the gaming environment. A shape is convex if all line segments between any two points in the shape lie entirely within the shape. This is an essential concept when programming collision detection and physics engines in games since the mathematical calculations can be more straightforward and efficient when the objects are convex. In addition to this, many rendering algorithms also operate optimally on convex objects, thereby helping improve the game’s graphical performance.
+
+Visit the following resources to learn more:
+
+- [@article@Convex in Game Development](https://dev.to/fkkarakurt/geometry-and-primitives-in-game-development-1og)

src/data/roadmaps/game-developer/content/convexity@YLusnwCba7BIdKOYUoY6F.md

@@ -1,3 +1,7 @@
 # Convexity
 
 Convexity is a significant concept used in game development, particularly in the narrow phase of collision detection. A shape is considered convex if, for every pair of points inside the shape, the complete line segment between them is also inside the shape. Essentially, a convex shape has no angles pointing inwards. Convex shapes can be of great benefit in game development because they're simpler to handle computationally. For instance, in collision detection algorithms such as separating axis theorem (SAT) and Gilbert–Johnson–Keerthi (GJK), the input shapes are often convex. Non-convex shapes or concave shapes usually require more complex methods for collision detection, often involving partitioning the shape into smaller convex parts.
+
+Visit the following resources to learn more:
+
+- [@article@Convexity in Game Development](https://www.gamedeveloper.com/game-platforms/understanding-convexity-in-ltv-modelling)

src/data/roadmaps/game-developer/content/cube@cv1-AwewuqJsZDBI3h84G.md

@@ -0,0 +1,7 @@
+# Cube
+
+In computer graphics, "cube" in the context of shadows often refers to using a cube-shaped object to visualize the concept of a "shadow volume." Imagine a light source shining on a cube. The silhouette of the cube from the light's perspective, extended infinitely outwards, forms a volume. Any object inside this "shadow volume" is considered to be in shadow. While helpful for understanding, shadow volumes themselves are not always shaped like cubes - their complexity depends on the object casting the shadow.
+
+Visit the following resources to learn more:
+
+- [@article@Draw a Cube](https://dev-tut.com/2022/unity-draw-a-debug-cube/)

src/data/roadmaps/game-developer/content/culling@1gdDeUPBRco10LpOxug4k.md

@@ -1,3 +1,8 @@
 # Culling
 
-**Culling** is a performance optimization strategy employed in game development to improve efficiency and speed. *Culling* helps in reducing the rendering workload by eliminating the elements that are not visible to the player or are outside the viewport of the game. There are several types of culling, two main being; **frustum culling** and **occlusion culling**. Frustum culling involves eliminating objects that are outside of the camera's field of view. On the other hand, Occlusion culling discards objects that are hidden or blocked by other objects. Culling ensures that only the elements that are necessary or add value to the player's experience are processed.
+**Culling** is a performance optimization strategy employed in game development to improve efficiency and speed. Culling helps in reducing the rendering workload by eliminating the elements that are not visible to the player or are outside the viewport of the game. There are several types of culling, two main being; **frustum culling** and **occlusion culling**. Frustum culling involves eliminating objects that are outside of the camera's field of view. On the other hand, Occlusion culling discards objects that are hidden or blocked by other objects. Culling ensures that only the elements that are necessary or add value to the player's experience are processed.
+
+Visit the following resources to learn more:
+
+- [@article@Culling in Game Development](https://medium.com/@niitwork0921/what-is-culling-in-game-design-a97c0b6344dd)
+- [@article@Object Culling in Unreal Engine](https://gamedevinsider.com/object-culling-in-unreal-engine/)

src/data/roadmaps/game-developer/content/curve@YTkOF_33oL1ZkA-loc_DP.md

@@ -1,8 +1,8 @@
-## Curve
+# Curve
 
 A `curve` in game development is a mathematical tool for creating smooth lines or paths, used in areas like animation, 3D modeling, UI design, and level layouts. Curves simplify complex shapes and movements, enabling more natural results compared to linear approaches. They're key for `lifelike animations`, organic shapes, `realistic physics`, and smooth camera movements, essential for polished, fluid game design.
 
 Learn more from the following resources:
 
-- [@article@Curves wikipedia](https://en.wikipedia.org/wiki/Curve)
-- [@article@Curves basics](https://byjus.com/maths/curve/)
+- [@article@Curves](https://en.wikipedia.org/wiki/Curve)
+- [@article@Basics of Curves](https://byjus.com/maths/curve/)

src/data/roadmaps/game-developer/content/dbvt@XHFV4d6Ab4kWQ3-XcZTyT.md

@@ -1,3 +1,8 @@
 # DBVT
 
 `DBVT` or `Dynamic Bounding Volume Tree` is an acceleration data structure that's primarily used in physics simulations like collision detection. It's a type of BVH (`Bounding Volume Hierarchy`), but the unique aspect of a DBVT is its handling of dynamic objects. As the name suggests, it's specifically designed to efficiently handle changing scenarios, such as objects moving or environments evolving, better than a typical BVH. Unlike a static BVH, a DBVT dynamically updates the tree as objects move, maintaining efficiency of collision queries. It primarily does this through tree rotations and refitting bounding volumes rather than fully rebuilding the tree. This makes DBVT a highly appealing option for scenarios with considerable dynamics.
+
+Learn more from the following resources:
+
+- [@article@DBVT](https://sopiro.github.io/DynamicBVH/)
+- [@article@Dynamic Bounding Volume Hierarchies](https://box2d.org/files/ErinCatto_DynamicBVH_Full.pdf)

src/data/roadmaps/game-developer/content/decision-learning@ul5XnVwQCwr4ZaL4kBNpd.md

@@ -1,3 +1,7 @@
 # Decision Learning
 
 In the realm of game development, **Decision Learning**  refers to information systems that recognize and analyze patterns to help in making decisions. It’s particularly used in AI game development where decision-making algorithms or artificial intelligence are programmed to learn from and make decisions based on past experiences or an established decision tree. These decisions can be about game behaviors, player interactions, environment changes and so on. Various methods such as reinforcement learning, Bayesian methods, Decision trees, Neural networks are used to facilitate decision learning in game development.
+
+Visit the following resources to learn more:
+
+- [@article@Decision Learning in Game Development](https://medium.com/@alidrsn/game-development-with-ai-strategy-tools-and-examples-7ae77257c062)

src/data/roadmaps/game-developer/content/decision-making@Ky-95ipdgyPZGAIdqwMCk.md

@@ -1,3 +1,7 @@
 # Decision Making
 
 In game development, decision making often refers to the logic or processes that determine the behavior of non-playable characters or game environments. Three main types of decision making are used: deterministic, stochastic, and strategic. Deterministic decision making is based on predefined rules. With stochastic decision making, outcomes are probability-based, providing an element of randomness. Strategic decision making involves planning a sequence of actions to achieve a specified goal. Decisions can also be guided using various API tools such as **pathfinding algorithms** (which determine the shortest path between two points) or **decision trees** (which facilitate the selection of an action based on certain conditions). The choice of decision-making method depends largely on the desired complexity and behavior of your game elements.
+
+Visit the following resources to learn more:
+
+- [@article@Decision Making in Game Development](https://www.cgspectrum.com/blog/game-design-decision-making-troy-dunniway)

src/data/roadmaps/game-developer/content/decision-tree-learning@sz1047M8_kScjth84yPwU.md

@@ -4,4 +4,6 @@
 
 Visit the following resources to learn more:
 
-- [@video@Decision trees - A friendly introduction](https://www.youtube.com/watch?v=HkyWAhr9v8g)
+- [@article@Game Strategy - Real Time Decision Tree](https://medium.com/@aleena.sebastian/game-strategy-optimization-using-decision-trees-d4067008eed1)
+- [@article@Real Time Decision Tree](https://www.codewithc.com/real-time-decision-trees-in-pygame-ai/)
+- [@video@Decision Trees - A Friendly Introduction](https://www.youtube.com/watch?v=HkyWAhr9v8g)

src/data/roadmaps/game-developer/content/decision-tree@rwGivalwv2ozdSlVMSc4U.md

@@ -1,3 +1,8 @@
 # Decision Tree
 
 A **Decision Tree** is a graphical representation used in game development which helps to visualize the possible outcomes or paths a game could take depending on certain choices made by a gamer. Each branch of the tree represents a possible decision, outcome, or reaction and each node on the tree represents a game situation or event. Decision Trees help game developers in making strategic designs, create complex enemy AI, and overall assists in predicting the interaction or course of the game. It allows game developers to layout the decision points, possible choices and their outcomes, thus making it easier to trace the direction in which the game progresses.
+
+Visit the following resources to learn more:
+
+- [@articleDecision Tree](https://www.gamedeveloper.com/programming/behavior-trees-for-ai-how-they-work)
+- [@video@What is a Decision Tree?](https://www.youtube.com/watch?v=bmP4ppe_-cw)

src/data/roadmaps/game-developer/content/deep-learning@ltkEyfuDxExs7knqs79ya.md

@@ -4,4 +4,7 @@ Deep Learning is a sub-field of machine learning, inspired by the structure and
 
 Visit the following resources to learn more:
 
-- [@video@But what is a neural network? | Chapter 1, Deep learning](https://www.youtube.com/watch?v=aircAruvnKk)
+- [@article@Deep Learning](https://en.wikipedia.org/wiki/Deep_learning)
+- [@article@Deep Learning Book](https://www.deeplearningbook.org/)
+- [@article@Introduction to Deep Learning](https://www.ibm.com/topics/deep-learning)
+- [@video@What is a Neural Network?](https://www.youtube.com/watch?v=aircAruvnKk)

src/data/roadmaps/game-developer/content/diffuse@0g1z5G2dsF4PTIfFAG984.md

@@ -0,0 +1,8 @@
+# Diffuse
+
+In the world of 3D rendering and game development, "diffuse" refers to diffuse lighting or diffuse reflection. It's a key concept in making objects look three-dimensional and realistically lit.
+
+Visit the following resources to learn more:
+
+- [@article@Difference Between Albedo and Diffuse Map](https://www.a23d.co/blog/difference-between-albedo-and-diffuse-map/)
+- [@article@Complete Guide to Learn Texture Styles](https://cgobsession.com/complete-guide-to-texture-map-types/)

src/data/roadmaps/game-developer/content/directional@foD8K7V0yIxgeXwl687Bv.md

@@ -0,0 +1,7 @@
+# Directional
+
+Directional light simulates a distant light source like the sun. It has only a direction, not a specific position, meaning its light rays are parallel and cast consistent shadows regardless of object location within the scene. This makes it ideal for simulating sunlight or moonlight, providing realistic outdoor lighting while being relatively performant for rendering.
+
+Visit the following resources to learn more:
+
+- [@article@Directional Light](https://www.a23d.co/blog/difference-between-albedo-and-diffuse-map/)

src/data/roadmaps/game-developer/content/directx-ray-tracing@qoIkw9o8iMx7MzUyVYoR2.md

@@ -1,3 +1,9 @@
 # DirectX Ray Tracing
 
-DirectX Ray Tracing (DXR) is an advanced Windows API introduced with DirectX 12. It delivers real-time, cinema-quality rendering to contend development in gaming and professional visualization. It provides highly efficient and straightforward access to RT Core hardware. DXR adds four new concepts to DirectX 12: The acceleration structure, The Raytracing pipeline state object, Shader tables, and the Command list method (DispatchRays). It represents a significant step forward by Microsoft in embracing Ray Tracing as a new standard in real-time rendering pipelines. For developers, DirectX Ray tracing is straightforward to integrate into existing engines given its easy compatibility with existing DirectX 12 programming models. However, to truly maximize DXR's potential, a deep understanding of both graphics workloads and tracing algorithms is necessary.
+DirectX Ray Tracing (DXR) is an advanced Windows API introduced with DirectX 12. It delivers real-time, cinema-quality rendering to contend development in gaming and professional visualization. It provides highly efficient and straightforward access to RT Core hardware. DXR adds four new concepts to DirectX 12: The acceleration structure, The Ray tracing pipeline state object, Shader tables, and the Command list method (DispatchRays). It represents a significant step forward by Microsoft in embracing Ray Tracing as a new standard in real-time rendering pipelines. For developers, DirectX Ray tracing is straightforward to integrate into existing engines given its easy compatibility with existing DirectX 12 programming models. However, to truly maximize DXR's potential, a deep understanding of both graphics workloads and tracing algorithms is necessary.
+
+Visit the following resources to learn more:
+
+- [@article@Announcing Microsoft DirectX Ray Tracing](https://devblogs.microsoft.com/directx/announcing-microsoft-directx-raytracing/)
+- [@official@DirectX Ray Tracing](https://developer.nvidia.com/blog/introduction-nvidia-rtx-directx-ray-tracing/)
+- [@official@DX12 Ray Tracing](https://developer.nvidia.com/blog/dx12-raytracing-tutorials/)

src/data/roadmaps/game-developer/content/directx@bgWFV09AtDv1yJS5t0EaB.md

@@ -1,3 +1,8 @@
 # DirectX
 
 **DirectX** is a collection of Application Programming Interfaces (APIs) developed by Microsoft to handle tasks related to multimedia, especially game programming and video, on Microsoft platforms. It was first introduced in 1995 and has become a crucial component for PC gaming. DirectX serves as an intermediary between a hardware and a software, managing the state of the hardware and giving commands to it. Some technologies under DirectX includes Direct3D for 3D graphics, DirectDraw for 2D graphics, DirectSound for sound, and DirectInput for interfacing with input devices such as keyboard and mouse.
+
+Visit the following resources to learn more:
+
+- [@official@Microsoft's DirectX](https://visualstudio.microsoft.com/vs/features/directx-game-dev/)
+- [@official@Learn DirectX](https://learn.microsoft.com/en-us/shows/introduction-to-c-and-directx-game-development/)

src/data/roadmaps/game-developer/content/dynamics@0D7KQlF-9ylmILTBBVxot.md

@@ -1,3 +1,7 @@
 # Dynamics
 
 **Dynamics** in game physics refers to the calculation and simulation of the movement and interaction of objects over time, taking into account properties such as mass, force, and velocity. Its purpose is to ensure the motion of game elements matches expectations in the real-world, or the specific conditions defined by the game designers. This typically includes topics like kinematics (velocity and acceleration), Newton's laws of motion, forces (like gravity or friction), and conservation laws (such as momentum or energy). This also involves solving equations of motions for the game objects, detecting collisions and resolving them. Dynamics, together with Statics (dealing with how forces balance on rigid bodies at rest), makes up the core of game physics simulation.
+
+Visit the following resources to learn more:
+
+- [@article@Dynamics in Game Physics](https://americanprofessionguide.com/game-mechanics-and-dynamics/)

src/data/roadmaps/game-developer/content/epa@vWLKYK2KUzV1fO-vQunzW.md

@@ -1,3 +1,8 @@
 # EPA
 
 The **EPA**, also known as the *Environmental Protection Agency*, is not typically related to game development or the concept of intersection within this context. However, in game development, EPA might refer to an 'Event-driven Process chain Architecture' or some other game-specific acronym. In this domain, different terminologies and acronyms are often used to express complex architectures, designs, or functionalities. If you have encountered EPA in a game development context, it might be best to refer to the specific documentation or guide where it was described for a better understanding. Understanding the context is key to untangle the meaning of such abbreviations.
+
+Visit the following resources to learn more:
+
+- [@article@Environmental Sustainability in Game Development](https://polydin.com/environmental-sustainability-in-game-development/)
+- [@article@Gaming Sustainability - Microsoft Game Dev](https://learn.microsoft.com/en-us/gaming/sustainability/sustainability-overview)

src/data/roadmaps/game-developer/content/euler-angle@L0J2kvveJNsmN9ueXhqKf.md

@@ -1,3 +1,7 @@
 # Euler Angle
 
 The **Euler angle** is a concept in mathematics and physics used to describe the orientation of a rigid body or a coordinate system in 3D space. It uses three angles, typically named as alpha (α), beta (β), and gamma (γ), and represents three sequential rotations around the axes of the original coordinate system. Euler angles can represent any rotation as a sequence of three elementary rotations. Keep in mind, however, that Euler angles are not unique, and different sequences of rotations can represent identical total effects. It's also noteworthy that Euler angles are prone to a problem known as gimbal lock, where the first and third axis align, causing a loss of a degree of freedom, and unpredictable behavior in particular orientations.
+
+Visit the following resources to learn more:
+
+- [@article@Euler Angle in Game Development](https://www.gameludere.com/2020/03/12/euler-angles-hamilton-quaternions-and-video-games/)

src/data/roadmaps/game-developer/content/fog@2ocwC0P1-ZFmjA9EmA1lV.md

@@ -0,0 +1,7 @@
+# Fog
+
+Fog in game development refers to a visual effect used to simulate atmospheric conditions and enhance the depth perception in a game environment. It creates a gradient of visibility, often fading objects into the background, which can improve performance by reducing the number of objects rendered at a distance. Fog can be implemented in various ways, such as linear fog, which gradually obscures objects based on their distance from the camera, or exponential fog, which creates a more dramatic effect by rapidly increasing the density of fog with distance.
+
+Visit the following resources to learn more:
+
+- [@article@Fog - Graphics and GPU Programming](https://gamedev.net/reference/articles/article677.asp)

src/data/roadmaps/game-developer/content/force@qduFRhmrzJ2sn0g7L-tza.md

@@ -1,3 +1,7 @@
 # Force
 
 **Force** is a vital concept in game development, especially when crafting physics in games. In the context of game physics, 'Force' is an influence that causes an object to undergo a certain change, either concerning its movement, direction, or geometrical construction. It's typically implemented in game engines, with part of the physics simulation that computes forces like gravity, friction, or custom forces defined by the developer. Incorporating forces gives a realistic feel to the game, allowing objects to interact naturally following the laws of physics. This is central in genres like racing games, sports games, and any game featuring physical interactions between objects. Remember that `F = ma`, the acceleration of an object is directly proportional to the force applied and inversely proportional to its mass. The balance and manipulation of these forces are integral to dynamic, immersive gameplay.
+
+Visit the following resources to learn more:
+
+- [@article@Physics for Game Dev](https://medium.com/@brazmogu/physics-for-game-dev-a-platformer-physics-cheatsheet-f34b09064558)

src/data/roadmaps/game-developer/content/friction@Hz9R4YGYtD0jAur8rYist.md

@@ -2,4 +2,7 @@
 
 `Friction` is a crucial concept in game dynamics. In the context of games, it's typically used to slow down or impede movement, providing a realistic feel to characters or objects movement. For example, when a player's character runs on a smooth surface as compared to a rough one, friction influences the speed and control of that character. It can be seen in how cars skid on icy surfaces, how walking speed changes depending on the terrain, or how a ball rolls and eventually slows. The equation to compute friction is usually `f = μN`, where `f` is the force of friction, `μ` is the coefficient of friction (which depends on the two surfaces interacting), and `N` is the normal force (which is generally the weight of the object). You can adjust the coefficient of friction in a game to have different effects depending upon the desired outcome.
 
+Visit the following resources to learn more:
+
+- [@article@Friction in Game Dev](https://medium.com/@originallearguy/rub-the-right-way-applying-friction-in-game-design-122bd98de69d)
 - [@video@Friction](https://youtu.be/t1HWIoDUWXg?si=FmFsIGTSHpLS72vp)

src/data/roadmaps/game-developer/content/frustum@UcLGWYu41Ok2NYdLNIY5C.md

@@ -2,8 +2,7 @@
 
 Frustum culling is a standard practice in computer graphics, used in virtually all games to optimize performance by not rendering objects outside of your field of view. Think of your field of view as a frustum, a truncated pyramid shape. The farthest side is called the far clip plane, and the closest side is the near clip plane. Any object in the game that doesn't fall within this frustum is culled, meaning it’s not rendered, to improve performance. This feature comes built-in with Unreal Engine.
 
-You can also adjust the near and far clip planes to fine-tune culling. For example, if an object is too close to the camera, it may disappear because it crosses the near clip plane threshold. Similarly, objects that are too far away might be culled by the far clip plane. In some cases, distant objects are LOD-ed (Level of Detail), an optimization technique that reduces the detail of the mesh the farther you are from it, and increases detail as you get closer.
-
-Frustum culling is a fundamental technique that is implemented in virtually all modern games to ensure efficient rendering and smooth gameplay.
+Visit the following resources to learn more:
 
+- [@article@Frustum Culling](https://gamedev.net/tutorials/programming/general-and-gameplay-programming/frustum-culling-r4613/)
 - [@video@Frustum Culling - Game Optimization 101 - Unreal Engine](https://www.youtube.com/watch?v=Ql56s1erTMI)

src/data/roadmaps/game-developer/content/fuzzy-logic@4ZCVUpYrCT14d_JULulLe.md

@@ -1,3 +1,7 @@
 # Fuzzy Logic
 
 Fuzzy Logic is a mathematical logic method that resolves problem-solving and system control. Unlike traditional binary sets (true or false), fuzzy logic variables have a truth value that ranges in degree between 0 and 1. This allows them to handle the concept of partial truth, where the truth value may range between completely true and completely false. In game development, fuzzy logic is often used in artificial intelligence to make the game more realistic. For instance, it can be used to program non-player characters (NPCs) who respond to situational changes dynamically, making the gameplay more engaging and interactive.
+
+Visit the following resources to learn more:
+
+- [@article@Fuzzy Login in Games](https://www.michelepirovano.com/pdf/fuzzy_ai_in_games.pdf)

src/data/roadmaps/game-developer/content/game-ai@Hpf_CPmLpCSP8Qo07Kq1X.md

@@ -1,3 +1,8 @@
 # Game AI
 
 Game AI is a subfield of artificial intelligence (AI) that is used to create video game characters that act and react like real human players. Game AI is used in a variety of video games, from simple puzzle games to complex strategy games. Game AI can be used to create non-player characters (NPCs) that interact with the player, as well as to create intelligent opponents that challenge the player.
+
+Visit the following resources to learn more:
+
+- [@article@Game AI](https://medium.com/@alidrsn/game-development-with-ai-strategy-tools-and-examples-7ae77257c062)
+- [@article@AI Game Development](https://modl.ai/ai-game-development/)

src/data/roadmaps/game-developer/content/game-ai@Hpk8eOaOepERMmOvUgkxa.md

@@ -1,3 +1,8 @@
 # Game AI
 
 Game AI is a subfield of artificial intelligence (AI) that is used to create video game characters that act and react like real human players. Game AI is used in a variety of video games, from simple puzzle games to complex strategy games. Game AI can be used to create non-player characters (NPCs) that interact with the player, as well as to create intelligent opponents that challenge the player.
+
+Visit the following resources to learn more:
+
+- [@article@Game AI](https://medium.com/@alidrsn/game-development-with-ai-strategy-tools-and-examples-7ae77257c062)
+- [@article@AI Game Development](https://modl.ai/ai-game-development/)

src/data/roadmaps/game-developer/content/game-engine@fv5tivGad2P9GRZOodfn2.md

@@ -1,3 +1,8 @@
 # Game Engine
 
 A *Game Engine* is a software framework designed to facilitate the creation and development of video games. Developers use them to create games for consoles, mobile devices, and personal computers. The core functionality typically provided by a game engine includes a rendering engine ("renderer") for 2D or 3D graphics, a physics engine or collision detection (and collision response), sound, scripting, animation, artificial intelligence, networking, streaming, memory management, and a scene graph. Game Engines can save a significant amount of development time by providing these reusable components. However, they aren't one-size-fits-all solutions, as developers must still customize much of the code to fit their games' unique needs. Some popular game engines are Unity, Unreal Engine, and Godot.
+
+Visit the following resources to learn more:
+
+- [@article@Game Engine](https://en.wikipedia.org/wiki/Game_engine)
+- [@video@Choosing a Game Engine is Easy!](https://www.youtube.com/watch?v=aMgB018o71U)

src/data/roadmaps/game-developer/content/game-physics@UTBnrQiZ6Bf96yJYIUf3b.md

@@ -1,3 +1,8 @@
 # Game Physics
 
-_Game physics_ is an integral part of game development that simulates the laws of physics in a virtual environment. This simulation brings realism into the game by defining how objects move, interact, and react to collisions and forces. Game physics ranges from how a character jumps or moves in a 2D or 3D space, to more complex mechanics such as fluid dynamics or ragdoll physics. Two main types of game physics are 'arcade physics', which are simpler and more abstract; and 'realistic physics', attempting to fully recreate real-life physics interactions. Implementing game physics requires a combination of mathematical knowledge and programming skills to integrate physics engines like Unity's PhysX and Unreal Engine's built-in physics tool.
+Game Physics is an integral part of game development that simulates the laws of physics in a virtual environment. This simulation brings realism into the game by defining how objects move, interact, and react to collisions and forces. Game physics ranges from how a character jumps or moves in a 2D or 3D space, to more complex mechanics such as fluid dynamics or ragdoll physics. Two main types of game physics are 'arcade physics', which are simpler and more abstract; and 'realistic physics', attempting to fully recreate real-life physics interactions. Implementing game physics requires a combination of mathematical knowledge and programming skills to integrate physics engines like Unity's PhysX and Unreal Engine's built-in physics tool.
+
+Visit the following resources to learn more:
+
+- [@article@Game Physics](https://en.wikipedia.org/wiki/Game_physics)
+- [@article@Master Game Physics Today!](https://www.udemy.com/course/gamephysics/)

src/data/roadmaps/game-developer/content/geometry@XWxW2ZBw3LcQ4DRk4tgAG.md

@@ -1,3 +1,8 @@
 # Geometry
 
 Geometry in game development refers to the mathematical study used to define the spatial elements within a game. This is vital in determining how objects interact within a game's environment. Particularly, geometry is employed in various aspects like object rendering, collision detection, character movement, and the calculation of angles and distance. It allows developers to create the spatial parameters for a game, including object dimensions and orientations. Understanding the basics such as 2D vs 3D, polygons, vertices, meshes and more advanced topics such as vectors, matrices, quaternions etc. is crucial to this field.
+
+Visit the following resources to learn more:
+
+- [@article@Game Geometry - Math is Fun](https://www.mathsisfun.com/geometry/index.html)
+- [@article@Geometry and Primitives for Games](https://dev.to/fkkarakurt/geometry-and-primitives-in-game-development-1og)

src/data/roadmaps/game-developer/content/gjk@lwd3Gz9bJEKCIwhXD6m-v.md

@@ -2,4 +2,8 @@
 
 The **GJK algorithm** (Gilbert–Johnson–Keerthi) is a computational geometry algorithm that is widely used to detect collisions between convex objects in video games and simulations. The primary role of this algorithm is to assess the intersection between two convex shapes. What makes it unique and widely used is its efficiency and accuracy even when dealing with complex three-dimensional shapes. It uses the concept of "Minkowski Difference" to simplify its calculations and determine if two shapes are intersecting.
 
-The algorithm works iteratively, beginning with a single point (the origin) and progressing by adding vertices from the Minkowski Difference, each time refining a simple 'guess' about the direction of the nearest point to the origin until it either concludes that the shapes intersect (the origin is inside the Minkowski difference), or until it can't progress further, in which case the shapes are confirmed not to intersect. This makes it an incredibly powerful and useful tool for game developers.
+Visit the following resources to learn more:
+
+- [@article@Game Geometry - Math is Fun](https://en.wikipedia.org/wiki/Gilbert-Johnson-Keerthi_distance_algorithm)
+- [@article@The GJK Algorithm](https://medium.com/@mbayburt/walkthrough-of-the-gjk-collision-detection-algorithm-80823ef5c774)
+- [@video@GJK Algorithm Explanation & Implementation](https://www.youtube.com/watch?v=MDusDn8oTSE)

src/data/roadmaps/game-developer/content/glsl@j8mWMFMQCEIPUzegDDsm1.md

@@ -1,3 +1,7 @@
 # GLSL
 
-GLSL (Graphics Library Shader Language) is a high-level shading language inspired by C, based on the syntax of the OpenGL Shading Language. It is used in graphics programming for defining how the graphical content should look. GLSL allows developers to harness the power of modern GPUs (Graphics Processing Units), enabling direct, unconstrained control over graphics rendering. A key aspect of the language is its ability to create shaders, which are small programs that run on the GPU. Shaders are used for various graphical effects like vertex manipulation, pixel color calculations, or post-processing effects.
+**GLSL** (Graphics Library Shader Language) is a high-level shading language inspired by C, based on the syntax of the OpenGL Shading Language. It is used in graphics programming for defining how the graphical content should look. GLSL allows developers to harness the power of modern GPUs (Graphics Processing Units), enabling direct, unconstrained control over graphics rendering. A key aspect of the language is its ability to create shaders, which are small programs that run on the GPU. Shaders are used for various graphical effects like vertex manipulation, pixel color calculations, or post-processing effects.
+
+Visit the following resources to learn more:
+
+- [@article@GLSL Shaders](https://developer.mozilla.org/en-US/docs/Games/Techniques/3D_on_the_web/GLSL_Shaders)

src/data/roadmaps/game-developer/content/goal-oriented-behavior@Cuc0xvCAkVyUtwOxO_Uua.md

@@ -1,3 +1,7 @@
 # Goal Oriented Behavior
 
 Goal oriented behavior in game development refers to the artificial intelligence algorithms employed that give non-player characters (NPCs) the ability to make decisions based on certain objectives or tasks. These NPCs analyze the circumstances in the game environment, formulate a plan to achieve specific goals, and then execute it. The degree of sophistication in these algorithms can range from simple pathways to complex problem-solving solutions. As the behavior models are not hard-coded, it provides NPCs with greater adaptability and autonomy.
+
+Visit the following resources to learn more:
+
+- [@article@Goal Oriented Action Planning](https://duckduckgo.com/?q=Goal%20Oriented%20Behaviorin%20Game%20Dev+site:www.gamedeveloper.com)

src/data/roadmaps/game-developer/content/godot@7OffO2mBmfBKqPBTZ9ngI.md

@@ -2,4 +2,9 @@
 
 Godot is an open-source, multi-platform game engine that is known for being feature-rich and user-friendly. It is developed by hundreds of contributors from around the world and supports the creation of both 2D and 3D games. Godot uses its own scripting language, GDScript, which is similar to Python, but it also supports C# and visual scripting. It is equipped with a unique scene system and comes with a multitude of tools that can expedite the development process. Godot's design philosophy centers around flexibility, extensibility, and ease of use, providing a handy tool for both beginners and pros in game development.
 
+Visit the following resources to learn more:
+
+- [@opensource@godotengine/godot](https://github.com/godotengine/godot)
+- [@official@Godot](https://godotengine.org/)
+- [@official@Godot Documentation](https://docs.godotengine.org/en/stable/)
 - [@video@Godot in 100 Seconds](https://m.youtube.com/watch?v=QKgTZWbwD1U)

src/data/roadmaps/game-developer/content/graphics-api@Kx7O7RLp7aPGtOvK8e314.md

@@ -1,3 +1,7 @@
 # Graphics API
 
 A Graphics API (Application Programming Interface) is a collection of commands, functions, protocols, and tools that game developers use to build games. It forms an interface between the game and the hardware of the device, usually a computer or console, and assists in rendering 2D and 3D graphics performance. Complex tasks such as drawing polygons, texturing, or lighting are encapsulated in a more manageable, higher-level process by the API. Common examples are Vulkan, DirectX, OpenGL, and Metal. Each one varies in availability and performance across different platforms and devices and has unique features that can be utilized for game development.
+
+Visit the following resources to learn more:
+
+- [@article@Graphics API in Unity](https://docs.unity3d.com/2022.3/Documentation/ScriptReference/PlayerSettings.SetGraphicsAPIs.html)

src/data/roadmaps/game-developer/content/graphics-pipeline@shSRnMf4NONuZ3TGPAoQc.md

@@ -1,3 +1,8 @@
 # Graphics Pipeline
 
 The **Graphics Pipeline**, also often referred to as the rendering pipeline, is a sequence of steps that a graphics system follows to convert a 3D model into a 2D image or view that can be displayed onto a screen. These steps typically include transformation, clipping, lighting, rasterization, shading, and other processes. Each step in the pipeline represents an operation that prepares or manipulates data to be used in downstream stages. The pipeline begins with a high-level description of a scene and ends with the final image rendered onto the screen. It is a primary concept in computer graphics that developers should learn as it can help in efficient rendering and high-quality visualization.
+
+Visit the following resources to learn more:
+
+- [@article@Graphics Pipelines](https://www.cs.cornell.edu/courses/cs4620/2020fa/slides/11pipeline.pdf)
+- [@article@Definition of Graphics Pipeline](https://www.pcmag.com/encyclopedia/term/graphics-pipeline)

src/data/roadmaps/game-developer/content/hermite@m4AuHjEBnHS0wyATG-I1Z.md

@@ -1,3 +1,7 @@
 # Hermite
 
 Hermite refers to Hermite interpolation, a fundamental technique in game development for executing smooth transitions. Essentially, Hermite interpolation is an application of polynomial mathematics, with two points applied as start/end (they're usually 3D positional vectors), and the tangents at these points controlling the curve's shape. The technique's name is derived from its inventor, Charles Hermite, a French mathematician. Hermite interpolation can be useful in different aspects of game development, such as creating smooth animations, camera paths, or motion patterns. Note, however, that while Hermite interpolation offers control over the start and end points of a sequence, it might not precisely predict the curve's full behavior.
+
+Visit the following resources to learn more:
+
+- [@article@Hermite Interpolation](https://en.wikipedia.org/wiki/Hermite_interpolation)

src/data/roadmaps/game-developer/content/hlsl@wYUDJb-q1rtM4w2QV3Wr1.md

@@ -1,3 +1,8 @@
 # HLSL
 
 **HLSL** stands for High-Level Shader Language, and it is the proprietary shading language developed by Microsoft for use with the Microsoft Direct3D API. Just like its counterpart from OpenGL - GLSL, it opens up the power of programmable GPUs for developers by providing capability for creating customized rendering effects or performing operations that are computationally expensive in CPU. HLSL resembles the C programming language, thereby making it easier for developers coming from traditional programming backgrounds. It is often considered an integral part of the Direct X ecosystem and is used for developing complex and visually impressive graphics for games.
+
+Visit the following resources to learn more:
+
+- [@article@HLSL](https://en.wikipedia.org/wiki/High-Level_Shader_Language)
+- [@article@Comparison of HLSLs](https://docs.vulkan.org/guide/latest/high_level_shader_language_comparison.html)

src/data/roadmaps/game-developer/content/horizon@9cBOfj58I4hBlxlQIyV9g.md

@@ -0,0 +1,7 @@
+# Horizon
+
+In graphics, the horizon refers to a horizontal line that represents the visual boundary where the sky meets the earth or a flat surface, such as the ocean. It's a fundamental concept in perspective and art, serving as a reference point for creating a sense of depth and distance in an image. The placement of the horizon line can significantly impact the composition and mood of an image, with high or low horizon lines creating different effects on the viewer's perception of the scene.
+
+Visit the following resources to learn more:
+
+- [@article@Vanishing Point](https://en.wikipedia.org/wiki/Vanishing_point)

src/data/roadmaps/game-developer/content/intersection@vmRYaXNVCe0N73xG8bsEK.md

@@ -1,3 +1,8 @@
 # Intersection
 
 `Intersection` is a concept in the narrow phase of game development where the exact point or points of collision are determined between two potentially colliding objects. This process takes place once a potential collision is determined in the broad phase. Algorithms such as Axis-Aligned Bounding Boxes (AABB), Separating Axis Theorem (SAT), Spherical or Capsule bounding, and many others are used for different intersection tests based on the shape of the objects. The intersection provides valuable data such as the point of contact, direction and depth of penetration, which are used to calculate the accurate physical response in the collision.
+
+Visit the following resources to learn more:
+
+- [@article@Intersection Tests for Games](https://www.gamedeveloper.com/game-platforms/simple-intersection-tests-for-games)
+- [@article@Intersection Geometry](https://www.petercollingridge.co.uk/tutorials/computational-geometry/line-line-intersections/)

src/data/roadmaps/game-developer/content/joints@m2_wUW2VHMCXHnn5B91qr.md

@@ -1,3 +1,8 @@
 # Joints
 
 Joints in game development primarily refer to the connections between two objects, often used in the context of physics simulations and character animations. These might simulate the physics of real-world joints like hinges or springs. Developers can control various characteristics of joints such as their constraints, forces, and reactions. The different types come with various properties suitable for specific needs. For example, Fixed joints keep objects together, Hinge joints allow rotation around an axis, and Spring joints apply a force to keep objects apart.
+
+Visit the following resources to learn more:
+
+- [@article@Game Character Rigging Fundamentals](https://learn.unity.com/project/game-character-rigging-fundamentals)
+- [@article@Joints in Unity](https://simonpham.medium.com/joints-in-unity-f9b602212524)

src/data/roadmaps/game-developer/content/learning@9_OcZ9rzedDFfwEYxAghh.md

@@ -1,3 +1,8 @@
 # Learning
 
 Machine Learning is a field of study that gives computers the ability to learn without being explicitly programmed. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention. In terms of game development, machine learning can be used to create NPCs that can learn from the player's actions and adapt to them.
+
+Visit the following resources to learn more:
+
+- [@article@Machine Learning - Wiki](https://en.wikipedia.org/wiki/Machine_learning)
+- [@article@Machine Learning Explained](https://mitsloan.mit.edu/ideas-made-to-matter/machine-learning-explained)

src/data/roadmaps/game-developer/content/light-source@VLrcBE1vb6N5fw5YESCge.md

@@ -1,3 +1,8 @@
 # Light Source
 
 In game development, a **light source** is a critical component that impacts the visual appeal and realism of the scene. It represents any object in the game scene that emits light, such as the sun, a lamp, or a torch. Light sources can be categorized as static or dynamic. Static light sources do not move or change throughout the game, while dynamic light sources can move and their properties can change in real-time. The properties of light sources that can be manipulated include intensity (how bright the light is), color, range (how far the light extends), direction, and type (point, directional, or spot). The lighting and shading effects are then computed based on these light source properties and how they interact with various objects in the game scene.
+
+Visit the following resources to learn more:
+
+- [@article@The Art of Game Lighting](https://3dskillup.com/effective-lighting-for-games/)
+- [@article@Lightning Game Environments](https://cgcookie.com/posts/art-of-lighting-game-environments)

src/data/roadmaps/game-developer/content/light@_1LkU258hzizSIgXipE0b.md

@@ -0,0 +1,8 @@
+# Light
+
+Light refers to a visual representation of illumination in a 3D environment. It is used to simulate the way light behaves in the real world, adding depth, volume, and realism to objects and scenes. Lighting can be categorized into different types, such as ambient, diffuse, specular, and emissive, each serving a specific purpose in creating a believable and immersive visual experience. Proper lighting can greatly enhance the mood, atmosphere, and overall aesthetic of a scene, making it an essential aspect of graphics and game development.
+
+Visit the following resources to learn more:
+
+- [@article@Lightning in Game Environments](https://medium.com/my-games-company/using-light-and-color-in-game-development-a-beginners-guide-400edf4a7ae0)
+- [@article@The Art of Game Lighting](https://3dskillup.com/effective-lighting-for-games/)

src/data/roadmaps/game-developer/content/lighting-and-shadow@DDN3mn0LTueBhjRzXFcbU.md

@@ -1,3 +1,9 @@
 # Lighting and Shadow
 
 **Lighting and Shadows** are paramount elements in computer graphics, significantly contributing to the visual realism of a game. They create depth and a sense of a three-dimensional space in a two-dimensional display. **Lighting** in game development mimics real-world light properties. It involves calculating how light interacts with different objects and surfaces based on their material characteristics and the light's intensity, direction, and color. Various algorithms, like Ray Tracing or Rasterization, are used to simulate these interactions. On the other hand, **shadows** are the areas unlit due to the blockage of light by an object. Producing realistic shadows involves complex computations, factoring in the light's position, the blocking object's shape and size, and the affected area's distance. Shadow Mapping and Shadow Volume are common techniques for creating shadows in game development. Special attention to these aspects can dramatically increase the perceived realism and immersion in the game environment.
+
+Visit the following resources to learn more:
+
+- [@article@Lightning and Shadows](https://www.techspot.com/article/1998-how-to-3d-rendering-lighting-shadows/)
+- [@article@The Art of Game Lighting](https://3dskillup.com/effective-lighting-for-games/)
+- [@article@Introduction to Lighting in 3D Games](https://www.gridpaperstudio.com/post/introduction-to-lighting-in-3d-game-engines-a-beginner-s-guide)

src/data/roadmaps/game-developer/content/linear-algebra@grRf-MmaXimDB4iODOV47.md

@@ -2,5 +2,8 @@
 
 Linear Algebra is a vital field in Mathematics that is extensively used in game development. It revolves around vector spaces and the mathematical structures used therein, including matrices, determinants, vectors, eigenvalues, and eigenvectors, among others. In the context of game development, linear algebra is used mainly for computer graphics, physics, AI, and many more. It allows developers to work with spatial transformations, helping them manipulate and critically interact with the 3D space of the game. On a broader context, it is important in computer programming for algorithms, parallax shifting, polygonal modeling, collision detection, etc. From object movements, positional calculations, game physics, to creating dynamism in games, linear algebra is key.
 
-- [@video@Linear Algebra full course by Kimberly Brehm](https://youtube.com/playlist?list=PLl-gb0E4MII03hiCrZa7YqxUMEeEPmZqK\&si=_r0WDwh94NKJbs_R)
+Visit the following resources to learn more:
+
+- [@article@Linear Algebra](https://en.wikipedia.org/wiki/Linear_algebra)
+- [@video@Linear Algebra Full Course by Kimberly Brehm](https://youtube.com/playlist?list=PLl-gb0E4MII03hiCrZa7YqxUMEeEPmZqK\&si=_r0WDwh94NKJbs_R)
 - [@feed@Explore top posts about Math](https://app.daily.dev/tags/math?ref=roadmapsh)

src/data/roadmaps/game-developer/content/linear-transformation@XABzEU9owCx9-zw1id9xU.md

@@ -1,3 +1,8 @@
 # Linear Transformation
 
-`Linear transformations` or `linear maps` are an important concept in mathematics, particularly in the fields of linear algebra and functional analysis. A linear transformation can be thought of as a transformation that preserves the operations of addition and scalar multiplication. In other words, a transformation T is linear if for every pair of vectors `x` and `y`, the equation T(x + y) = T(x) + T(y) holds true. Similarly, for any scalar `c` and any vector `x`, the equation T(cx)=cT(x) should also hold true. This property makes them very useful when dealing with systems of linear equations, matrices, and in many areas of computer graphics, including game development.
+`Linear transformations` or `linear maps` are an important concept in mathematics, particularly in the fields of linear algebra and functional analysis. A linear transformation can be thought of as a transformation that preserves the operations of addition and scalar multiplication. In other words, a transformation T is linear if for every pair of vectors `x` and `y`, the equation `T(x + y) = T(x) + T(y)` holds true. Similarly, for any scalar `c` and any vector `x`, the equation `T(cx)=cT(x)` should also hold true. This property makes them very useful when dealing with systems of linear equations, matrices, and in many areas of computer graphics, including game development.
+
+Visit the following resources to learn more:
+
+- [@article@Linear Transformation](https://en.wikipedia.org/wiki/Linear_map)
+- [@feed@Explore top posts about Math](https://app.daily.dev/tags/math?ref=roadmapsh)

src/data/roadmaps/game-developer/content/linear-velocity@Z_U6abGV_wVkTGZ2LVkFK.md

@@ -1,3 +1,8 @@
 # Linear Velocity
 
 **Linear Velocity** is a fundamental concept in physics that is extensively used in game development. It refers to the rate of change of an object's position with respect to a frame of reference. It's calculated by dividing the change in position by the change in time, often represented with the vector 'v'. In game development, an object's linear velocity can be manipulated to control its speed and direction. This is especially important in the development of physics simulations or movement-dependent gameplay elements. For instance, it can be used to make a character run or drive, or to throw an object at different speeds and directions.
+
+Visit the following resources to learn more:
+
+- [@article@Linear Velocity](https://byjus.com/physics/linear-velocity/)
+- [@feed@Explore top posts about Math](https://app.daily.dev/tags/math?ref=roadmapsh)

src/data/roadmaps/game-developer/content/mapping@THMmnx8p_P0X-dSPoHvst.md

@@ -1,7 +1,8 @@
 # Mapping
 
-"Mapping" in game development, especially in the context of shaders, predominantly refers to Texture Mapping and Normal Mapping. 
+"Mapping" in game development, especially in the context of shaders, predominantly refers to Texture Mapping and Normal Mapping. **Texture Mapping** is the application of a texture (an image or colour data) onto a 3D model's surface. It's a process of defining how a 2D surface wraps around a 3D model or the way that a flat image is stretched across a model's surface to paint its appearance. This could be anything from the colour of objects to their roughness or reflectivity. Whereas, **Normal Mapping** is a technique used to create the illusion of complexity in the surface of a 3D model without adding any additional geometry. A Normal Map is a special kind of texture that allows the addition of surface details, such as bumps, grooves, and scratches which catch the light as if they are represented by real geometry, making a low-polygon model appear as a much more complex shape.
 
-- **Texture Mapping**: This is the application of a texture (an image or colour data) onto a 3D model's surface. It's a process of defining how a 2D surface wraps around a 3D model or the way that a flat image is stretched across a model's surface to paint its appearance. This could be anything from the colour of objects to their roughness or reflectivity.
+Visit the following resources to learn more:
 
-- **Normal Mapping**: This is a technique used to create the illusion of complexity in the surface of a 3D model without adding any additional geometry. A Normal Map is a special kind of texture that allows the addition of surface details, such as bumps, grooves, and scratches which catch the light as if they are represented by real geometry, making a low-polygon model appear as a much more complex shape.
+- [@article@Designing Maps](https://www.gamedeveloper.com/design/designing-maps-that-complement-game-mechanics)
+- [@article@Mapping and Tiles in Game Development](https://code.tutsplus.com/an-introduction-to-creating-a-tile-map-engine--gamedev-10900t)

src/data/roadmaps/game-developer/content/markov-system@c6j-30p84vk3MZEF1R2hN.md

@@ -1,3 +1,8 @@
 # Markov System
 
 A **Markov System** or **Markov Chain** represents a statistical model that is used in decision-making scenarios within game development. This model is based on the notion of "memorylessness" where a certain event's probability depends solely on the state attained in the previous event. It employs a sequence of possible events where the probability of each event hinges on the state achieved in the previous event. A common usage of a Markov System is in designing AI behavior within games, where each state symbolizes a different behavior, and transitions between them are governed by the Markov chain probabilities.
+
+Visit the following resources to learn more:
+
+- [@article@Markov System](https://towardsdatascience.com/modeling-games-with-markov-chains-c7b614731a7f)
+- [@article@Using Markov Chain in Game Development](https://www.gamedeveloper.com/design/advanced-math-in-game-design-random-walks-and-markov-chains-in-action)

src/data/roadmaps/game-developer/content/matrix@Kg6Mg9ieUUGXWX9Lai7B0.md

@@ -1,3 +1,8 @@
 # Matrix
 
 In game development, a **matrix** is a fundamental part of game mathematics. It's a grid of numbers arranged into rows and columns that's particularly important in 3D game development. These matrices are typically 4x4, meaning they contain 16 floating point numbers, and they're used extensively for transformations. They allow for the scaling, rotation, and translation (moving) of 3D vertices in space. With matrices, these transformations can be combined, and transformed vertices can be used to draw the replicas of 3D models into 2D screen space for rendering.
+
+Visit the following resources to learn more:
+
+- [@article@Matrix Algebra and Game Programming](https://www.gameludere.com/2019/12/21/matrix-algebra-and-game-programming/)
+- [@article@Matrices in Game Development](https://dev.to/fkkarakurt/matrices-and-vectors-in-game-development-67h)

src/data/roadmaps/game-developer/content/mcts@QD9TfZn3yhGPVwiyJ6d0V.md

@@ -1,3 +1,8 @@
 # MCTS
 
 "MCTS", or Monte Carlo Tree Search, is a search algorithm that utilizes methods of decision-making to solve complex problems, commonly implemented in a range of applications, including board games. It essentially operates through building a search tree, node by node, for probable states of a game and then using Monte Carlo simulations to provide a statistical analysis of potential outcomes. It randomly generates moves using the game's determined rules, then makes decisions based on the results of these simulations. In board games, it's often used to determine AI decisions by simulating possible game scenarios, hence contributing to making the AI system more robust and challenging.
+
+Visit the following resources to learn more:
+
+- [@article@MCTS Algorithm](https://en.wikipedia.org/wiki/Monte_Carlo_tree_search/)
+- [@article@Monte Carlo Tree Search](https://www.geeksforgeeks.org/ml-monte-carlo-tree-search-mcts/)

src/data/roadmaps/game-developer/content/metallicity@olY1ibR7kw1yJ58TfU-37.md

@@ -1,3 +1,8 @@
 # Metallicity
 
 In Physically Based Rendering (PBR), **Metallicity** is a critical property of a material, which influences how it interacts with light. It's a binary property, indicating whether the material is a 'metal' or 'non-metal'. Metals have a high metallicity value (often 1), non-metals (such as wood, plastic, etc.) have a low metallicity value (often 0). Interestingly, with PBR, there exists no 'partially metal' materials ― it's an all or nothing characteristic. This property significantly impacts color handling, too, as metals derive their color from specular reflection while non-metals derive from subsurface scattering (diffuse).
+
+Visit the following resources to learn more:
+
+- [@article@Metallicty in PBR](https://en.wikipedia.org/wiki/Physically_based_rendering)
+- [@article@What is PBR in 3D Games](https://www.adobe.com/products/substance3d/discover/pbr.html)

src/data/roadmaps/game-developer/content/microsurface-scattering@YrQgfjsdLCIUxrwflpEHO.md

@@ -4,4 +4,6 @@ Microsurface scattering, also known as sub-surface scattering, is an important p
 
 Visit the following resources to learn more:
 
-- [@video@The 4 main types of subsurface scattering](https://www.youtube.com/watch?v=GkjvYSbGHg4)
+- [@article@Subsurface Rendering](https://gamedev.net/forums/topic/600708-subsurface-scattering/)
+- [@article@Real Time Sub Surface Rendering](https://therealmjp.github.io/posts/sss-intro/)
+- [@video@Types of Subsurface Scattering](https://www.youtube.com/watch?v=GkjvYSbGHg4)

src/data/roadmaps/game-developer/content/minimax@oOjGqicW3eqRwWyIwJdBA.md

@@ -1,3 +1,7 @@
 # Minimax
 
 `Minimax` is an artificial intelligence (AI) decision-making algorithm mainly used in decision making and game theory, particularly for two player zero-sum games. It formulates a strategy by simulating all possible game scenarios and assuming that the opponent is playing an optimal game. Minimax operates by the player minimizing the possible loss for a worst case scenario and thus making the 'maximum of the minimum' possible scenarios. This algorithm is often combined with `alpha-beta pruning` technique to increase its efficiency.
+
+Visit the following resources to learn more:
+
+- [@article@Minimax](https://en.wikipedia.org/wiki/Minimax)

src/data/roadmaps/game-developer/content/moment-of-inertia@6E2mkXuAzoYnrT1SEIA16.md

@@ -1,3 +1,7 @@
 # Moment of Inertia
 
 The **moment of inertia**, also known as rotational inertia, is a measure of an object's resistance to changes to its rotation. In simpler terms, it's essentially how difficult it is to start or stop an object from spinning. It is determined by both the mass of an object and its distribution of mass around the axis of rotation. In the context of game development, the moment of inertia is crucial for creating realistic movements of characters, objects or vehicles within the game. This is particularly relevant in scenarios where the motion involves spinning or revolving entities. Calculating and applying these physics ensures a more immersive and believable gaming experience.
+
+Visit the following resources to learn more:
+
+- [@article@Moment of Inertia](https://en.wikipedia.org/wiki/Moment_of_inertia)

src/data/roadmaps/game-developer/content/movement@mUyzX-DXnIKDl-r9o8d38.md

@@ -1,3 +1,7 @@
 # Movement
 
 In the context of game development and game API (Application Programming Interface), movement refers to the process of changing the position or orientation of game objects. This involves using programming functions to control objects' movement like walk, run, jump, fly, or any such physical action in the game world. Movement is at the core to creating the dynamics of a game and is critical to both game physics and game logic. Different game engines offer different ways for handling movement. In some APIs, this process could be as simple as setting a new position directly, such as `object.position = new Vector3(5, 10, 0)`. Meanwhile, in others, more complex methods involving real-world physics are required, such as applying forces or altering velocity.
+
+Visit the following resources to learn more:
+
+- [@article@Movement in Games](https://www.gamedeveloper.com/design/analyzing-core-character-movement-in-3d)

src/data/roadmaps/game-developer/content/naive-bayes-classifier@aw1BAGqrdBBmUwB6vMF_A.md

@@ -1,3 +1,8 @@
 # Naive Bayes Classifier
 
 The Naive Bayes Classifier is a type of probabalistic machine learning model that is utilized for classification tasks. These tasks can range from email filtering to sentiment analysis or even document categorization. This model is termed 'naive' because it operates under the assumption that each input feature is independent from one another. This simplifying assumption allows for the computation of the probabilities involved to be severely less complicated. It follows the Bayes' Theorem equation to predict the class of the given data point. While this classifier might seem simplistic, it holds its own quite well in complex real-world situations. Due to its simplicity and high efficiency, the Naive Bayes Classifier is one of the most reliable and practical methods in machine learning applications.
+
+Visit the following resources to learn more:
+
+- [@article@How Naive Bayes Classifier Works?](https://www.machinelearningplus.com/predictive-modeling/how-naive-bayes-algorithm-works-with-example-and-full-code/)
+- [@article@Text Classification With Naive Bayes Classifier](https://gamedevacademy.org/text-classification-tutorial-with-naive-bayes/)

src/data/roadmaps/game-developer/content/narrow-phase@SuemqQuiePab0Qpm2EGy9.md

@@ -1,3 +1,7 @@
 # Narrow Phase
 
 The **Narrow Phase** of collision detection is a process that dives deeply into detailed collision checks for pairs of objects that are already found to be potentially colliding during the broad phase. Narrow phase is essentially a fine-tuning process. Upon positive detection from the broad phase, it identifies the precise points of collision between the two objects, and it may involve more detailed shape representations and more expensive algorithms. It might also calculate additional information necessary for the physics simulation (like the exact time of impact and contact normals). The usual methods used for this phase involve bounding box, bounding sphere or separating axis theorem. However, the method can vary depending on the complexity of shapes of objects and the specific needs of the game.
+
+Visit the following resources to learn more:
+
+- [@article@Narrow Phase in Game Development](https://rocketbrush.com/blog/game-development-process-guide)

src/data/roadmaps/game-developer/content/native@CeAUEN233L4IoFSZtIvvl.md

@@ -1,3 +1,10 @@
 # Native
 
 You don't necessarily have to use tools like Unreal, Unity3d, or Godot to make games. You can also use native languages like C++ or Rust to make games. However, you will have to do a lot of work yourself, and you will have to learn a lot of things that are already done for you in game engines.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Visit Dedicated C++ Roadmap](https://roadmap.sh/cpp)
+- [@roadmap@Visit Dedicated Rust Roadmap](https://roadmap.sh/rust)
+- [@article@Learn Game Development with C++](https://learn.microsoft.com/en-us/cpp/overview/game-development-cpp?view=msvc-170)
+- [@article@Building Games with Rust](https://rustmeup.com/building-games-with-rust)

src/data/roadmaps/game-developer/content/obb@7nGtvbxoEAheiF4IPMfPf.md

@@ -1,3 +1,8 @@
 # OBB
 
 `Oriented Bounding Box (OBB)` is a type of bounding volume used in computer graphics and computational geometry. It is often used to simplify complex geometric objects by correlating them as a box much closer in size and orientation to the actual object. Unlike the `Axis-Aligned Bounding Box (AABB)`, the `OBB` is not constrained to align with the axis, so the box can be rotated. This orientation is usually chosen based on the object's local coordinate system, so the `OBB` maintains its rotation. Properties of an `OBB` include its center, dimensions, and orientation. However, it is worth noting that `OBBs` can be more computationally intensive than `AABBs` due to mathematical complexity.
+
+Visit the following resources to learn more:
+
+- [@article@OBB vs OBB Collision Detection](https://gamedev.stackexchange.com/questions/25397/obb-vs-obb-collision-detection)
+- [@article@Oriented Bounding Box](https://gamedev.stackexchange.com/questions/49041/oriented-bounding-box-how-to)

src/data/roadmaps/game-developer/content/occluder@MlLYqO_8JDNOwKRvaM-bf.md

@@ -1,3 +1,8 @@
 # Occluder
 
 An **Occluder** in game development is basically a tool or method used to hide other objects in the game environment. When a certain object, which is known as the occluder, blocks the line of sight to another object from the camera's perspective, the hidden or blocked object does not need to be rendered. This object could be anything from a building to a terrain feature. The process of managing these occluders is known as occlusion culling. The purpose of using occluders is to optimize the game and improve its performance by reducing unnecessary rendering workload. However, it's important to note that setting up occluders requires careful planning to ensure that it does not impact the gameplay or visual quality.
+
+Visit the following resources to learn more:
+
+- [@article@Occluder and How to Use Them](https://80.lv/articles/occluders-and-how-to-use-them-for-level-design/)
+- [@article@Occlusion Culling Tutorial](https://thegamedev.guru/unity-performance/occlusion-culling-tutorial/)

src/data/roadmaps/game-developer/content/opengl-es@EVOiWAeZsIvjLTt3EYu-6.md

@@ -1,3 +1,8 @@
 # OpenGL ES
 
 OpenGL ES (Open Graphics Library for Embedded Systems) is a simplified version of OpenGL, designed for use on systems with lower computational power, such as mobile devices and embedded systems. Despite its semantic simplifications, OpenGL ES still retains high versatility and capability, allowing for high-performance 2D and 3D graphics on these smaller, less powerful systems. OpenGL ES has become particularly popular in mobile game development, with major platforms like Android and iOS providing full support for it. The API is divided into several versions, the latest of which, OpenGL ES 3.2, was released in 2016.
+
+Visit the following resources to learn more:
+
+- [@article@LVGL — Light and Versatile Embedded Graphics Library](https://lvgl.io/)
+- [@article@Embedded Lighting](http://embeddedlightning.com/ugui/)

src/data/roadmaps/game-developer/content/opengl@ffa5-YxRhE3zhWg7KXQ4r.md

@@ -2,4 +2,8 @@
 
 Open GL, also known as Open Graphics Library, is a cross-language, cross-platform API designed to render 2D and 3D vector graphics. As a software interface for graphics hardware, Open GL provides programmers the ability to create complex graphics visuals in detail. It was first developed by Silicon Graphics Inc. in 1992 and quickly became a highly popular tool in the graphics rendering industry. Open GL is widely used in CAD, virtual reality, scientific visualization, information visualization, and flight simulation. It is also used in video games production where real-time rendering is a requirement. The API is designed to work with a broad range of hardware from different manufacturers. Being open-source, Open GL's code capabilities can be extended by anyone in the software community.
 
+Visit the following resources to learn more:
+
+- [@official@Open Graphics Library](https://www.opengl.org/)
+- [@official@OpenGL Libraries](https://www.opengl.org/sdk/libs/)
 - [@video@OpenGL Tutorials](https://youtube.com/playlist?list=PLPaoO-vpZnumdcb4tZc4x5Q-v7CkrQ6M-&si=Mr71bYJMgoDhN9h-)

src/data/roadmaps/game-developer/content/optix@GDLysy3__cbYidEaOmFze.md

@@ -1,3 +1,8 @@
 # OptiX
 
 `OptiX` is an application framework developed by NVIDIA for achieving high performance ray tracing in graphics processing unit (GPU) programming. It's mainly intended for use in real-time graphics application, scientific simulations, and other visual computing applications. `OptiX` provides key functionalities such as hierarchical object acceleration, programmable ray generation, material shading, and dynamic scene management to achieve fast and state-of-the-art rendering. This highly efficient, scalable and flexible API supports the coding of applications, not just for graphic rendering but also for collision detection and physics simulation. Please note that access to `OptiX` currently requires NVIDIA GeForce, Quadro and Tesla products with Kepler, Maxwell, Pascal, Volta, Turing and later generation GPUs.
+
+Visit the following resources to learn more:
+
+- [@official@OptiX by Nvidia](https://developer.nvidia.com/optix/)
+- [@official@OptiX API Documentation](https://developer.nvidia.com/rtx/ray-tracing/optix)

src/data/roadmaps/game-developer/content/orientation@iIWEjpkNFBj4R5wQ0mcWY.md

@@ -1,3 +1,8 @@
 # Orientation
 
 In the context of game development, **Orientation** refers to the aspect or direction in which an object is pointed in a 3D space. To determine an object's orientation in 3D space, we typically use three angles namely: pitch, yaw, and roll collectively known as Euler's angles. **Pitch** is the rotation around the X-axis, **Yaw** around the Y-axis and **Roll** around the Z-axis. Alternatively, orientation can also be represented using a Quaternion. Quaternions have the advantage of avoiding a problem known as Gimbal lock (a loss of one degree of freedom in 3D space), present when using Euler's angles.
+
+Visit the following resources to learn more:
+
+- [@article@Orientation of Character](https://medium.com/@dev.szabo.endre/a-bit-e-of-game-dev-math-01-character-movement-with-vectors-effc862a1e4f)
+- [@article@Vector Maths for Game Developers](https://www.gamedeveloper.com/programming/vector-maths-for-game-dev-beginners)

src/data/roadmaps/game-developer/content/orthogonal@d6C1qFv-Tad3AtMBDLI6r.md

@@ -1,3 +1,7 @@
 # Orthogonal
 
 Orthogonal projection, or orthographic projection, is a type of parallelogram projection in game development where the lines of projection are perpendicular to the projection plane. This creates a view that is straight-on, essentially removing any form of perspective. Unlike perspective projection where objects further from the viewer appear smaller, objects in orthogonal projection remain the same size regardless of distance. The lack of perspective in orthogonal projection can be useful for specific types of games like platformers or strategy games. It is commonly used in CAD (Computer-Aided Design) and technical drawings as well.
+
+Visit the following resources to learn more:
+
+- [@article@Orthogonal Projection](https://medium.com/retronator-magazine/game-developers-guide-to-graphical-projections-with-video-game-examples-part-1-introduction-aa3d051c137d)

src/data/roadmaps/game-developer/content/parallax@YGeGleEN203nokiZIYJN8.md

@@ -0,0 +1,7 @@
+# Parallax
+
+In game development and graphics, parallax refers to the apparent displacement or difference in the apparent position of an object viewed along two different lines of sight, and is measured by the angle or semi-angle of inclination between those two lines. In simpler terms, parallax is a technique used to create the illusion of depth in 2D environments by moving background layers at different speeds relative to the foreground.
+
+Visit the following resources to learn more:
+
+- [@article@Parallax Effect](https://www.encora.com/insights/how-to-take-advantage-of-parallax-in-programming-and-video-games)

src/data/roadmaps/game-developer/content/perspective@LEJymJ2EaAW5FM5LgKW38.md

@@ -1,3 +1,7 @@
 # Perspective
 
 In game development, **Perspective** plays a significant role in creating a three-dimensional world on a two-dimensional space. It mimics the way our eyes perceive distance and depth, with objects appearing smaller as they go farther away. Essentially, this is achieved by projecting 3D co-ordinates on a virtual screen. Perspective projection is done in two types - one-point where only one axis displays a change in size with depth and two-point where both axis display a change. It creates more realistic views, enhancing game visualization and immersion. An important aspect is the player's viewpoint, which is the vanishing point where parallel lines converge in the distance.
+
+Visit the following resources to learn more:
+
+- [@article@Perspective in Games](https://www.gamedeveloper.com/design/making-the-most-out-of-the-first-person-perspectives)

src/data/roadmaps/game-developer/content/physically-based-rendering@XvFtMHrYsBREmuerE7CGc.md

@@ -1,3 +1,7 @@
 # Physically-Based Rendering
 
 Physically Based Rendering (PBR) is a technique in computer graphics that aims to mimic the interaction of light with surfaces in the real world. It models how light behaves, from reflection to refraction, in a way that accurately represents reality. The PBR model factors in physical properties of materials, such as roughness or metallicity, making the rendering output more consistent and predictable under different lighting conditions. It uses complex shading algorithms and light calculations to generate a high level of realism. In order to achieve this, many PBR systems use a combination of two important components: the Bidirectional Reflectance Distribution Function (BRDF), which defines how light is reflected off an object, and the Bidirectional Surface Scattering Reflectance Distribution Function (BSSRDF), which handles how light scatters under the surface of an object.
+
+Visit the following resources to learn more:
+
+- [@article@Physically-Based Rendering](https://dev.epicgames.com/community/learning/tutorials/Yx3q/unreal-engine-physically-based-rendering-pbr-explained-in-depth)