diff --git a/public/pdfs/roadmaps/game-developer.pdf b/public/pdfs/roadmaps/game-developer.pdf
new file mode 100644
index 000000000..8bb9ccce6
Binary files /dev/null and b/public/pdfs/roadmaps/game-developer.pdf differ
diff --git a/public/roadmaps/game-developer.png b/public/roadmaps/game-developer.png
new file mode 100644
index 000000000..3fdb00941
Binary files /dev/null and b/public/roadmaps/game-developer.png differ
diff --git a/src/data/roadmaps/game-developer/content/100-client-side.md b/src/data/roadmaps/game-developer/content/100-client-side.md
index 2d2376520..f37d92671 100644
--- a/src/data/roadmaps/game-developer/content/100-client-side.md
+++ b/src/data/roadmaps/game-developer/content/100-client-side.md
@@ -1 +1,3 @@
-# Client side
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/100-game-developer-roadmap-note.md b/src/data/roadmaps/game-developer/content/100-game-developer-roadmap-note.md
new file mode 100644
index 000000000..08cce0bcf
--- /dev/null
+++ b/src/data/roadmaps/game-developer/content/100-game-developer-roadmap-note.md
@@ -0,0 +1,3 @@
+# Note
+
+These roadmaps cover everything that is there to learn for the paths listed below. Don't feel overwhelmed, you don't need to learn it all in the beginning if you are just getting started.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/100-react-roadmap-note.md b/src/data/roadmaps/game-developer/content/100-react-roadmap-note.md
deleted file mode 100644
index a4106a0ff..000000000
--- a/src/data/roadmaps/game-developer/content/100-react-roadmap-note.md
+++ /dev/null
@@ -1 +0,0 @@
-# React roadmap note
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/100-linear-algebra.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/100-linear-algebra.md
index be36ce707..0b78048e3 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/100-linear-algebra.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/100-linear-algebra.md
@@ -1 +1,3 @@
-# Linear algebra
\ No newline at end of file
+# Linear Algebra
+
+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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/101-vector.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/101-vector.md
index e93e6fb9c..d172337e7 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/101-vector.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/101-vector.md
@@ -1 +1,3 @@
-# Vector
\ No newline at end of file
+# Vector
+
+`Vector` in game development is a mathematical concept and an integral part of game physics. It represents a quantity that has both magnitude and direction. A vector can be used to represent different elements in a game like positions, velocities, accelerations, or directions. In 3D games, it's commonly used to define 3D coordinates (x, y, z). For example, if you have a character in a game and you want to move it up, you'd apply a vector that points upward. Hence, understanding how to manipulate vectors is a fundamental skill in game development.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/102-matrix.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/102-matrix.md
index 98dc1223b..a1a40b7f7 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/102-matrix.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/102-matrix.md
@@ -1 +1,3 @@
-# Matrix
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/103-geometry.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/103-geometry.md
index bd8b7ee07..02177ffeb 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/103-geometry.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/103-geometry.md
@@ -1 +1,3 @@
-# Geometry
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/104-linear-transformation.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/104-linear-transformation.md
index 331c3d45d..98290e14e 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/104-linear-transformation.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/104-linear-transformation.md
@@ -1 +1,3 @@
-# Linear transformation
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-space.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-space.md
index bfb2da0ab..70bb62910 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-space.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-space.md
@@ -1 +1,3 @@
-# Affine space
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-transformation.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-transformation.md
index a6a4a91a6..ff4a278fb 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-transformation.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/105-affine-transformation.md
@@ -1 +1,3 @@
-# Affine transformation
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-quaternion.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-quaternion.md
index e33a334be..e550edebb 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-quaternion.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-quaternion.md
@@ -1 +1,3 @@
-# Quaternion
\ No newline at end of file
+# Quaternion
+
+The **quaternion** is a complex number system that extends the concept of rotations in three dimensions. It involves four components: one real and three imaginary parts. Quaternions are used in game development for efficient and accurate calculations of rotations and orientation. They are particularly useful over other methods, such as Euler angles, due to their resistance to problems like Gimbal lock. Despite their complex nature, understanding and implementing quaternions can greatly enhance a game's 3D rotational mechanics and accuracy.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-spline.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-spline.md
index edbf73c5b..6c9b922d0 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-spline.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/100-spline.md
@@ -1 +1,3 @@
-# Spline
\ No newline at end of file
+# Spline
+
+`Spline` is a mathematical function widely used in computer graphics for generating curves and surfaces. It connects two or more points through a smooth curve, often used in games for defining pathways, movement paths, object shapes, and flow control. Splines are not confined to two dimensions and can be extended to 3D or higher dimensions. Types of splines include `Linear`, `Cubic`, and `Bezier` splines. While linear splines generate straight lines between points, cubic and bezier splines provide more control and complexity with the addition of control points and handles. Developing a good understanding of splines and their usage can vastly improve the fluidity and visual aesthetics of a game.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-euler-angle.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-euler-angle.md
index 326bd7aab..4043224a6 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-euler-angle.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-euler-angle.md
@@ -1 +1,3 @@
-# Euler angle
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-hermite.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-hermite.md
index 70be00390..95594a3e9 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-hermite.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/101-hermite.md
@@ -1 +1,3 @@
-# Hermite
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/102-bezier.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/102-bezier.md
index 12b8cca4e..b119d6b9a 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/102-bezier.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/102-bezier.md
@@ -1 +1,3 @@
-# Bezier
\ No newline at end of file
+# Bezier
+
+`Bezier curves` are named after Pierre Bezier, a French engineer working at Renault, who used them in the 1960s for designing car bodies. A Bezier curve is defined by a set of control points with a minimum of two but no upper limit. The curve is calculated between the first and the last control point and does not pass through the controlling points, which only influence the direction of the curve. There are linear, quadratic, and cubic Bezier curves, but curves with more control points are also possible. They are widely used in computer graphics, animations, and are extensively used in vector images and tools to create shapes, texts, and objects.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/103-catmull-rom.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/103-catmull-rom.md
index fed7c0101..e35ba43f8 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/103-catmull-rom.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/103-catmull-rom.md
@@ -1 +1,3 @@
-# Catmull rom
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/index.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/index.md
index 1e49e92fa..d4653a6d6 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/index.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/106-orientation/index.md
@@ -1 +1,3 @@
-# Orientation
\ No newline at end of file
+# Curve
+
+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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/100-perspective.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/100-perspective.md
index 9386127c2..59d9aa077 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/100-perspective.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/100-perspective.md
@@ -1 +1,3 @@
-# Perspective
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/101-orthogonal.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/101-orthogonal.md
index 92250ed09..b3c69c369 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/101-orthogonal.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/101-orthogonal.md
@@ -1 +1,3 @@
-# Orthogonal
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/index.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/index.md
index 5e8824f92..2c8d70345 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/index.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/107-projection/index.md
@@ -1 +1,3 @@
-# Projection
\ No newline at end of file
+# Projection
+
+`Projection` in game mathematics often refers to the method by which three-dimensional images are transferred to a two-dimensional plane, typically a computer screen. There are two main types of projection in game development; `Orthographic Projection` and `Perspective Projection`. In the Orthographic Projection, objects maintain their size regardless of their distance from the camera. This is often used in 2D games or 3D games where perspective is not important. On the other hand, Perspective Projection mimics human eye perspective, where distant objects appear smaller. This method provides a more realistic rendering for 3D games. It's crucial to understand projection in game development because it governs how virtual 3D spaces and objects are displayed on 2D viewing platforms.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/101-game-mathematics/index.md b/src/data/roadmaps/game-developer/content/101-game-mathematics/index.md
index 51a0739f3..1931f95a5 100644
--- a/src/data/roadmaps/game-developer/content/101-game-mathematics/index.md
+++ b/src/data/roadmaps/game-developer/content/101-game-mathematics/index.md
@@ -1 +1,3 @@
-# Game mathematics
\ No newline at end of file
+# Game Mathematics
+
+"Game Mathematics" is a critical aspect of game development that deals with the use of mathematical concepts to create and control game mechanics. This involves areas such as geometry for 3D modelling, logic for game rules, algebra for scoring systems, and trigonometry for movements or trajectories. Understanding game mathematics enables developers to implement features like physics simulation, AI behaviours, and procedural generation. Advanced topics include complex calculations for graphics (e.g., shaders, lighting) and calculus for continuous animation or advanced physics. The mathematical complexity depends on the game's demands, but a solid foundation is crucial for any game developer.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/100-center-of-mass.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/100-center-of-mass.md
index 289449d5b..a451035cf 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/100-center-of-mass.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/100-center-of-mass.md
@@ -1 +1,3 @@
-# Center of mass
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/101-acceleration.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/101-acceleration.md
index 8b339158c..5c96eea42 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/101-acceleration.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/101-acceleration.md
@@ -1 +1,3 @@
-# Acceleration
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/102-force.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/102-force.md
index 8792e8334..37c886d48 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/102-force.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/102-force.md
@@ -1 +1,3 @@
-# Force
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/103-angular-velocity.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/103-angular-velocity.md
index e07e7b441..de2e2008e 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/103-angular-velocity.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/103-angular-velocity.md
@@ -1 +1,3 @@
-# Angular velocity
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/104-linear-velocity.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/104-linear-velocity.md
index fb19c5b48..27bc4a9ba 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/104-linear-velocity.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/104-linear-velocity.md
@@ -1 +1,3 @@
-# Linear velocity
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/105-moment-of-inertia.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/105-moment-of-inertia.md
index b4bbb871b..8e1daa700 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/105-moment-of-inertia.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/105-moment-of-inertia.md
@@ -1 +1,3 @@
-# Moment of inertia
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/106-joints.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/106-joints.md
index 9cc59cb62..d8e579f66 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/106-joints.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/106-joints.md
@@ -1 +1,3 @@
-# Joints
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/107-restitution.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/107-restitution.md
index b279045ec..653d9b5d3 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/107-restitution.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/107-restitution.md
@@ -1 +1,3 @@
-# Restitution
\ No newline at end of file
+# Restitution
+
+In game development, **Restitution** is a property closely related to the physics of objects. Essentially, restitution represents the "bounciness" of an object or, in more scientific terms, the ratio of the final relative velocity to the initial relative velocity of two objects after a collision. In the context of game physics, when objects collide, restitution is used to calculate how much each object should bounce back or recoil. Restitution values typically fall between 0 and 1 where a value of 0 means an object will not bounce at all and a value of 1 refers to a perfectly elastic collision with no energy lost. Therefore, the higher the restitution value, the higher the bounce back of the object after a collision.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/108-buoyancy.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/108-buoyancy.md
index c7d0fc5cf..1100a4a07 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/108-buoyancy.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/108-buoyancy.md
@@ -1 +1,3 @@
-# Buoyancy
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/109-friction.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/109-friction.md
index 90936e9aa..6817251f0 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/109-friction.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/109-friction.md
@@ -1 +1,3 @@
-# Friction
\ No newline at end of file
+# Friction
+
+`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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/index.md
index cb78cd310..9abf00af5 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/100-dynamics/index.md
@@ -1 +1,3 @@
-# Dynamics
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/100-ccd.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/100-ccd.md
index 9b52312c3..a88c39138 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/100-ccd.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/100-ccd.md
@@ -1 +1,3 @@
-# Ccd
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/convex-decomposition.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/convex-decomposition.md
index 65e807107..1afd98668 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/convex-decomposition.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/convex-decomposition.md
@@ -1 +1,3 @@
-# Convex decomposition
\ No newline at end of file
+# 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'.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/index.md
index b8797dd92..254409c6f 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/concave/index.md
@@ -1 +1,5 @@
-# Concave
\ No newline at end of file
+# Concave
+
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/convex-hull.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/convex-hull.md
index 6b72223c8..eed73599e 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/convex-hull.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/convex-hull.md
@@ -1 +1,3 @@
-# Convex hull
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/index.md
index 2d07eb9ed..685d734f1 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/convex/index.md
@@ -1 +1,3 @@
-# Convex
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/index.md
index 901cf20b4..7dd2ec152 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/convexity/index.md
@@ -1 +1,3 @@
-# Convexity
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/index.md
index ec7f91cf0..68b3413b5 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/index.md
@@ -1 +1,3 @@
-# Narrow phase
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/epa.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/epa.md
index dfc2e0c0d..370b328b1 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/epa.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/epa.md
@@ -1 +1,3 @@
-# Epa
\ No newline at end of file
+# 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.
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/gjk.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/gjk.md
index a8d2a5003..5f41d6607 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/gjk.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/gjk.md
@@ -1 +1,5 @@
-# Gjk
\ No newline at end of file
+# GJK
+
+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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/index.md
index 5a59d8334..48c817089 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/index.md
@@ -1 +1,3 @@
-# Intersection
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/sat.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/sat.md
index 2a6b071d8..0c4ae39b7 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/sat.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/101-narrow-phase/intersection/sat.md
@@ -1 +1,3 @@
-# Sat
\ No newline at end of file
+# SAT
+
+`Sat`, or separating axis theorem, is frequently used in collision detection in game development. Its primary benefit is for simple and fast detection of whether two convex polygons intersect. The theorem is somewhat complex—it works by projecting all points of both polygons onto numerous axes around the shapes, then checking for overlaps. However, it can be relatively time-consuming when dealing with more complex models or numerous objects as it has to calculate the projections, so often it is used in a broad-phase detection system. A deep explanation of how `sat` works might involve some mathematical concepts or visual aids, but this is the foundation of its use in game development.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/aabb.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/aabb.md
index 93a649e21..e947eec6d 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/aabb.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/aabb.md
@@ -1 +1,3 @@
-# Aabb
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/index.md
index 5d723f35b..626f6c567 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/index.md
@@ -1 +1,3 @@
-# Bounding volume
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/obb.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/obb.md
index b20a77d28..f203a7495 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/obb.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/bounding-volume/obb.md
@@ -1 +1,3 @@
-# Obb
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/index.md
index 83db32d75..fed69797e 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/index.md
@@ -1 +1,3 @@
-# Broad phase
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/dbvt.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/dbvt.md
index 98224e023..ecc1d075b 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/dbvt.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/dbvt.md
@@ -1 +1,3 @@
-# Dbvt
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/index.md
index c42f217c4..99bc58941 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/bvh/index.md
@@ -1 +1,3 @@
-# Bvh
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/index.md
index b97b5859d..d23abf5d8 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/index.md
@@ -1 +1,3 @@
-# Spatial partitioning
\ No newline at end of file
+# Spatial Partitioning
+
+"Spatial partitioning" is a technique used in computational geometry, intended to make calculations involving objects in space more efficient. It involves dividing a large virtual space into a series of smaller spaces, or "partitions". These partitions can be used to quickly eliminate areas that are irrelevant to a particular calculation or query, thus lowering the overall computational cost. This technique is widely used in game development in contexts such as collision detection, rendering, pathfinding, and more. Various methods exist for spatial partitioning, including grid-based, tree-based (like Quadtree and Octree), and space-filling curve (like Z-order or Hilbert curve) approaches.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/sort-and-sweep.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/sort-and-sweep.md
index e01930df5..fd3db4a5c 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/sort-and-sweep.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/102-broad-phase/spatial-partitioning/sort-and-sweep.md
@@ -1 +1,3 @@
-# Sort and sweep
\ No newline at end of file
+# Sort and Sweep
+
+**Sort and Sweep** is an algorithm used in collision detection in game development which optimizes the process of identifying potential intersecting objects. Here's how it works: first, all objects in the game are sorted along a specific axis (typically the 'x' axis). Then a line (known as the 'sweep line') is moved along this axis. As the line sweeps over the scene, any objects that cross this line are added to an 'active' list. When an object no longer intersects with the sweep line, it's removed from this list. The only objects checked for intersection are those within this 'active' list reducing the number of checks required. This makes sort and sweep an efficient spatial partitioning strategy.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/index.md
index 56adaecea..8ae74b6e6 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/101-collision-detection/index.md
@@ -1 +1,3 @@
-# Collision detection
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/102-game-physics/index.md b/src/data/roadmaps/game-developer/content/102-game-physics/index.md
index ffd688fb6..efd8cd150 100644
--- a/src/data/roadmaps/game-developer/content/102-game-physics/index.md
+++ b/src/data/roadmaps/game-developer/content/102-game-physics/index.md
@@ -1 +1,3 @@
-# Game physics
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/103-game-engine/100-godot.md b/src/data/roadmaps/game-developer/content/103-game-engine/100-godot.md
index a36f3106c..95c2a401a 100644
--- a/src/data/roadmaps/game-developer/content/103-game-engine/100-godot.md
+++ b/src/data/roadmaps/game-developer/content/103-game-engine/100-godot.md
@@ -1 +1,3 @@
-# Godot
\ No newline at end of file
+# Godot
+
+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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/103-game-engine/101-unreal-engine.md b/src/data/roadmaps/game-developer/content/103-game-engine/101-unreal-engine.md
index 1aeb9db1d..125d18052 100644
--- a/src/data/roadmaps/game-developer/content/103-game-engine/101-unreal-engine.md
+++ b/src/data/roadmaps/game-developer/content/103-game-engine/101-unreal-engine.md
@@ -1 +1,3 @@
-# Unreal engine
\ No newline at end of file
+# Unreal Engine
+
+The **Unreal Engine** is a powerful game development engine created by Epic Games. Used by game developers worldwide, it supports the creation of high-quality games across multiple platforms such as iOS, Android, Windows, Mac, Xbox, and PlayStation. Unreal Engine is renowned for its photo-realistic rendering, dynamic physics and effects, robust multiplayer framework, and its flexible scripting system called Blueprint. The engine is also fully equipped with dedicated tools and functionalities for animation, AI, lighting, cinematography, and post-processing effects. The most recent version, Unreal Engine 5, introduces real-time Global Illumination and makes film-quality real-time graphics achievable.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/103-game-engine/102-native.md b/src/data/roadmaps/game-developer/content/103-game-engine/102-native.md
index 4ce1e1ec9..03b8e46fc 100644
--- a/src/data/roadmaps/game-developer/content/103-game-engine/102-native.md
+++ b/src/data/roadmaps/game-developer/content/103-game-engine/102-native.md
@@ -1 +1,3 @@
-# Native
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/103-game-engine/103-unity-3d.md b/src/data/roadmaps/game-developer/content/103-game-engine/103-unity-3d.md
index 5bd2c9149..e47afe041 100644
--- a/src/data/roadmaps/game-developer/content/103-game-engine/103-unity-3d.md
+++ b/src/data/roadmaps/game-developer/content/103-game-engine/103-unity-3d.md
@@ -1 +1,3 @@
-# Unity 3d
\ No newline at end of file
+# Unity 3D
+
+**Unity 3D** is a versatile, cross-platform game engine that supports the development of both 2D and 3D games. This game engine allows users to create a wide variety of games including AR, VR, Mobile, Consoles, and Computers. It provides a host of powerful features and tools, such as scripting, asset bundling, scene building, and simulation, to assist developers in creating interactive content. Unity 3D also boasts a large, active community that regularly contributes tutorials, scripts, assets, and more, making it a robust platform for all levels of game developers.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/103-game-engine/index.md b/src/data/roadmaps/game-developer/content/103-game-engine/index.md
index 666dc62d7..5cf71c487 100644
--- a/src/data/roadmaps/game-developer/content/103-game-engine/index.md
+++ b/src/data/roadmaps/game-developer/content/103-game-engine/index.md
@@ -1 +1,3 @@
-# Game engine
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/104-programming-languages/100-c-cpp.md b/src/data/roadmaps/game-developer/content/104-programming-languages/100-c-cpp.md
index fdaae3723..c6e597900 100644
--- a/src/data/roadmaps/game-developer/content/104-programming-languages/100-c-cpp.md
+++ b/src/data/roadmaps/game-developer/content/104-programming-languages/100-c-cpp.md
@@ -1 +1,7 @@
-# C cpp
\ No newline at end of file
+# C / C++
+
+**C** and **C++ (commonly known as CPP)** are two of the most foundational high-level programming languages in computer science. **C** was developed in the 1970s and it is a procedural language, meaning it follows a step-by-step approach. Its fundamental principles include structured programming and lexical variable scope.
+
+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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/104-programming-languages/101-csharp.md b/src/data/roadmaps/game-developer/content/104-programming-languages/101-csharp.md
index ad0f08296..08c14a3c4 100644
--- a/src/data/roadmaps/game-developer/content/104-programming-languages/101-csharp.md
+++ b/src/data/roadmaps/game-developer/content/104-programming-languages/101-csharp.md
@@ -1 +1,3 @@
-# Csharp
\ No newline at end of file
+# C#
+
+**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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/104-programming-languages/102-assembly.md b/src/data/roadmaps/game-developer/content/104-programming-languages/102-assembly.md
index f321e7dde..7c13f7383 100644
--- a/src/data/roadmaps/game-developer/content/104-programming-languages/102-assembly.md
+++ b/src/data/roadmaps/game-developer/content/104-programming-languages/102-assembly.md
@@ -1 +1,3 @@
-# Assembly
\ No newline at end of file
+# Assembly
+
+**Assembly** is a low-level programming language, often used for direct hardware manipulation, real-time systems, and to write performance-critical code. It provides a strong correspondence between its instructions and the architecture's machine-code instructions, since it directly represents the specific commands of the computer's CPU structure. However, it's closer to machine language (binary code) than to human language, which makes it difficult to read and understand. The syntax varies greatly, which depends upon the CPU architecture for which it's designed, thus Assembly language written for one type of processor can't be used on another. Despite its complexity, time-intensive coding process and machine-specific nature, Assembly language is still utilized for speed optimization and hardware manipulation where high-level languages may not be sufficient.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/104-programming-languages/103-rust.md b/src/data/roadmaps/game-developer/content/104-programming-languages/103-rust.md
index 8fc1f9db2..2f64489eb 100644
--- a/src/data/roadmaps/game-developer/content/104-programming-languages/103-rust.md
+++ b/src/data/roadmaps/game-developer/content/104-programming-languages/103-rust.md
@@ -1 +1,3 @@
-# Rust
\ No newline at end of file
+# Rust
+
+**Rust** is a modern, open-source, multi-paradigm programming language designed for performance and safety, especially safe concurrency. It was initially designed by Mozilla Research as a language that can provide memory safety without garbage collection. Since then, it has gained popularity due to its features and performance that often compare favorably to languages like C++. Its rich type system and ownership model guarantee memory-safety and thread-safety while maintaining a high level of abstraction. Rust supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/104-programming-languages/104-python.md b/src/data/roadmaps/game-developer/content/104-programming-languages/104-python.md
index 92106a828..18877ac95 100644
--- a/src/data/roadmaps/game-developer/content/104-programming-languages/104-python.md
+++ b/src/data/roadmaps/game-developer/content/104-programming-languages/104-python.md
@@ -1 +1,3 @@
-# Python
\ No newline at end of file
+# Python
+
+Python is a popular high-level programming language that was designed by Guido van Rossum and published in 1991.  It is preferred for its simplicity in learning and usage, making it a great choice for beginners. Python's design philosophy emphasizes code readability with its use of significant indentation. Its language constructs and object-oriented approach aim to help developers write clear, logical code for small and large-scale projects. Python is dynamically-typed and garbage-collected. Moreover, it supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Python is often used for web development, software development, database operations, and machine learning. Although not typically used for game development, some game developers utilize Python for scripting and automating tasks.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/104-programming-languages/index.md b/src/data/roadmaps/game-developer/content/104-programming-languages/index.md
index a14baa504..b9495160c 100644
--- a/src/data/roadmaps/game-developer/content/104-programming-languages/index.md
+++ b/src/data/roadmaps/game-developer/content/104-programming-languages/index.md
@@ -1 +1,3 @@
-# Programming languages
\ No newline at end of file
+# Programming Languages
+
+Programming languages are very crucial to game development as they are the backbone of game design and functionality. A variety of languages can be used, but some are more commonly preferred in the industry due to their robustness and efficiency. The most popular ones include C++, C#, and Java. **C++**, a high-level language primarily used for developing video games, is known for its speed and efficiency. **C#**, which was developed by Microsoft, is extensively used with the Unity game engine to develop multi-platform games. **Java** is well-established in the sector as well, and it often utilized in the development of Android games. It's pivotal for a game developer to select a language that aligns with the project's requirements and nature. Despite the programming language you choose, a deep understanding of its constructs, logic, and capabilities is required for successful game development.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/100-ray-tracing.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/100-ray-tracing.md
index 776e23265..797bd40b7 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/100-ray-tracing.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/100-ray-tracing.md
@@ -1 +1,3 @@
-# Ray tracing
\ No newline at end of file
+# Ray Tracing
+
+Ray tracing is a rendering technique in computer graphics that simulates the physical behavior of light. It generates images with a high degree of visual realism, as it captures shadows, reflections, and refracts light. Ray tracing follows the path of light backwards from the camera (eye) to the source (light object), calculating the color of each pixel in the image on the way. The color value calculation considers the object from which the ray has reflected or refracted, and the nature of the light source i.e. whether it's ambient, point or spot. Ray tracing algorithm handles effects that rasterization algorithms like scanline rendering and 'Z-buffer' find complex to handle.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/101-rasterization.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/101-rasterization.md
index 3065de59e..3fc52bb3b 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/101-rasterization.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/101-rasterization.md
@@ -1 +1,3 @@
-# Rasterization
\ No newline at end of file
+# Rasterization
+
+In the realm of computer graphics, **Rasterization** refers to the process of converting the image data into a bitmap form, i.e., pixels or dots. It is predominantly used in 3D rendering where three-dimensional polygonal shapes are transformed into a two-dimensional image, possessing height, width, and color data. It is a scan-conversion process where vertices and primitives, upon being processed through the graphics pipeline, are mathematically converted into fragments. Every fragment finds its position in a raster grid. The process culminates in fragments becoming pixels in the frame buffer, the final rendered image you see on the screen. However, it's essential to note that rasterization does limit the image's resolution to the resolution of the device on which it is displayed.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/102-graphics-pipeline.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/102-graphics-pipeline.md
index 67a12f65f..991c1bae3 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/102-graphics-pipeline.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/102-graphics-pipeline.md
@@ -1 +1,3 @@
-# Graphics pipeline
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/103-sampling.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/103-sampling.md
index 1fe47294c..9791b7a5b 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/103-sampling.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/103-sampling.md
@@ -1 +1,3 @@
-# Sampling
\ No newline at end of file
+# Sampling
+
+**Sampling** in computer graphics is a method used to convert a continuous mathematical function (image, signal, light and sound), into a discrete digital representation. The process is done by taking snapshots at regular intervals which are also known as samples, and it's this that gives us the concept of 'sampling'. Some common types of sampling techniques include: uniform sampling (evenly spaced samples), random sampling (samples taken at random intervals), and jittered sampling (a compromise between uniform and random sampling). The higher the sampling rate, the more accurately the original function can be reconstructed from the discrete samples. Effective sampling is a significant aspect of achieving realistic computer graphics.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/104-computer-animation.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/104-computer-animation.md
index a6257c69f..af79a6424 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/104-computer-animation.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/104-computer-animation.md
@@ -1 +1,5 @@
-# Computer animation
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/105-color.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/105-color.md
index 4ceeed37b..0e9c61c0d 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/105-color.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/105-color.md
@@ -1 +1,3 @@
-# Color
\ No newline at end of file
+# Color
+
+In the realm of computer graphics, color plays an integral role. It can be defined in various color models such as RGB (Red, Green, Blue), CYMK (Cyan, Yellow, Magenta, Black), and others. RGB is a color model that combines the primary colors (red, green, blue) in different amounts to produce a spectrum of colors. This model is often used in digital displays. In contrast, CMYK is a color model used in color printing. It uses cyan, magyenta, yellow, and black as the primary colors. HSL (Hue, Saturation, Lightness) and HSV (Hue, Saturation, Value) are other useful models that represent colors based on human perceptions. Another important element of color in computer graphics is the color depth, also known as bit depth, which determines the number of colors that can be displayed at once.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/106-visual-perception.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/106-visual-perception.md
index 27f5e6d3c..320658122 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/106-visual-perception.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/106-visual-perception.md
@@ -1 +1,3 @@
-# Visual perception
\ No newline at end of file
+# Visual Perception
+
+Visual Perception is a fundamental aspect of game development, widely explored within the field of computer graphics. It involves the ability to interpret and understand the visual information that our eyes receive, essential to create immersive and dynamic visual experiences in games. The study involves the understanding of light, color, shape, form, depth, and motion, among others, which are key elements to create aesthetically pleasing and engaging graphics. Making full use of visual perception allows the game developers to control and manipulate how the gamers interact with and experience the game world, significantly enhancing not only the visual appeal but also the overall gameplay. 
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/107-tone-reproduction.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/107-tone-reproduction.md
index 1b3ae5b3f..fbb682d94 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/107-tone-reproduction.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/107-tone-reproduction.md
@@ -1 +1,3 @@
-# Tone reproduction
\ No newline at end of file
+# Tone Reproduction
+
+`Tone Reproduction` or `Tone Mapping` is the technique used in computer graphics to simulate the appearance of high-dynamic-range images in media with a more limited dynamic range. Print-outs, CRT, LCD monitors, and other displays can only reproduce a reduced dynamic range. This technique is widely used in gaming development, where developers employ it to improve the visual experience. The process involves taking light from a scene and mapping it to a smaller range of tones while preserving the visual appearance—i.e., regarding brightness, saturation, and hue. There are various tone mapping algorithms available, each with unique attributes suitable for different imaging tasks.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/100-render-equation.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/100-render-equation.md
index b36135381..321535cf9 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/100-render-equation.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/100-render-equation.md
@@ -1 +1,3 @@
-# Render equation
\ No newline at end of file
+# Rendering Equation
+
+The **Render Equation**, also known as the **Rendering Equation**, is a fundamental principle in computer graphics that serves as the basis for most advanced lighting algorithms today. First introduced by James Kajiya in 1986, it defines how light interacts with physical objects in a given environment. The equation tries to simulate light's behavior, taking into account aspects such as transmission, absorption, scattering, and emission. The equation can be computationally intensive to solve accurately. It's worth mentioning, however, that many methods have been developed to approximate and solve it, allowing the production of highly realistic images in computer graphics.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/diffuse.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/diffuse.md
index 944d02bca..adf16d419 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/diffuse.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/diffuse.md
@@ -1 +1,3 @@
-# Diffuse
\ No newline at end of file
+# Diffuse
+
+**Diffuse** shading is one of the fundamental aspects within a game's graphics system. It is a property of light that allows it to scatter in an infinite number of directions after striking a surface, resulting in a soft, washed-out, and non-specular appearance. This type of reflection is visible from all angles regardless of the viewer's perspective, giving objects in video games a more realistic, three-dimensional look. It's essential for modeling the way light hits flat, matte, or non-shiny surfaces like cloth or rough stone. Factors such as the angle of incidence and the light's intensity do influence the brightness of the diffuse reflection.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/index.md
index bcc10cdcf..5e82675f3 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/index.md
@@ -1 +1,3 @@
-# Reflection
\ No newline at end of file
+# Reflection
+
+Reflection in game development, specifically in shaders, is a phenomena that simulates the bouncing off of light from objects similar to the way it happens in the real world. Shaders replicate this effect by emitting rays from the lighting source against the object's surface. When the ray strikes the surface, it will calculate the light’s color and angle to define how light should reflect off that surface. Reflection in shaders can further be classified into two types: Specular Reflection and Diffuse Reflection. Specular Reflection is the mirror-like reflection of light from a surface, where each incident ray is reflected with the light ray reflected at an equal but opposite angle. Diffuse Reflection, on the other hand, is the reflection of light into many directions, giving a softer effect. These reflections are quantified in computer graphics often using a reflection model such as the Phong reflection model or the Lambertian reflectance model.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/specular.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/specular.md
index 5c889d2dc..fe54d8986 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/specular.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/101-reflection/specular.md
@@ -1 +1,3 @@
-# Specular
\ No newline at end of file
+# Specular
+
+Specular reflection, often referred to simply as "specularity", pertains to the glossiness of a gaming object's surface. It represents the mirror-like reflection of light from the surface, providing that shiny, polished appearance on the objects. The specular value details how much of the light hitting the object is reflected directly into the viewer's eyes, creating a bright, shiny spot. This reflective value can be fine-tuned using the specular color and intensity settings to match specific object properties – like the reflectiveness of plastic versus metal. In practice, this is often used to simulate the subtle reflections from the rough surface, offering a greater sense of realism in the game's visual representation.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/bump.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/bump.md
index 38ed0e421..1f1cd04d1 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/bump.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/bump.md
@@ -1 +1,3 @@
-# Bump
\ No newline at end of file
+# Bump
+
+Bump mapping is a technique in computer graphics for simulating bumps and wrinkles on the surface of an object. This is achieved by modifying the surface normals of the object and using the modified normals during lighting calculations. The result is an apparently bumpy surface rather than a smooth surface, despite the surface geometry being unchanged. Normal maps, which are a type of bump map, store the perturbations of the surface normals in an RGB image. When applied to a model, they can greatly enhance the level of perceived detail without increasing the polygon count. To emphasize, bump mapping doesn't change the geometry of the model, only the lighting calculations across its surface.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/horizon.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/horizon.md
index 436c61419..3d27e5d42 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/horizon.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/horizon.md
@@ -1 +1,3 @@
-# Horizon
\ No newline at end of file
+# Horizon
+
+In the context of game development, "horizon" is typically referred to as the farthest point visible in a game's terrain, map, or landscape. It's where the sky meets the ground from the player's perspective. The manipulation of the horizon can greatly influence the immersion and realism of a game world. For instance, developers often use techniques like "Horizon Mapping" or "SkyBox" to visually represent the horizon and far-off scenery. A detailed and well-designed horizon can add vastness into the world, even if the playable area is limited. However, the horizon also poses performance considerations, as rendering vast landscapes can lead to extensive processing demands and memory consumption. Therefore, techniques like fogging, level of detail (LOD) reduction, and horizon occlusion are often used to manage the performance.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/index.md
index 24afcedcf..e9a3c2b7f 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/index.md
@@ -1 +1,7 @@
-# Mapping
\ No newline at end of file
+# Mapping
+
+"Mapping" in game development, especially in the context of shaders, predominantly refers to Texture Mapping and Normal Mapping. 
+
+- **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.
+
+- **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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/parallax.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/parallax.md
index f3b6ba722..9c93d183b 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/parallax.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/parallax.md
@@ -1 +1,3 @@
-# Parallax
\ No newline at end of file
+# Parallax
+
+Parallax is a powerful technique employed in game development to establish depth in 2D games. The term 'Parallax' comes from the Greek word 'parallaxis', which means alteration. In game development, parallax creates an illusion of depth by making background images move slower compared to the foreground images when the player moves. This is due to the phenomenon where objects that are farther away seem to move at a slower speed compared to closer ones. There are different types of parallax techniques like the traditional parallax scrolling, multi-layered parallax, and parallax mapping. Parallax Mapping, also known as offset mapping or virtual displacement mapping, is a method used to fake details on a surface to give the illusion of depth or surface irregularities.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/texture.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/texture.md
index 028dabc10..e0553d13d 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/texture.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/102-mapping/texture.md
@@ -1 +1,4 @@
-# Texture
\ No newline at end of file
+# Texture
+
+
+**Texture** refers to the 2D artwork added on a 3D model to give it a convincing and detailed appearance in video games. These textures can represent various properties like color, reflectivity, light absorption, transparency, etc., depending on the needs of the game. Textures can be created through various methods like drawing, painting, or photography and then manipulated digitally. Depending on the topological structure of the 3D model, it can be directly textured (in case of UV maps) or through procedural methods. Different types of textures like albedo/diffuse, specular, normal/bump, displacement are used to achieve different visual effects. The texturing process is a crucial step in game development as it greatly enhances the realism and appeal of the 3D environment and characters.
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/index.md
index 8e748116a..ebcc3e3b9 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/108-shader/index.md
@@ -1 +1,3 @@
-# Shader
\ No newline at end of file
+# Shader
+
+Shaders are a type of software used in 3D computer graphics. They are utilized to render quality visual effects by making calculations and transformations on image data. Also, a shader is responsible for determining the final color of an object. There are several types of shaders: vertex shaders, geometry shaders, pixel shaders, and compute shaders. Each of these is programmed to manipulate specific attributes of an image, such as its vertices, pixels, and overall geometry. They are essential tools for game developers aiming to produce realistic and engaging visual experiences.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/100-stencil-shadow.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/100-stencil-shadow.md
index 5a5c66354..e6ae538be 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/100-stencil-shadow.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/100-stencil-shadow.md
@@ -1 +1,3 @@
-# Stencil shadow
\ No newline at end of file
+# Stencil Shadow
+
+`Stencil shadows` are a technique used in 3D computer graphics for creating shadows. The stencil shadow algorithm operates by treating a shadow as a 3D volume of space, known as a shadow volume. Any part of the scene that lies inside this shadow volume will be in shadow. If it lies outside the shadow volume, it will be in light. The shadow volume is created by extruding the polygonal silhouette of a 3D object into space along the lines of sight from the light source. For equivalent complex objects, the number of edges or vertices to fill the stencil buffer will generally be less than the number of pixels needed to compute shadow maps, making stencil shadows more efficient in that regard. However, the shadows produced by this technique can look blocky or unrealistic if not further refined.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/2d.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/2d.md
index 656ddd160..8ac757dbf 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/2d.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/2d.md
@@ -1 +1,3 @@
-# 2d
\ No newline at end of file
+# 2D
+
+2D, or two-dimensional, refers to games or elements that are designed on a two-dimensional plane. It's a classic method in game development and it's primarily used for platformers, puzzles, RPGs (Role-playing Games), and arcade games. In 2D games, the graphics are typically a bit simpler since they only deal with height and width, disregarding depth. Examples of graphical assets used in 2D game development are sprites and tilemaps. For coding and physics, it uses simpler mathematics compared to 3D. Some of the popular 2D game development engines are `Unity 2D`, `Godot`, and `GameMaker Studio 2`. These engines simplify the process of developing 2D games, providing tools and features such as 2D physics, sprite manipulation, and AI (Artificial Intelligence) pathfinding specific for two-dimensions.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cascaded.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cascaded.md
index e0214e141..4cfde2875 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cascaded.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cascaded.md
@@ -1 +1,3 @@
-# Cascaded
\ No newline at end of file
+# Cascaded
+
+"Cascaded" refers to the Cascaded Shadow Maps (CSM) technique implemented in graphical computations. It involves the procedure of dividing the view frustum, the portion of a 3D space visualized on the screen, into several sub-frustums or "cascades". Each cascade corresponds to a different shadow map, allowing various levels of details for shadows in a single render. Each cascade uses a different region of the shadow map texture, facilitating the ability to provide finer shadow detail close to the camera and coarser detail as the distance from the camera increases. This technique helps in the efficient utilization of shadow map resolution and improves visual quality by reducing aliasing artifacts in the distance.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cube.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cube.md
index 0212c8a35..88ec73615 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cube.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/cube.md
@@ -1 +1,3 @@
-# Cube
\ No newline at end of file
+# Cube
+
+A **Cube** is a three-dimensional geometric figure known for its symmetric and box-like shape. It is also characterized by its equal length, width, and height dimensions. In game development, cubes can be the starting point for creating more complex 3D models. They are utilized in numerous ways such as creating physical objects, defining environments, constructing characters, and more. Furthermore, in the context of a shadow map, a cube map can be generated to deal with omnidirectional light sources. Cube mapping, a process that uses a six-sided cube as the map shape, is particularly useful for creating reflections and applying textures on 3D models.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/index.md
index c4aa2011d..050a30643 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/101-shadow-map/index.md
@@ -1 +1,7 @@
-# Shadow map
\ No newline at end of file
+# Shadow Map
+
+Shadow mapping is a technique used in computer graphics to add shadows to a scene. This process involves two steps - generating the shadow map and then rendering the scene. 
+
+In the shadow map generating step, the scene is rendered from the perspective of the light source capturing depth information. This results in a texture that stores the distance from the light to the nearest surface along each light direction, a “shadow map”.
+
+In the scene rendering step, the scene is rendered from the camera’s perspective. For each visible surface point, its distance from the light is calculated and compared to the corresponding stored distance in the shadow map. If the point's distance is greater than the stored distance, the point is in shadow; otherwise, it's lit. This information is used to adjust the color of the point, producing the shadow effect.
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/directional-light.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/directional-light.md
index 6afa27aa5..98e7ae6da 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/directional-light.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/directional-light.md
@@ -1 +1,3 @@
-# Directional light
\ No newline at end of file
+# Directional Light
+
+`Directional light` is a type of light commonly utilized in 3D game development. As the name suggests, this form of light appears to be coming from a specific direction, much as sunlight does in reality. In actuality, it extends infinitely in a single direction and doesn't emanate from a specific source like point or spotlights do. This property allows it to illuminate all objects within a scene uniformly. Directional light is particularly useful for replicating large and distant light sources such as the sun or moon.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/index.md
index 20a7d6585..60673fc4b 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/index.md
@@ -1 +1,3 @@
-# Light source
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/infinite-light.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/infinite-light.md
index 8b44146eb..a39637dbc 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/infinite-light.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/infinite-light.md
@@ -1 +1,3 @@
-# Infinite light
\ No newline at end of file
+# Infinite Light
+
+`Infinite light` in game development refers to a type of light source that emits light rays in parallel. This source is assumed to be located at an infinite distance away, hence the term 'infinite light'. Each ray of light coming from the source is regarded as a straight line. This is especially useful for simulating sunlight or far off light sources in outdoor scenes as the light rays from these sources, when received on earth, can be safely assumed to be parallel to each other. However, keep in mind that infinite light does not produce any localized lighting effects or shadows, as it dispenses even lighting throughout your scene.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/point-light.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/point-light.md
index de363109d..7ae043abe 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/point-light.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/point-light.md
@@ -1 +1,3 @@
-# Point light
\ No newline at end of file
+# Point Light
+
+A `Point Light` is a common light source within game development. It simulates a light radiating from a single point equally in all directions, like a light bulb in a room. Because it emits light in all directions, a point light affects every object, regardless of its orientation towards the light source. Additionally, a point light has a location in space and no directional vector, unlike a directional or spot light. It's worth noting that although point lights have an associated range or radius beyond which their intensity is zero, they can consume more computation resources compared to other types of light sources due to their influence over a larger area of the scene. Hence, careful planning is required when using point lights.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/spot-light.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/spot-light.md
index c248e6c7d..69268cc06 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/spot-light.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/102-light-source/spot-light.md
@@ -1 +1,3 @@
-# Spot light
\ No newline at end of file
+# Spot Light
+
+A **Spot Light** is a type of light source used in game development, often utilized to create focused, directional lighting within a specific radius, imitating real-world sources like a flashlight or a stage spotlight. The two primary properties of a spot light are its cone angle and its fall-off. The cone angle determines the size of the illuminated area, while the fall-off controls how quickly the light diminishes towards the edges of the light cone. Spotlights can create dramatic effects and are essential in driving attention towards specific game elements or areas due to their constrained, targeted lighting.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/index.md
index 24fa2286a..07fb12f4d 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/109-lightning-and-shadow/index.md
@@ -1 +1,3 @@
-# Lightning and shadow
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/fog.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/fog.md
index a39d8dbde..637e662ed 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/fog.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/fog.md
@@ -1 +1,3 @@
-# Fog
\ No newline at end of file
+# Fog
+
+In the framework of game development, **fog** is a visual technique applied effectively for various artistic and optimization purposes. Aesthetically, it's used to simulate different atmospheric effects such as smoke, fog, mist, and dust. Fog can also be utilized to conceal or lessen the details of distant objects, hence reducing the rendering load on the system. This technique is often called "distance fog". Moreover, specialized types of fog like "volumetric fog" add a three-dimensional feel to the game, making the lighting atmosphere more immersive and realistic. Note that fog settings and effects can be adjusted based on different game engines, such as Unreal Engine, Unity, or Godot.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/index.md
index 07980b7e3..b174cad5a 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/100-occluder/index.md
@@ -1 +1,3 @@
-# Occluder
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/frustum.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/frustum.md
index 90044ca39..f340ad28b 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/frustum.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/frustum.md
@@ -1 +1,3 @@
-# Frustum
\ No newline at end of file
+# Frustum
+
+`Frustum` is a term commonly used in the game development industry and is intensely associated with the concept of "culling". It is the field of view of the camera, or more specifically, the portion of the world that is currently visible to your camera in the game. Shaped like a truncated pyramid (or a pyramid with its top cut off), the frustum's small end is where your camera sits, and the larger end is far away from the camera stretching outwards. Objects within this frustum are what the player sees on their screen, and ones outside are not rendered, which helps increase the performance of the game. Frustum culling, thus, is a computational process to determine which objects are within the frustum and should be drawn.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/index.md
index 7ff08904c..eeb9f1f5e 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/index.md
@@ -1 +1,3 @@
-# Culling
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/light.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/light.md
index 52bd2d13d..7cf50001d 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/light.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/light.md
@@ -1 +1,3 @@
-# Light
\ No newline at end of file
+# Light
+
+Lighting in game development is crucial for creating an immersive and realistic gaming experience. There are several types of light sources, including directional light, point light, and spotlights. Directional light simulates sun or moonlight with parallel rays illuminating the game world. Point light emanates from a single point in all directions, similar to a light bulb. Spotlights produce a cone of light, similar to a flashlight or a stage spotlight. Then, there's Ambient light which creates a base level of light that hits every surface equally, regardless of its orientation or position, making sure no area is ever in complete darkness. These different sources of light can be manipulated to create the desired mood and aesthetic in a scene.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/shadow.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/shadow.md
index 925ef3bfb..c9a9b4138 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/shadow.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/101-culling/shadow.md
@@ -1 +1,3 @@
-# Shadow
\ No newline at end of file
+# Shadow
+
+Shadows contribute significantly to the realism of a virtual scene in gaming. They play a pivotal role in determining an object's position relative to other objects and surfaces. Shadows are largely incorporated through two major techniques in game development: 'Shadow Mapping' and 'Shadow Volumes'. Shadow Mapping is a process that involves creating a depth map from the light source's point of view. Shadow Volumes, on the other hand, use stencil buffers to draw shadows onto scenes. These are computationally intense processes which can be optimized using various techniques such as Cascaded Shadow Maps, and Umbra and Penumbra calculations. Furthermore, developers have the challenge to implement dynamic shadows that react to changing light sources and positions, as well as static shadows for non-moving objects. It's essential that developers learn how to implement, optimize and balance shadows effectively to provide immersive and dynamic game play experiences.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/index.md
index c56743ec9..56c2f6536 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/index.md
@@ -1 +1,3 @@
-# Clipping
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polygon.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polygon.md
index 8f02424d8..80c3488ad 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polygon.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polygon.md
@@ -1 +1,3 @@
-# Polygon
\ No newline at end of file
+# Polygon
+
+`Polygon` is a fundamental term used in computer graphics and game development. It is a plane figure that is described by a finite number of straight line segments connected to form a closed polygonal chain or polygonal circuit. The segments that form a polygon are known as its edges or sides, and the points where the edges meet are the polygon's vertices. In 3D modeling, polygons are used to create the surfaces of objects. Triangles, rectangles, pentagons, hexagons are examples of polygons. Complex 3D models are made up of numerous polygons. Polygons are crucial to determining the detail of 3D models in games; higher polygon counts usually mean higher detail.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polyhedron.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polyhedron.md
index 3f6dbbfa7..c043bc754 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polyhedron.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/102-clipping/polyhedron.md
@@ -1 +1,3 @@
-# Polyhedron
\ No newline at end of file
+# Polyhedron
+
+A **Polyhedron** is a three-dimensional geometric shape, whose faces are polygons. These are bound by straight lines creating a closed shape with flat surfaces and straight edges. Each of the corners or vertices of these shapes meets an equal number of edges. Some common examples include the cube, the pyramid, and the prism. Each polyhedron has a set of properties including volume, surface area and the number of vertices, edges, and faces. The sum of the angles of the polygonal faces gives the total angular defect of the polyhedron. These are fundamental elements in 3D modeling and graphics rendering within the field of game development.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/index.md
index 83fb3454f..31c084a7d 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/110-visibility-and-occlusion/index.md
@@ -1 +1,3 @@
-# Visibility and occlusion
\ No newline at end of file
+# Visibility and Occlusion
+
+"Visibility and occlusion" in computer graphics refers to the process of determining which parts of a particular object are visible from a certain viewpoint and which are hidden. "Occlusion" describes the phenomenon where an object is blocked from view by another object. Understanding these concepts is important for creating realistic renderings in game design. Real-time engines typically use data structures like BSP-trees, Quad-trees or Octrees to quickly identify occlusion. Advanced techniques such as Occlusion culling and Z-buffering are used to further optimize the representation of visible and hidden parts of 3D objects. Understanding the depths and dimensions related to visibility and occlusion empowers the game developer to enhance presentation and performance.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/105-computer-graphics/index.md b/src/data/roadmaps/game-developer/content/105-computer-graphics/index.md
index b32b8b525..239712b3a 100644
--- a/src/data/roadmaps/game-developer/content/105-computer-graphics/index.md
+++ b/src/data/roadmaps/game-developer/content/105-computer-graphics/index.md
@@ -1 +1,3 @@
-# Computer graphics
\ No newline at end of file
+# Computer Graphics
+
+Computer Graphics is a subfield of computer science that studies methods for digitally synthesizing and manipulating visual content. It involves creating and manipulating visual content using specialized computer software and hardware. This field is primarily used in the creation of digital and video games, CGI in films, and also in visual effects for commercials. The field is divided into two major categories: **Raster graphics** and **Vector graphics**. Raster graphics, also known as bitmap, involve the representation of images through a dot matrix data structure, while Vector graphics involve the use of polygons to represent images in computer graphics. Both of these methods have their unique usage scenarios. Other concepts integral to the study of computer graphics include rendering (including both real-time rendering and offline rendering), animation, and 3D modeling. Generally, computer graphics skills are essential for game developers and animation experts.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/100-hlsl.md b/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/100-hlsl.md
index d90aff8c0..ee04df937 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/100-hlsl.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/100-hlsl.md
@@ -1 +1,3 @@
-# Hlsl
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/index.md b/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/index.md
index 0b2313463..5bf4cf1f4 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/index.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/100-direct-x/index.md
@@ -1 +1,3 @@
-# Direct x
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/100-glsl.md b/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/100-glsl.md
index 19e885a1c..d48a88edd 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/100-glsl.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/100-glsl.md
@@ -1 +1,3 @@
-# Glsl
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/index.md b/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/index.md
index 294260e91..e37c5eb22 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/index.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/101-open-gl/index.md
@@ -1 +1,3 @@
-# Open gl
\ No newline at end of file
+# OpenGL
+
+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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/102-web-gl.md b/src/data/roadmaps/game-developer/content/106-graphics-api/102-web-gl.md
index 9b58b9e2a..bec09878d 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/102-web-gl.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/102-web-gl.md
@@ -1 +1,3 @@
-# Web gl
\ No newline at end of file
+# WebGL
+
+`WebGL` (Web Graphics Library) is a JavaScript API that is used to render interactive 2D and 3D graphics within any compatible web browser without the use of plug-ins. It leverages the power of the Graphics Processing Unit (GPU), which provides high-efficiency rendering. WebGL programs consist of control code written in JavaScript and shader code that's written in OpenGL Shading Language (GLSL), allowing developers to control the fine details of graphics rendering. Besides its compatibility with HTML5 and its ability to render on any platform that supports the web, WebGL is entirely integrated into all web standards, facilitating GPU-accelerated image processing and effects.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/103-opengl-es.md b/src/data/roadmaps/game-developer/content/106-graphics-api/103-opengl-es.md
index d8ff4a5bc..5ebe035ad 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/103-opengl-es.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/103-opengl-es.md
@@ -1 +1,3 @@
-# Opengl es
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/104-metal.md b/src/data/roadmaps/game-developer/content/106-graphics-api/104-metal.md
index 319cf8ad4..aa7616ff6 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/104-metal.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/104-metal.md
@@ -1 +1,3 @@
-# Metal
\ No newline at end of file
+# Metal
+
+Metal is a low-level, high-performance, application programming interface (API) developed by Apple. It debuted in iOS 8 and is dedicated to graphics and data-parallel computations. Essentially, it's designed to exploit modern GPU architecture on Apple devices, optimizing performance and power efficiency. This API applies to various platforms, including iOS, macOS, and tvOS. In contrast to high-level APIs like OpenGL, Metal offers a much lower overhead, allowing more direct control over the GPU. For developers, it means that they can squeeze better performance out of the hardware compared to higher-level APIs. With Metal, developers have a much more detailed view and control on the GPU which results in better graphical output and smoother performance.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/100-spirv.md b/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/100-spirv.md
index 67d5d21a7..6cd20c243 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/100-spirv.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/100-spirv.md
@@ -1 +1,3 @@
-# Spirv
\ No newline at end of file
+# SPIR-V
+
+`SPIR-V` is a binary intermediate language for graphics and computation kernels, which is defined by the Khronos Group. This programming language has been largely adopted and used by Vulkan, a low-overhead, cross-platform 3D graphics and computing API. Vulkan consumes `SPIR-V` directly, serving as the final shader stage before the GPU. The `SPIR-V` binary format is designed for portability and flexibility, allowing it to be a powerful tool for developers because of its extensibility through the addition of new instructions, without the need to rebuild toolchains or shaders. This makes `SPIR-V` an essential part of Vulkan, especially for game developers creating large, diverse worldscapes and intricate graphics.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/index.md b/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/index.md
index 6ebea85d0..c9f0499a9 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/index.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/105-vulkan/index.md
@@ -1 +1,3 @@
-# Vulkan
\ No newline at end of file
+# Vulkan
+
+Vulkan is a high-performance, cross-platform API for graphics and computation tasks published by the Khronos Group. Unlike other graphics APIs, Vulkan provides developers with direct control over the GPU and aims to take full advantage of multicore processors, enabling significant performance gains in 3D applications. It supports Windows, Linux, Android, iOS, and MacOS platforms. It's built from ground-up to ensure minimal overhead on the CPU side, providing a more balanced CPU/GPU usage, hence not limiting the game to a single core. Vulkan can be seen as the successor to OpenGL, as it offers lower-level functionality and more efficient multi-threading capabilities.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/106-graphics-api/index.md b/src/data/roadmaps/game-developer/content/106-graphics-api/index.md
index 158bb79f1..a2cdc8c35 100644
--- a/src/data/roadmaps/game-developer/content/106-graphics-api/index.md
+++ b/src/data/roadmaps/game-developer/content/106-graphics-api/index.md
@@ -1 +1,3 @@
-# Graphics api
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/100-decision-tree.md b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/100-decision-tree.md
index febdf00b6..8360df462 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/100-decision-tree.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/100-decision-tree.md
@@ -1 +1,3 @@
-# Decision tree
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/101-state-machine.md b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/101-state-machine.md
index 4393a623b..97ce82ba7 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/101-state-machine.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/101-state-machine.md
@@ -1 +1,3 @@
-# State machine
\ No newline at end of file
+# State Machine
+
+A **State Machine** is a conceptual model that is frequently used in game development to manage game states, or conditions. It consists of a number of different 'states', or modes, and the transitions between them. For instance, a mobile game could have states such as 'Start Screen', 'Playing', 'Paused' and 'Game Over'. Each one of these states will have specific commands associated and rules for transitioning to other states. This will govern the flow and behavior of the game. It can be used in AI character behaviors, UI systems, or game-level states. State Machines keep the code organised and manageable, making it easier for developers to implement complex game logic.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/102-behavior-tree.md b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/102-behavior-tree.md
index ddf43117d..f436f6de8 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/102-behavior-tree.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/102-behavior-tree.md
@@ -1 +1,3 @@
-# Behavior tree
\ No newline at end of file
+# Behavior Tree
+
+The **Behavior Tree** is a decision-making system used in game development, primarily for AI character behavior. These trees help define the actions an AI character will take, based on predefined tasks and conditions. The tree structure starts from a single root, branching out to nodes that represent these decisions or tasks. The tasks can be simple, such as moving from one point to another, or can be complex decisions like whether to attack or retreat. This kind of structure is advantageous because it is easy to add, remove, or modify tasks without breaking the tree or affecting other tasks. This makes it highly flexible and easy to manage, irrespective of the complexity of the tasks.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/103-fuzzy-logic.md b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/103-fuzzy-logic.md
index 513f710b8..2f5581b33 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/103-fuzzy-logic.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/103-fuzzy-logic.md
@@ -1 +1,3 @@
-# Fuzzy logic
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/104-markov-system.md b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/104-markov-system.md
index 9ee8d17f8..3e5ce17c7 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/104-markov-system.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/104-markov-system.md
@@ -1 +1,3 @@
-# Markov system
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/105-goal-oriented-behavior.md b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/105-goal-oriented-behavior.md
index a65a4c5af..0c30847cf 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/105-goal-oriented-behavior.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/105-goal-oriented-behavior.md
@@ -1 +1,3 @@
-# Goal oriented behavior
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/index.md b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/index.md
index 56d4fb8bd..854760a87 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/index.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/100-decision-making/index.md
@@ -1 +1,3 @@
-# Decision making
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/101-movement.md b/src/data/roadmaps/game-developer/content/107-game-api/101-movement.md
index c06920030..25a914ffe 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/101-movement.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/101-movement.md
@@ -1 +1,3 @@
-# Movement
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/100-minimax.md b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/100-minimax.md
index 041c05f2c..232e935e5 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/100-minimax.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/100-minimax.md
@@ -1 +1,3 @@
-# Minimax
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/101-ab-pruning.md b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/101-ab-pruning.md
index 3d656cf6e..8a4daa01f 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/101-ab-pruning.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/101-ab-pruning.md
@@ -1 +1,3 @@
-# Ab pruning
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/102-mcts.md b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/102-mcts.md
index c0c582e62..ea6cc80a9 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/102-mcts.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/102-mcts.md
@@ -1 +1,3 @@
-# Mcts
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/index.md b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/index.md
index 8ec4de3c5..e86eb0fd7 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/index.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/102-board-game/index.md
@@ -1 +1,3 @@
-# Board game
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/107-game-api/index.md b/src/data/roadmaps/game-developer/content/107-game-api/index.md
index 0dc27c45d..7b7597992 100644
--- a/src/data/roadmaps/game-developer/content/107-game-api/index.md
+++ b/src/data/roadmaps/game-developer/content/107-game-api/index.md
@@ -1 +1,3 @@
-# Game api
\ No newline at end of file
+# Game AI
+
+The term "API" stands for Application Programming Interface. In simple terms, a *Game API* is a set of protocols and tools used for building software and applications. It is, essentially, a method for different software applications to communicate with each other. In terms of game development, Game API provides a bridge to interact with the game engine, allowing developers to script in-game behaviors or functionalities, like graphics rendering, physics calculations, sound, and AI (Artificial Intelligence). Popular game APIs include DirectX and OpenGL. DirectX is used widely in the development of video games for Windows and Xbox. OpenGL, on the other hand, is a cross-platform API for rendering 2D and 3D graphics in video games.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/100-decision-learning.md b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/100-decision-learning.md
index ac2fff411..ed0072778 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/100-decision-learning.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/100-decision-learning.md
@@ -1 +1,3 @@
-# Decision learning
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/101-naive-bayes-classifier.md b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/101-naive-bayes-classifier.md
index 4a0dbe912..3723e550b 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/101-naive-bayes-classifier.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/101-naive-bayes-classifier.md
@@ -1 +1,3 @@
-# Naive bayes classifier
\ No newline at end of file
+# 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.
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/102-decision-tree-learning.md b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/102-decision-tree-learning.md
index 9dd9e79e0..a8ff937a3 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/102-decision-tree-learning.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/102-decision-tree-learning.md
@@ -1 +1,3 @@
-# Decision tree learning
\ No newline at end of file
+# Decision Tree Learning
+
+`Decision Tree Learning` is an important concept in game development, particularly in the development of artificial intelligence for game characters. It is a kind of machine learning method that is based on using decision tree models to predict or classify information. A decision tree is a flowchart-like model, where each internal node denotes a test on an attribute, each branch represents an outcome of that test, and each leaf node holds a class label (decision made after testing all attributes). By applying decision tree learning models, computer-controlled characters can make decisions based on different conditions or states. They play a key role in creating complex and interactive gameplay experiences, by enabling game characters to adapt to the player's actions and the ever-changing game environment.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/103-deep-learning.md b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/103-deep-learning.md
index 4afeca8e1..f8fed07ad 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/103-deep-learning.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/103-deep-learning.md
@@ -1 +1,3 @@
-# Deep learning
\ No newline at end of file
+# Deep Learning
+
+Deep Learning is a sub-field of machine learning, inspired by the structure and function of the human brain, specifically designed to process complex input/output transformations. It uses artificial neural networks with many layers (hence the term 'deep' learning) to model complex, non-linear hypotheses and discover hidden patterns within large datasets. Deep learning techniques are crucial in game development, primarily in creating intelligent behaviors and features in gaming agents, procedural content generation, and player profiling. You might have heard about the uses of deep learning technologies in popular, cutting-edge games like Google DeepMind's AlphaGo. Coding languages like Python, R, and frameworks like TensorFlow, Keras, and PyTorch are commonly used for deep learning tasks. Learning Deep Learning can be a prominent game-changer in your game development journey.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/104-artificial-neural-network.md b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/104-artificial-neural-network.md
index 0fa771de2..302814afd 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/104-artificial-neural-network.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/104-artificial-neural-network.md
@@ -1 +1,3 @@
-# Artificial neural network
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/105-reinforcements-learning.md b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/105-reinforcements-learning.md
index 61be13ff2..1756d84cc 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/105-reinforcements-learning.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/105-reinforcements-learning.md
@@ -1 +1,3 @@
-# Reinforcements learning
\ No newline at end of file
+# Reinforcements Learning
+
+`Reinforcement Learning` is a type of Machine Learning which is geared towards making decisions. It involves an agent that learns to behave in an environment, by performing certain actions and observing the results or rewards/results it gets. The main principle of reinforcement learning is to reward good behavior and penalize bad behavior. The agent learns from the consequences of its actions, rather than from being taught explicitly. In the context of game development, reinforcement learning could be used to develop an AI (Artificial Intelligence) which can improve its performance in a game based on reward-driven behavior. The AI gradually learns the optimal strategy, known as policy, to achieve the best result.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/index.md b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/index.md
index 5d05ca7b0..e096536f6 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/index.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/100-learning/index.md
@@ -1 +1,3 @@
-# Learning
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/108-game-api-2/index.md b/src/data/roadmaps/game-developer/content/108-game-api-2/index.md
index ff9137fe6..23b433aea 100644
--- a/src/data/roadmaps/game-developer/content/108-game-api-2/index.md
+++ b/src/data/roadmaps/game-developer/content/108-game-api-2/index.md
@@ -1 +1,3 @@
-# Game api 2
\ No newline at end of file
+# Game AI
+
+"Game API 2" refers to the next generation or updated version of a Game API (Application Programming Interface). With the functionalities provided by the game API, as a developer, you can utilize pre-written sets of codes to build games, instead of creating everything from scratch. The main focus of "Game API 2" often revolves around delivering improved functionalities, ease of use, and better performance, aiding in creating more complex and advanced games. Some examples may include access to new graphical features, optimized resource management, or better hardware utilization. Specific capabilities usually depend on the respective Game API you are using. However, it's important to note that "Game API 2" is a generalized term, and you may need to refer to specific APIs documentation (such as DirectX 12 for Microsoft, Vulkan for Khronos Group, etc.) for an in-depth understanding.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/100-directx-ray-tracing.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/100-directx-ray-tracing.md
index d5d55e5c2..12cefafc5 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/100-directx-ray-tracing.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/100-directx-ray-tracing.md
@@ -1 +1,3 @@
-# Directx ray tracing
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/101-vulcan-ray-tracing.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/101-vulcan-ray-tracing.md
index a471e1200..a15231d95 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/101-vulcan-ray-tracing.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/101-vulcan-ray-tracing.md
@@ -1 +1,3 @@
-# Vulcan ray tracing
\ No newline at end of file
+# Vulcan Ray Tracing
+
+`Vulkan Ray Tracing` is an extension of the Vulkan API (Application Programming Interface), which is an open-source, cross-platform API developed by the Khronos Group. Its main goal is to provide developers with greater control over the GPU, enabling better performance and more efficient multisystem and multicore use. The Vulkan Ray Tracing extension provides a standardized ray tracing interface similar to DirectX Raytracing, enabling real-time ray tracing applications to be built on Vulkan. This extension includes a number of functionalities such as acceleration structure building and management, ray tracing shader stages and pipelines, and indirect ray tracing dispatch.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/102-optix.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/102-optix.md
index f3654b485..fd1533c8f 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/102-optix.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/102-optix.md
@@ -1 +1,3 @@
-# Optix
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/index.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/index.md
index 4240f2833..3efe514d1 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/index.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/100-real-time-ray-tracing/index.md
@@ -1 +1,3 @@
-# Real time ray tracing
\ No newline at end of file
+# Real-Time Ray Tracing
+
+**Real-time Ray Tracing** is a notable advancement in rendering technology. It aims to mimic the way light works in the real world by simulating how each ray of light interacts with different surfaces. In real-time ray tracing, rays of light are generated from the viewer's perspective and sent into the scene. They can reflect off surfaces, refract through materials, or scatter in different directions. These rays can also be absorbed, producing shadows and shaping the visibility of objects. What makes real-time ray tracing special is its ability to calculate all these interactions in real-time, which allows graphics to be much more dynamic and interactive. The complexity of real-time ray tracing involves extensive computational power and it has been a groundbreaking feature in newer hardware and software releases.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/101-translucency-and-transparency.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/101-translucency-and-transparency.md
index 6a921e701..34adb03af 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/101-translucency-and-transparency.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/101-translucency-and-transparency.md
@@ -1 +1,3 @@
-# Translucency and transparency
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/102-metallicity.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/102-metallicity.md
index 1316bc033..dba5ddeb6 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/102-metallicity.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/102-metallicity.md
@@ -1 +1,3 @@
-# Metallicity
\ No newline at end of file
+# 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).
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/103-microsurface-scattering.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/103-microsurface-scattering.md
index 576f7b5de..5d44fd9c7 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/103-microsurface-scattering.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/103-microsurface-scattering.md
@@ -1 +1,3 @@
-# Microsurface scattering
\ No newline at end of file
+# Microsurface Scattering
+
+Microsurface scattering, also known as sub-surface scattering, is an important phenomenon in Physically Based Rendering (PBR). This process involves the penetration of light into the surface of a material, where it is scattered by interacting with the material. In other words, when light strikes an object, rather than simply bouncing off the surface, some of it goes into the object and gets scattered around inside before getting re-emitted. It is key to achieving more realistic rendering of translucent materials like skin, marble, milk, and more. Consider it essential for replicating how light interacts with real-world materials in a convincing manner in your game.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/index.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/index.md
index f86d98a63..7af90c82b 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/index.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/101-physically-based-rendering/index.md
@@ -1 +1,3 @@
-# Physically based rendering
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/content/109-advanced-rendering/index.md b/src/data/roadmaps/game-developer/content/109-advanced-rendering/index.md
index f7c7ee437..e7050a942 100644
--- a/src/data/roadmaps/game-developer/content/109-advanced-rendering/index.md
+++ b/src/data/roadmaps/game-developer/content/109-advanced-rendering/index.md
@@ -1 +1,3 @@
-# Advanced rendering
\ No newline at end of file
+# 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.
\ No newline at end of file
diff --git a/src/data/roadmaps/game-developer/game-developer.json b/src/data/roadmaps/game-developer/game-developer.json
index 15ecbfa8d..d18ac9892 100644
--- a/src/data/roadmaps/game-developer/game-developer.json
+++ b/src/data/roadmaps/game-developer/game-developer.json
@@ -2607,7 +2607,7 @@
           "x": "1068",
           "y": "387",
           "properties": {
-            "controlName": "100-react-roadmap-note"
+            "controlName": "100-game-developer-roadmap-note"
           },
           "children": {
             "controls": {
diff --git a/src/data/roadmaps/game-developer/game-developer.md b/src/data/roadmaps/game-developer/game-developer.md
index 3091ec8f0..82787d6f7 100644
--- a/src/data/roadmaps/game-developer/game-developer.md
+++ b/src/data/roadmaps/game-developer/game-developer.md
@@ -6,6 +6,7 @@ briefDescription: 'Roadmap to becoming a Game Developer in 2023'
 title: 'Game Developer'
 description: 'Roadmap to becoming a Game Developer in 2023'
 hasTopics: true
+isNew: true
 dimensions:
   width: 968
   height: 2104.59