Updated readme

Author: Habrador

_text/10-bytecode.md

@@ -8,9 +8,13 @@ The programmers with no skillz write their code in a .txt-file. You read that fi
 
 **When is it useful?**
 
-- If you want to add modding support.
+- To add modding support.
 
-- If you don't want to hard-code behaviour.
+- To avoid hard-coded behaviour.
+
+- To handle cutscenes and dialogue systems. Scripted sequences or dialogue interactions can be expressed in bytecode, allowing for easier management and execution of these sequences during gameplay.
+
+- To manage and execute the conditions and actions required to unlock achievements or track player progress.
 
 
 ## [Back](../) 

_text/15-service-locator.md

@@ -1,6 +1,6 @@
 # 15. Service Locator
 
-When making your game you use many standardized methods to for example generate random numbers. These are called services and should be accessible from everywhere (globally) but still be independet from your game's main code.   
+When making your game you use many standardized methods to for example generate random numbers. These are called services and should be accessible from everywhere (globally) but still be independet from your game's main code. The pattern allows services to be easily replaced or extended without affecting the existing code that relies on them.    
 
 **How to implement?**
 
@@ -16,6 +16,14 @@ Unity has implemented this pattern in the form of the GetComponent() method.
 
 - In the game you may have different audio objects depending on if the game is running on a console or PC. This is the same example as in the book so you can find the code for it in the code section.  
 
+- To inject dependencies into game objects or systems - aka dependency injection. Instead of hardcoding the references to specific services, game objects can use the service locator to request and retrieve the required services at runtime.
+
+- To obtain the input service, abstracting away the underlying input device handling.
+
+- Objects or systems that need to display localized text can use the service locator to retrieve the appropriate localization service.
+
+- Objects that need AI functionality can use the service locator to access AI-related services, such as pathfinding or decision-making algorithms.
+
 **Related patterns** 
 
 - **Singleton.** Both provide a global access to an object. So the problems with the Singleton also applies to this pattern.  

_text/17-dirty-flag.md

@@ -1,6 +1,6 @@
 # 17. Dirty Flag
 
-This pattern is useful if something has changed in your game and if so you have to run a costly operation. A Dirty Flag is used to tell that something has changed but the costly operation hasn't been activated yet. You can often postpone the costly operation until the result is actually needed.   
+This pattern is useful if something has changed in your game and if so you have to run a costly operation. A Dirty Flag is used to tell that something has changed but the costly operation hasn't been activated yet. You can often postpone the costly operation until the result is actually needed. So this pattern allows games to avoid unnecessary computations, updates, and data processing.   
 
 **How to implement?**
 
@@ -16,5 +16,9 @@ The dirty flag is just a bool.
 
 - I used this pattern when experimenting with Genetic Algorithms (GA) and the Traveling Salesman Problem (TSP) where you find the shortest path between multiple cities. The GA generates multiple solutions, like 100, to the TSP and then each iteration you evolve 100 better solutions by calculating a cost function, which is the distance between all cities. You can use "tournament selection" to find good solutions from the previous iteration to the next, which is basically picking 3 solutions and returns the solution with the shortest distance between all cities. I realized I didn't have to calculate the cost fuction 100 times each iteration because it's a costly operation. To optimize I only calculate the cost function of the cities being picked by the tournament selection. I kept track of which solution has had its cost fuction calculated by using a bool which is set to false each iteration and then to true if the cost function has been run.  
 
+- In multiplayer games, the Dirty Flag Pattern can be used to track changes in game state for network synchronization. Only data that has been marked as "dirty" needs to be sent across the network, reducing bandwidth usage and improving network performance.
+
+- Can be used to track changes in the game environment or AI state. The AI system can then prioritize updates and decision-making for objects or AI agents with "dirty" data.
+
 
 ## [Back](../)

_text/19-spatial-partition.md

@@ -21,9 +21,13 @@ If the objects move you have to update the data structure. These data stuctures
 
 **When is it useful?**
 
-- Find the closest object to a character. This can be a really slow process if you have hundreds of objects around the character. And if you have soldiers fighting soldiers, you have to make that seach for each soldier. A better way is to divide the search-area so you don't have to search thorough all objects - just the ones closest to you.
+- Find the closest object to a character. This can be a really slow process if you have hundreds of objects around the character. And if you have soldiers fighting soldiers, you have to make that search for each soldier. A better way is to divide the search-area so you don't have to search thorough all objects - just the ones closest to you.
 
 - To increase the performance of collision detection and raytracing.
 
+- To deactivate objects if they are far away from your character to improve performance. This is called culling. You can hide for example trees and AI far away don't have to update themselves.   
+
+- In games with pathfinding, spatial partitioning can help optimize the search for valid paths. By organizing the game world into a navigation grid or spatial data structure, pathfinding algorithms can be restricted to search only within relevant partitions, reducing computation time.
+
 
 ## [Back](../)

_text/20-decorator.md

@@ -1,6 +1,6 @@
 # 20. Decorator
 
-You have a class you want to add some behaviors to in a flexible way without modifying the original class.  
+You have a class you want to add some behaviors to in a flexible to an object way without modifying the original class. Other objects of the same class are uneffected, so it is used to dynamically extend the functionality of objects at runtime. Overall, the Decorator Pattern is a versatile and flexible design pattern that enables game developers to enhance and customize game objects or systems without modifying their core implementation.   
 
 **How to implement?**
 
@@ -12,6 +12,12 @@ You have a class and now you create several "decorator" classes that modifies so
 
 - If you ever played Pubg you know you have weapons to which you can attach various attachments you find while playing the game. You can find magazines, sights, silenzers, etc, modifying the weapon's properties. You can use the Decorator pattern to implement this in your game.   
 
+- To implement power-ups that temporarily modify the behavior of game objects. Each power-up can be represented as a decorator that wraps around the original object, adding specific enhancements, such as increased speed, damage boost, or invincibility.
+
+- To add special effects or animations to UI buttons, panels, or icons.
+
+- To dynamically adjust the difficulty level of a game. Decorators can be added or removed based on player performance or preferences, altering the game's challenges accordingly.
+
 **Related patterns**
 
 - **Subclass Sandbox.** You may end up with many child-classes. To easier handle the code, you can define high-level methods in the parent.

_text/21-factory.md

@@ -16,6 +16,8 @@ If you are creating several different factories, then they should inherit from s
 
 - To keep track of all of your Singletons. 
 
+- The Factory Pattern can be used to create game objects, such as characters, enemies, items, obstacles, terrain features, structures, power-ups, collectibles, buttons, particles, etc.
+
 **Related patterns**
 
 - **Prototype.** The Prototype pattern is generally used if you want to make a copy of an existing object, while the Factory pattern is generating new objects. But some argue you can put the Prototype pattern inside of the Factory pattern.

_text/6-state.md

@@ -20,6 +20,8 @@ You could use an enum that keeps track of each state and then a switch statement
 
 - The game itself can be a number of states: intro video, main menu, main game, mini game, etc. 
 
+- Can be used to manage interactions between different game objects. For example, a door object can have states like open, closed, locked, and unlocked, and its behavior changes depending on its current state.
+
 **Related patterns**
 
 - **Type Object.** In both cases you have a main object and then you add another object to define something. The difference is that in State you switch the other object, while in Type Object that object remains the same. So if the object in Type Object can be switched you get the State pattern.