Command Mode
***Encapsulate commands and decouple them from target behavior, so that commands change from process concepts to object data
Since the command becomes data, it can be passed, stored, and reused.
Command Pattern is a behavioral design pattern that encapsulates a request into an object, allowing users to parameterize other objects using different requests, queues, or log requests. Command mode also supports revocable operations
*** Application scenarios
- If you need to parameterize the object through operations, you can use command mode.
- If you want to put an operation into a queue, execute an operation, or execute an operation remotely, you can use command mode.
- If you want to implement the operation rollback function, you can use command mode.
***Implementation method
- Command: Define the interface of the command and declare the method to perform operations.
- ConcreteCommand: The implementation object of the Command interface, which corresponds to the specific behavior and the binding of the receiver.
- Client: Create a specific command object and set its receiver.
- Invoker: Require the command object to execute the request.
- Receiver: Know how to implement operations related to performing a request.
***advantage
- Control the order of request processing: You can control the order in which requests are processed.
- Single responsibility principle: You can decouple the classes that initiate and execute operations.
- Opening and closing principle: You can add new processors to the program without changing existing code
Encapsulate a request into an object, allowing the client to be parameterized using different requests or queues or logs, while supporting the revocation and recovery of request operations.
The command is an objectized (instified) method call, a method call encapsulated in an object
It can be understood that commands are object-oriented callbacks
// The Avatar class inherits from MonoBehaviour, which is an operator class that handles the movement of objects.
public class Avatar : MonoBehaviour {
private Transform mTransform;
void Start () {
mTransform = transform;
}
public void Move(Vector3 DeltaV3)
{
// Use Translate method of Transform to achieve displacement.
(DeltaV3);
}
}
// The Command class is an abstract base class that defines the interface to the command.
public abstract class Command {
protected float _TheTime; // The timestamp corresponding to the command.
public float TheTime
{
get { return _TheTime; }
}
public virtual void execute(Avatar avatar) { }
public virtual void undo(Avatar avatar) { }
}
// CommandMove class inherits from Command class, implementing specific move commands
public class CommandMove : Command {
private Vector3 TransPos;
// Constructor, receives the moving position and the time when the command is executed.
public CommandMove(Vector3 transPos, float time)
{
TransPos = transPos; // Initialize the moving target position.
_TheTime = time; // Initialization time.
}
// Implement the method of executing commands.
public override void execute(Avatar avatar)
{
// Call Avatar's Move method to achieve movement.
(TransPos);
}
// Implement the method of revoking the command.
public override void undo(Avatar avatar)
{
// Call Avatar's Move method and use the opposite vector to undo the movement.
(-TransPos);
}
}
// The CommandManager class is responsible for managing and calling commands
public class CommandManager: MonoBehaviour
{
public Avatar TheAvatar; // Reference to the Avatar object.
private Stack<Command> mCommandStack; // Stack used to store commands.
private float mCallBackTime; // Record the accumulated time of command execution.
public bool IsRun = true; // Flag variable to determine whether to run a command or undo the operation.
void Start()
{
// Initialize the command stack and time.
mCommandStack = new Stack<Command>();
mCallBackTime = 0;
}
void Update()
{
// Select Execute the command or run undo according to the IsRun variable.
if (IsRun)
{
Control(); // Execute command control.
}
else
{
RunCallBack(); // Perform the undo operation.
}
}
private void Control()
{
// Increase command execution time.
mCallBackTime += ;
// Get the currently entered command object.
Command cmd = InputHandler();
// If the command object is not null, push on the stack and execute it.
if (cmd != null)
{
(cmd);
(TheAvatar);
}
}
private void RunCallBack()
{
// Reduce the current time.
mCallBackTime -= ;
// If a command exists in the stack and the current time is less than the time of the command on the top of the stack, perform the undo operation.
if ( > 0 && mCallBackTime < ().TheTime)
{
// Pop up and undo the top command.
().undo(TheAvatar);
}
}
private Command InputHandler()
{
// Generate a move command based on the input.
if (())
{
return new CommandMove(new Vector3(0, , 0), mCallBackTime);
}
if (())
{
return new CommandMove(new Vector3(0, -, 0), mCallBackTime);
}
if (())
{
return new CommandMove(new Vector3(-, 0, 0), mCallBackTime);
}
if (())
{
return new CommandMove(new Vector3(, 0, 0), mCallBackTime);
}
return null; // If no key is detected, return null.
}
}Enjoy the Yuan mode
*** Different instances share the same characteristics (commonities) while retaining their own characteristics parts
- ***The information transmitted is diversified, which can save calculation time
- ***The stored information can save space
- ***So the Enjoy Yuan mode can reduce the cost of time and space
Flyweight Pattern is a structural design pattern designed to minimize memory usage by sharing objects. It effectively saves memory by separating reused objects into shared and non-shared parts. The core idea of the Encyclopedia mode is to share objects with the same internal state to reduce memory usage
*** Application scenarios
- When there are a large number of similar or identical objects in the system.
- Object creation and destruction cost is high.
- The state of an object can be externalized, that is, part of the state of an object can exist independently of the object itself.
- When it is necessary to create a large number of similar objects and share public information, it is also suitable for systems that need to consider performance optimization and shared control.
***Implementation method
- Flyweight Factory: Responsible for creating and managing the genre objects, usually including a pool (cache) for storing and reusing the already created genre objects.
- Concrete Flyweight: Implements the abstract element-savvy interface, including internal and external states. The internal state can be shared, while the external state is passed by the client.
- Abstract Flyweight: Defines the interfaces of specific and non-shared and enjoyment, and usually includes methods to set external states.
- Client: Use the Xiangyuan factory to obtain the Xiangyuan object and operate the Xiangyuan object by setting the external state. Clients usually do not need to care about the specific implementation of the Encyclopedia object.
***advantage
- Reduce memory consumption: By sharing objects, the number of objects in memory is reduced.
- Improve efficiency: Reduces the time for object creation and improves system efficiency.
***shortcoming
- Increase system complexity: It is necessary to separate internal and external states, which increases the complexity of design and implementation.
- Thread safety issues: If external state is handled improperly, it may cause thread safety issues
The Encyclopedia pattern solves the problem by dividing object data into two types.
- The first type of data is data that does not belong to a single instance object and can be shared by all objects, such as the geometry and texture data of trees, etc.
- The other data is the external state, and they are unique for each instance. For example, the position, scale and color of each tree
//Random size position rendering
internal class SpecificAttributes
{
public Matrix4x4 TransMatrix;//Conversion matrix
internal Vector3 mPos;
internal Vector3 mScale;
internal Quaternion mRot;
public SpecificAttributes()
{
mPos = * 10;
mRot = ();
mScale = * (1, 3);
TransMatrix = (mPos, mRot, mScale);//Create a transformation matrix based on position, rotation and scaling
}
}
//Objects used to instantiate tests
public class CubeBase: MonoBehaviour
{
private MeshRenderer mMR;
private MeshFilter mMF;
public Mesh mSharedMesh;
public Material mSharedMaterial;
private Matrix4x4[] TransInfos;
private void Start()
{
Init();
}
//Initialize components and share materials and mesh
public void Init()
{
mMR = GetComponent<MeshRenderer>();
mMF = GetComponent<MeshFilter>();
if (mMR == null)
{
("MeshRenderer component is missing on the GameObject.");
return;
}
if (mMF == null)
{
("MeshFilter component is missing on the GameObject.");
return;
}
mSharedMaterial = ;
mSharedMesh = ;
if (mSharedMesh == null)
{
("The shared mesh in the MeshFilter is null. Ensure a valid mesh is assigned.");
}
}
//Use method to draw instantiated mesh
internal void ObjInstancing(int num)
{
if (mSharedMesh == null)
{
("Cannot draw instances because the shared mesh is null.");
return;
}
TransInfos = new Matrix4x4[num];
for (int i = 0; i < num; i++)
{
SpecificAttributes sa = new SpecificAttributes();
TransInfos[i] = ;
}
(mSharedMesh, 0, mSharedMaterial, TransInfos);
}
}
//Xienyuan mode control class
using;
using UnityEngine;
using;
public class FlyweightManager: MonoBehaviour
{
public GameObject TheObj;
public bool IsFlyweight=true;
private Text StatusText;
private List<Transform> ObjTrs;
void Start()
{
ObjTrs = new List<Transform>();
StatusText=("StatusText").GetComponent<Text>();
= IsFlyweight? "Disable Enjoy Yuan Mode": "Enable Enjoy Yuan Mode";
}
void Update()
{
if (IsFlyweight)
{
GenerateObjsWithInstancing(1000);
}
else
{
GenerateObjsWithoutInstancing(1000);
}
}
public void SwitchFlyweight()
{
IsFlyweight = !IsFlyweight;
= IsFlyweight? "Disable Enjoy Yuan Mode": "Enable Enjoy Yuan Mode";
}
//Use the ObjInstancing method of the CubeBase script to generate a specified number of instantiated objects
public void GenerateObjsWithInstancing(int num)
{
// traverse the ObjTrs list and destroy all existing game objects
for (int i = 0; i < ; i++)
{
Destroy(ObjTrs[i].gameObject);
}
// Clear the ObjTrs list and remove all references
();
// Call the ObjInstancing method of the CubeBase script to generate a specified number of instantiated objects
<CubeBase>().ObjInstancing(num);
}
//Create a non-institized object
public void GenerateObjsWithoutInstancing(int num)
{
// traverse the ObjTrs list and destroy all existing game objects
for (int i = 0; i < ; i++)
{
Destroy(ObjTrs[i].gameObject);
}
// Clear the ObjTrs list and remove all references
();
// Loop to create a specified number of new game objects
for (int i = 0; i < num; i++)
{
// Create a SpecificAttributes instance to store properties of a new object
SpecificAttributes sa = new SpecificAttributes();
// Create a copy of TheObj using the Instantiate method and set its position and rotation
Transform tr = Instantiate(TheObj, , ).transform;
// Set the material color of the new object to white
<MeshRenderer>(). = ;
// Set local scaling of new objects
= ;
// Add the Transform of the newly created object to the ObjTrs list
(tr);
}
}
}Consider this requirement:
There are ten thousand enemies at the same time in the game
Not considering rendering pressure for the time being, simply designing an implementation of enemy attributes
The enemy's attributes include
- Blood volume
- height
- There are four types of ranks: recruit, sergeant, sergeant, and captain
- The upper limit of health (varies according to the rank, 100, 200, 500, 1000)
- Movement speed (varies according to the level, 1.0f, 2.0f, 3.0f, 4.0f)
- The corresponding name of the rank (varies according to the rank, namely the recruit, the sergeant, the sergeant, the captain)
The original way is to declare an Attr class, which containshp,hpMax,mp,mpMax,name
The problem is memory waste, and each attribute object is opened at the same time.hp,hpMax,mp,mpMax,nameMemory space
You can make a rank into an enumeration, and define a dictionary for the corresponding attributes of the rank.
public enum AttrType : uint
{
// New recruits
Recruit,
// Sgt.
StaffSergeant,
// Sgt.
Sergeant,
// Captain
Captian,
}
public static readonly Dictionary<AttrType, Dictionary<string, float>> BaseAttrDict = new Dictionary<AttrType, Dictionary<string, float>>
{
{ , new Dictionary<string, float>
{
{"MaxHp",100.0f},
{"MoveSpeed",1.0f},
}},
{ , new Dictionary<string, float>
{
{"MaxHp",200.0f},
{"MoveSpeed",2.0f},
}},
{ , new Dictionary<string, float>
{
{"MaxHp",500.0f},
{"MoveSpeed",3.0f},
}}, { , new Dictionary<string, float>
{
{"MaxHp",1000.0f},
{"MoveSpeed",4.0f},
}},
};
public float GetMapHp()
{
return [baseAttrType]["MaxHp"];
}
public float GetMoveSpeed()
{
return [baseAttrType]["MoveSpeed"];
}But there is one requirement that requires access to the Chinese name corresponding to the rank. In order to achieve the requirement, the value of the dictionary cannot befloat, but should beobject
public static readonly Dictionary<AttrType, Dictionary<string, object>> BaseAttrDict = new Dictionary<AttrType, Dictionary<string, object>>
{
{ , new Dictionary<string, object>
{
{"MaxHp",100},
{"MoveSpeed",1.0f},
{"Name","New Soldier"}
}},
{ , new Dictionary<string, object>
{
{"MaxHp",200},
{"MoveSpeed",2.0f},
{"Name","Sergeant"}
}},
{ , new Dictionary<string, object>
{
{"MaxHp",500},
{"MoveSpeed",3.0f},
{"Name","Sergeant"}
}}, { , new Dictionary<string, object>
{
{"MaxHp",1000},
{"MoveSpeed",4.0f},
{"Name","Captain"}
}},
};
public string GetName()
{
return (string)[baseAttrType]["Name"];
}
public int GetMapHp()
{
return (int)[baseAttrType]["MaxHp"];
}
public float GetMoveSpeed()
{
return (float)[baseAttrType]["MoveSpeed"];
}There is a fatal problem with this writing: the performance consumption caused by unboxing (if you can set the value)
Save various types of variables in a dictionary and are forced to use themobject, but when using it again, you have toobjectUnboxing into the corresponding actual type, this configuration dictionary scheme will only be used if these properties are not frequently called.
Using the Encyclopedia mode, first find the "shareable" attributes on the design. In this example, it is:maxHp，moveSpeed，name, put shared attributes together
public class FlyweightAttr
{
public int maxHp { get; set; }
public float moveSpeed { get; set; }
public string name { get; set; }
public FlyweightAttr(string name, int maxHp, float moveSpeed)
{
= name;
= maxHp;
= moveSpeed;
}
}
Soldier's attribute classSoldierAttrholdFlyweightAttrThis reference and contains non-shared properties:hpandheight
public class SoldierAttr
{
public int hp { get; set; }
public float height { get; set; }
public FlyweightAttr flyweightAttr { get; }
public SoldierAttr(FlyweightAttr flyweightAttr, int hp, float height)
{
= flyweightAttr;
= hp;
= height;
}
public int GetMaxHp()
{
return ;
}
public float GetMoveSpeed()
{
return ;
}
public string GetName()
{
return ;
}
}
Add another factory class to make it easy for external attributes to obtain
public class AttrFactory
{
/// <summary>
/// Attribute type enumeration
/// </summary>
public enum AttrType : uint
{
// New recruits
Recruit = 0,
// Sgt.
StaffSergeant,
// Sgt.
Sergeant,
// Captain
Captian,
}
// Basic attribute cache
private Dictionary<AttrType, FlyweightAttr> _flyweightAttrDB = null;
public AttrFactory()
{
_flyweightAttrDB = new Dictionary<AttrType, FlyweightAttr>();
_flyweightAttrDB.Add(, new FlyweightAttr("Soldier", 100, 1.0f));
_flyweightAttrDB.Add(, new FlyweightAttr("Sergeant", 200, 2.0f));
_flyweightAttrDB.Add(, new FlyweightAttr("Sergeant", 500, 3.0f));
_flyweightAttrDB.Add(, new FlyweightAttr("Captain", 1000, 4.0f));
}
// Create role properties
public SoldierAttr CreateSoldierAttr(AttrType type, int hp, float height)
{
if (!_flyweightAttrDB.ContainsKey(type))
{
("{0} attribute does not exist", type);
return null;
}
FlyweightAttr flyweightAttr = _flyweightAttrDB[type];
SoldierAttr attr = new SoldierAttr(flyweightAttr, hp, height);
return attr;
}
}
static void Main(string[] args){
//Test code
AttrFactory factory = new AttrFactory();
for (int i = 0; i < _enemy_max; i++)
{
var values = (typeof());
attrType = ()((0, 3));
SoldierAttr soldierAttr = (attrType, (0, 100), (155.0f, 190.0f));
(soldierAttr);
}
}You can use the original attribute class to compare performance
public class HeavySoldierAttr : MonoBehaviour
{
public int hp { get; set; }
public float height { get; set; }
public int maxHp { get; set; }
public float moveSpeed { get; set; }
public string name { get; set; }
public HeavySoldierAttr(int hp, float height, int maxHp, float moveSpeed, string name)
{
= hp;
= height;
= maxHp;
= moveSpeed;
= name;
}
}
Observer mode
***Observer Pattern is a behavioral design pattern that defines a one-to-many dependency between objects, so that when an object changes its state, all objects that depend on it will be notified and automatically updated. This mode is also called the publish-subscribe mode
*** Application scenarios
- When the change of one object requires changing other objects at the same time.
- When it is necessary to keep synchronization between different objects.
- When an object must be automatically updated when another object's state changes.
***Implementation method
- Subject: Also known as "observed", it maintains a group of observers, provides interfaces for registering and deregistering observers, and notifies them when states change.
- Observer: Provides an update interface for notification when the subject state changes.
- Concrete Subject: Implement the subject interface and send a notification to the observer when its state changes.
- Concrete Observer: Implement the observer interface and perform actions related to changes in the subject state.
***advantage
- Implement loose coupling between objects: The coupling degree between the subject and the observer is low, and the subject does not need to know the observer's specific implementation.
- Support broadcast communication: The subject can broadcast notifications to all registered observers without knowing the specific number and type of observers.
- Flexibility and scalability: Observers can be added or deleted dynamically without modifying the subject's code.
***shortcoming
- May cause performance issues: Notifying all observers may result in performance degradation if the observer list is long.
- May lead to cyclic dependencies: If there is a circular dependency between the observer and the subject, it may lead to complex state update issues
C# integrates it at the language level,eventKeywords
Suppose there is a game scene where a character needs to notify other objects when the health volume changes. This scenario can be implemented using the observer mode, allowing other objects to be notified and processed accordingly when the character's health changes.
// Define observable role object interface
public interface ICharacterObservable
{
//Add an observer
void AddObserver(ICharacterObserver observer);
//Remove the observer
void RemoveObserver(ICharacterObserver observer);
// Notify all observers
void NotifyObservers();
}
// Define the observer object interface
public interface ICharacterObserver
{
// How to deal with changes in character health
void OnCharacterHealthChanged(int newHealth);
}
// Specific role classes to implement ICharacterObservable interface
public class GameCharacter: ICharacterObservable
{
//Storage the observer object that implements the ICharacterObserver interface. This collection is used to manage all observers interested in the role object so that they are notified when the role state changes.
private List<ICharacterObserver> observers = new List<ICharacterObserver>();
private int health;
// Character's health attribute
public int Health
{
get { return health; }
set
{
health = value;
NotifyObservers(); // Notify all observers when the blood volume changes
}
}
// Add observer
public void AddObserver(ICharacterObserver observer)
{
(observer);
}
// Remove observer
public void RemoveObserver(ICharacterObserver observer)
{
(observer);
}
// Notify all observers
public void NotifyObservers()
{
foreach (var observer in observers)
{
(health); // Notify observers to deal with character health changes
}
}
}
// Specific observer class, implementing the ICharacterObserver interface
public class EnemyAI: ICharacterObserver
{
// How to deal with changes in character health
public void OnCharacterHealthChanged(int newHealth)
{
if (newHealth <= 0)
{
// Processing logic when a character dies
("Enemy AI: Character is dead, stop attacking!");
}
else
{
// Processing logic when character health changes
("Enemy AI: Character health changed to " + newHealth);
}
}
}
// Use example
GameCharacter player = new GameCharacter();
EnemyAI enemyAI = new EnemyAI();
(enemyAI); // Add monster AI to the character object as an observer
= 10; // Trigger notification, output "Enemy AI: Character health changed to 10"
= 0; // Trigger notification, output "Enemy AI: Character is dead, stop attacking!"Dynamic memory allocation can be a problem, you can use chain list observers, you can add or delete observers without dynamically allocating memory
To implement the entire interface in order to receive a notification does not conform to the current programming aesthetics. A more modern approach is that for each "observer", it only has one reference method or reference function
C#eventIt turns the observer into an agent
using System;
public class GameCharacter
{
// Define an event, the type of event is EventHandler<int>
public event EventHandler<int> HealthChanged;
private int health;
public int Health
{
get { return health; }
set
{
health = value;
OnHealthChanged(health); // Call event trigger method in setter
}
}
// Method to trigger events
protected virtual void OnHealthChanged(int newHealth)
{
// Call the event through the event trigger, passing the current object and the new health value
HealthChanged?.Invoke(this, newHealth);
}
}
public class EnemyAI
{
// Subscribe to the HealthChanged event of GameCharacter object
public void Subscribe(GameCharacter character)
{
+= CharacterHealthChanged;
}
// Event handling method
public void CharacterHealthChanged(object sender, int newHealth)
{
("Enemy AI: Character health changed to " + newHealth);
}
}
// Use example
GameCharacter player = new GameCharacter();
EnemyAI enemyAI = new EnemyAI();
(player); // Subscribe to events
= 10; // Output "Enemy AI: Character health changed to 10"Unity example:
//The specific topic of the trigger event
public class Emitter : MonoBehaviour
{
public GameObject Ball;
void Start()
{
//First time wait 1 second for to the EmitBall method, then call at random intervals of 0.5-1.5 seconds
InvokeRepeating("EmitBall", 1f, (0.5f, 1.5f));
}
void EmitBall()
{
GameObject go = Instantiate(Ball);
<Rigidbody>().velocity = * 2f;
if ( != null)//if is not null
{
();
}
}
}
// Provides a global event distribution mechanism
public class Radio : MonoBehaviour
{
public delegate void EmitHandler(Transform target);// Define a delegate type for the event
public EmitHandler OnEmitEvent;// Create a new event with the delegate type
public static Radio Instance;
void Awake()
{
Instance = this;
}
}
//Observer
public class Shooter : MonoBehaviour
{
public GameObject Bullet;
private void Start()
{
AddObserver();
}
private void AddObserver()
{
+= Shoot;//subscribe to the event
}
private void Shoot(Transform target)
{
GameObject go = Instantiate(Bullet, , );
<Rigidbody>().velocity = ( - ).normalized * 30f;
}
}Title: Note
Be sure to delete the invalid observer in time, and the corresponding observer object that is invalidated by the observer.
Observer mode is very suitable for communication problems between some unrelated modules. It is not suitable for communication within a single compact modulePrototype mode
*** Use one or more objects as prototypes, and clone many prototype-like objects through a unified generator. At the same time, you can change the clone properties through the configuration table to create many objects with their own personality.
Prototype Pattern is a creative design pattern that creates new instances by copying existing instances, rather than creating them. This pattern is suitable for creating complex objects, especially when the creation cost is high. Prototype mode allows the system to dynamically increase or decrease the number of objects at runtime
*** Application scenarios
- When the object that needs to be created is complex and is expensive to create.
- When the system should be independent of the creation, composition and representation of its products.
- When it is necessary to specify the creation of objects by specifying existing objects, and to create new objects by copying them.
***Implementation method
- Prototype: Define an interface or abstract class for creating cloning, usually including a cloning method.
- Concrete Prototype: Implement the prototype interface and provide specific implementation of cloning itself.
- Client: Use the prototype interface to create a new object instance.
***advantage
- Reduce creation costs: Create new objects by copying existing objects, which can reduce the cost of creating complex objects.
- Increase flexibility: The number of objects can be dynamically increased or decreased at runtime.
- Supports multiple replication methods: Deep or shallow replication can be achieved, depending on the requirements.
***shortcoming
- Implement complexity: Implementing prototype patterns may require writing additional cloned code, especially for complex objects.
- Deep and shallow copy: Deep and shallow replication need to be clearly distinguished to avoid potential problems
For example, setting up three types of monsters, and generating them requires three types of monster generator classes. This design is too redundant.
Prototype mode provides a solution. Its core idea is that an object can generate other objects similar to itself. If you have a ghost, you can make more ghosts through this ghost. If you have a devil, you can make other devils. Any monster can be regarded as a prototype, and you can use this prototype to copy more different versions of monsters.
Design a base class firstMonster, There is an abstract methodclone,Each subclass provides a specific implementation that returns an object with the same type and state as its own
Once allMonsterAll classes implement these interfaces, so you no longer need to use each oneMonsterClass defines aSpawnerClass, just define one class
*Monster Spawner
using UnityEngine;
namespace
{
public class SpawnController : MonoBehaviour
{
// Each type of monster has a corresponding prototype
private Ghost ghostPrototype;
private Demon demonPrototype;
private Sorcerer sorcererPrototype;
// The monsterSpawners array saves all available Spawner instances
private Spawner[] monsterSpawners;
private void Start()
{
// Initialize the prototype of each monster type.
ghostPrototype = new Ghost(15, 3);
demonPrototype = new Demon(11, 7);
sorcererPrototype = new Sorcerer(4, 11);
// Initialize the Spawner array to provide a Spawner monsterSpawners = new Spawner[] {
new(ghostPrototype),
new(demonPrototype),
new(sorcererPrototype),
};
}
private void Update()
{
if (())
{
var ghostSpawner = new Spawner(ghostPrototype);
var newGhost = () as Ghost;
// Call the Talk method of the new ghost and output a message to the console
();
// Randomly select a Spawner to generate a random type of monster
Spawner randomSpawner = monsterSpawners[(0, )];
_Monster randomMonster = ();
// Call the Talk method of the newly generated random monster.
();
}
}
}
}
namespace
{
// Use Prototyping Pattern to allow new object instances to be generated from a prototype object
public class Spawner
{
private _Monster prototype; // Save the prototype monster to be cloned
// The constructor takes a prototype monster as a parameter and saves it.
public Spawner(_Monster prototype)
{
= prototype;
}
// The SpawnMonster method returns a clone of the prototype monster.
public _Monster SpawnMonster()
{
return ();
}
}
}
namespace
{
public abstract class _Monster
{
// The Clone method implements the prototype design pattern, and the derived class should override this method to return its own clone.
public abstract _Monster Clone();
// The Talk method is an abstract method, and the derived class should implement different dialogue content according to its own characteristics.
public abstract void Talk();
}
}
using UnityEngine;
namespace
{
public class Sorcerer : _Monster
{
private int health;
private int speed;
private static int sorcererCounter = 0;
public Sorcerer(int health, int speed)
{
= health;
= speed;
sorcererCounter += 1;
}
public override _Monster Clone()
{
return new Sorcerer(health, speed);
}
public override void Talk()
{
($"Hello this is Sorcerer number {sorcererCounter}. My health is {health} and my speed is {speed}");
}
}
}
using UnityEngine;
namespace
{
public class Ghost : _Monster
{
private int health;
private int speed;
private static int ghostCounter = 0;
public Ghost(int health, int speed)
{
= health;
= speed;
ghostCounter += 1;
}
public override _Monster Clone()
{
return new Ghost(health, speed);
}
public override void Talk()
{
($"Hello this is Ghost number {ghostCounter}. My health is {health} and my speed is {speed}");
}
}
}
using UnityEngine;
namespace
{
public class Demon: _Monster
{
private int health;
private int speed;
private static int demonCounter = 0;
public Demon(int health, int speed)
{
= health;
= speed;
demonCounter += 1;
}
public override _Monster Clone()
{
return new Demon(health, speed);
}
public override void Talk()
{
($"Hello this is Demon number {demonCounter}. My health is {health} and my speed is {speed}");
}
}
}*Dragon
:
{
"dragons": [
{
"name": "FatDragon",
"scale": {
"x": 4,
"y": 1,
"z": 1
}
},
{
"name": "TallDragon",
"scale": {
"x": 1,
"y": 1,
"z": 3
}
},
{
"name": "LongDragon",
"scale": {
"x": 1,
"y": 4,
"z": 1
}
},
{
"name": "Dragon",
"scale": {
"x": 1,
"y": 1,
"z": 1
}
},
{
"name": "LittleDragon",
"scale": {
"x": 0.5,
"y": 0.5,
"z": 0.5
}
},
{
"name": "HugeDragon",
"scale": {
"x": 3,
"y": 3,
"z": 3
}
}
]
}
: Can be cloned to create a new dragon object
using UnityEngine;
[]
public class DragonData
{
public string name;
public Vector3 scale;
}
public abstract class DragonPrototype : MonoBehaviour
{
protected string Name;
protected Vector3 Scale;
public virtual void SetData(DragonData data)
{
Name = ;
Scale = ;
= Scale;
= Name;
}
public abstract DragonPrototype Clone();
}
:Inherited fromDragonPrototypeAnd implementClonemethod
using UnityEngine;
public class Dragon : DragonPrototype
{
void Start()
{
Invoke(nameof(DestroyThis), 10f);
}
private void DestroyThis()
{
Destroy(gameObject);
}
public override DragonPrototype Clone()
{
return Instantiate(this) as DragonPrototype;
}
void Update()
{
( * (- * 2));
}
}
:Carry object cloning
using ;
using ;
using UnityEngine;
public class Spawner : MonoBehaviour
{
public DragonPrototype Prototype;
public float GapTime = 1;
private List<DragonData> dragons;
void Start()
{
LoadDragonsFromJson( + @"\004PrototypePattern\");
InvokeRepeating(nameof(SpawnObj), 0, GapTime);
}
private void LoadDragonsFromJson(string path)
{
string json = (path);
var dragonsWrapper = <DragonsWrapper>(json);
if (dragonsWrapper != null && != null && > 0)
{
dragons = ;
}
else
{
("Dragons list is empty or null.");
}
}
void SpawnObj()
{
if (dragons == null || == 0) return;
int target = (0, );
DragonData dragonData = dragons[target];
DragonPrototype newDragon = () as DragonPrototype;
(dragonData);
= ;
}
[]
public class DragonsWrapper
{
public List<DragonData> dragons;
}
}
Singleton mode
***Use a singleton pattern means that there is only one instance of this object, this instance is constructed by the object itself and can be provided globally
*** Application scenarios
- When it is necessary to ensure that a certain class has only one instance.
- When a global access point needs to be provided to obtain this instance.
- When the cost of instantiation is high and only one instance is required.
***Implementation method
-
Privatization constructor: Make sure it cannot pass
newKeyword creation instances of class. - Provide a private static variable: Used to hold a unique class instance.
- Provide a public static method: Used to get class instances. If the instance does not exist, create an instance and return it; if the instance already exists, return it directly.
***advantage
- Control the number of instances: Make sure there is only one instance of the class to avoid wasting resources.
- Quick access: Provides a global access point to obtain instances for easy use. Any other class can use its public variables and methods by accessing the singleton
- Delay initialization: Instantiation operations can be delayed until it is really needed.
- Reduce code reuse, let special classes handle special things - for example, let TimeLog class record logs, instead of writing StreamWriter code into each class
***shortcoming
- Abuse single case: Because the implementation is simple and easy to use, there is a tendency to be abused, resulting in unreasonable system design.
- Difficulty in testing: Singleton pattern can cause unit testing difficulties because it introduces global state.
- Thread safety issues: Each thread can access this singleton, which will cause a series of problems such as initialization and deadlock. In a multi-threaded environment, thread safety needs to be ensured.
- Abuse of singletons can promote couplingBecause singletons are globally accessible, if the visitor does not access the singleton, it will cause overcoupling - for example, if the player allows singletons, the player can be called directly after the stone hits the ground to play the sound, which is not reasonable in the program world and will destroy the architecture
- If many, many classes and objects call a singleton and make a series of modifications, then it will be difficult to understand what happened
The book has always emphasized that singleton should not be used, because it is a global variable, which promotes coupling and is not concurrency friendly. When setting up a global variable, we created a piece of memory that each thread can access and modify it, regardless of whether they know that other threads are operating it. This can lead to deadlocks, conditional competition and some other hard-to-fix thread synchronization bugs
: Implement singleton instance
using System;
using;
using;
using;
using UnityEngine;
public class TimeLogger: MonoBehaviour
{
public static TimeLogger Instance;
private StreamWriter mSW;// StreamWriter is used to write files
void Awake()
{
Instance = this;
LoggerInit( + @"\005SingletonPattern\");
}
void LoggerInit(string path)
{
if (mSW == null)
{
mSW = new StreamWriter(path);
}
}
public void WhiteLog(string info)
{
( + ": " + info + "\n");
}
private void OnEnable()
{
LoggerInit( + @"\005SingletonPattern\");
}
private void OnDisable()
{
();
}
}:
using ;
using ;
using UnityEngine;
public class Speaker : MonoBehaviour
{
public string SpeakerName;
public float GapTime = 1;
private int index = 1;
void Start()
{
InvokeRepeating("Speak", 0, GapTime);
}
void Speak()
{
string content = "I'm " + SpeakerName + ". (Index : " + index + ")";
(content);
(content);
index++;
}
}
Status Mode
***Now state and conditions determine the new state of the object, and state determines behavior (the AnimationController in Unity is the state machine)
State Pattern allows an object to change its behavior when its internal state changes, and the object appears to modify its class. The state mode encapsulates the behavior of the object in different state objects, separating the state of the object from the object, and the client does not need to care about the current state and state transition of the object.
*** Application scenarios
- When an object's behavior depends on its state, and it must change its behavior according to its state at runtime.
- When there are a large number of conditional statements in the code, and these conditional statements depend on the state of the object.
- If the object needs to perform different behaviors according to its current state, and the number of states is very large and the code related to the state will be changed frequently.
***Implementation method
- State Interface: Define the methods required for a state class that describe the behavior an object should perform in that state.
- Concrete State Classes: Implement a state interface to define specific behaviors for objects in different states.
- Context class (Context): Contains a reference to a state object and updates its behavior when the state changes.
***advantage
- Code structure: Encapsulate state-related behaviors in specific state classes so that the state transition logic is clear.
- Easy to maintain and expand: Each state only needs to care about its own internal implementation, without affecting other and reducing coupling.
- Adding new status is easy to operate: Different states can be isolated, each state is a separate class, and the transformation logic of various states can be distributed into subclasses of states to reduce interdependence.
***shortcoming
- Increased number of classes:The number of state classes is large, which increases the complexity of the system.
- The state transition logic is complex: If the state transition logic is complex, the dependencies between state classes may become complicated.
- Structure and implementation complexity: The structure and implementation of the state mode are relatively complex. If used improperly, it will lead to confusion in the program structure and code.
LightSwitchCase:Light switches to the next state according to the current state and sets the corresponding light color
using;
using;
using UnityEngine;
public class LightSwitchCase : MonoBehaviour {
public LightState CurrentState = ;
private Light mLight;
private Material mMat;
private static readonly int EmissionColor = ("_EmissionColor");
public enum LightState
{
Off,
Warm,
White,
WarmWhite
}
private void Awake()
{
mLight = GetComponent<Light>();
mMat = GetComponentInChildren<Renderer>().material;
}
public void OnChangeState()
{
//State transition
switch (CurrentState)
{
case:
CurrentState = ;
break;
case:
CurrentState = ;
break;
case:
CurrentState = ;
break;
case:
CurrentState = ;
break;
default:
CurrentState = ;
break;
}
//Status Behavior
switch (CurrentState)
{
case:
= ;
(EmissionColor, );
break;
case:
= new Color(0.8f, 0.5f, 0);
(EmissionColor, );
break;
case:
= new Color(1, 0.85f, 0.6f);
(EmissionColor, );
break;
case:
= new Color(0.8f, 0.8f, 0.8f);
(EmissionColor, );
break;
default:
= ;
(EmissionColor, );
break;
}
}
}LightStateClass and TrafficState abstract classes:
using UnityEngine;
public class LightStateClass : MonoBehaviour
{
public GameObject GreenLightObj;
public GameObject YellowLightObj;
public GameObject RedLightObj;
//Lighting Material
private Material GreenLight;
private Material YellowLight;
private Material RedLight;
//Current lighting status
private TrafficState TrafficLight;
void Start()
{
GreenLight = <Renderer>().material;
YellowLight = <Renderer>().material;
RedLight = <Renderer>().material;
SetState(new Pass());
}
void Update()
{
(this, GreenLight, YellowLight, RedLight);
}
public void SetState(TrafficState state)
{
TrafficLight = state;
(GreenLight, YellowLight, RedLight);
}
}
public abstract class TrafficState
{
public float Duration;
public float Timer;
public static readonly int EmissionColor = ("_EmissionColor");//Control the material's self-luminous color attribute ID
public virtual void StateStart(Material GreenLight, Material YellowLight, Material RedLight)
{
Timer = ;//Current time
}
public abstract void ContinuousStateBehaviour(LightStateClass mLSC, Material GreenLight, Material YellowLight, Material RedLight);
}Traffic light status category: Pass, Passblink, Wait, Stop
using UnityEngine;
public class Pass : TrafficState
{
public Pass()
{
Duration = 2;
}
public override void StateStart(Material GreenLight, Material YellowLight, Material RedLight)
{
(GreenLight, YellowLight, RedLight);
(EmissionColor, );
(EmissionColor, );
(EmissionColor, );
}
public override void ContinuousStateBehaviour(LightStateClass mLSC, Material GreenLight, Material YellowLight, Material RedLight)
{
if ( > Timer + Duration)
{
(new PassBlink());
}
}
}
using UnityEngine;
public class PassBlink : TrafficState
{
private bool On = true;
private float BlinkTimer = 0;
private float BlinkInterval = 0.2f;
public PassBlink()
{
Duration = 1;
}
public override void StateStart(Material GreenLight, Material YellowLight, Material RedLight)
{ (GreenLight, YellowLight, RedLight); }
private static void SwitchGreen(Material GreenLight, bool open)
{
Color color = open ? : ;
(EmissionColor, color);
}
public override void ContinuousStateBehaviour(LightStateClass mLSC, Material GreenLight, Material YellowLight, Material RedLight)
{
if ( > Timer + Duration)
{
(new Wait());
}
if ( > BlinkTimer+BlinkInterval)
{
On = !On;
BlinkTimer = ;
SwitchGreen(GreenLight,On);
}
}
}
using UnityEngine;
public class Wait : TrafficState
{
public Wait()
{
Duration = 1;
}
public override void StateStart(Material GreenLight, Material YellowLight, Material RedLight)
{
(GreenLight, YellowLight, RedLight);
(EmissionColor, );
(EmissionColor, );
(EmissionColor, );
}
public override void ContinuousStateBehaviour(LightStateClass mLSC, Material GreenLight, Material YellowLight, Material RedLight)
{
if ( > Timer + Duration)
{
(new Stop());
}
}
}
using UnityEngine;
public class Stop : TrafficState
{
public Stop()
{
Duration = 1;
}
public override void StateStart(Material GreenLight, Material YellowLight, Material RedLight)
{
(GreenLight, YellowLight, RedLight);
(EmissionColor, );
(EmissionColor, );
(EmissionColor, );
}
public override void ContinuousStateBehaviour(LightStateClass mLSC, Material GreenLight, Material YellowLight, Material RedLight)
{
if ( > Timer + Duration)
{
(new Pass());
}
}
}
Double buffering mode
***Double Buffering is a technology that manages data reading and writing by setting two independent buffers. In the double buffering mechanism, the system switches between read and write buffers, so that producers and consumers can operate different buffers separately, avoiding direct conflicts
- *** When a buffer is ready, it will be used - just like a container will be shipped only if it is full; when one buffer is used, the other is in the ready state, a double buffer is formed
- ***Widely used in rendering, it will only be rendered onto the screen after a frame is ready - so the preparation time will cause the frame rate to drop
A display device such as a computer monitor draws only one pixel at each moment. It scans pixels in each row in the screen from left to right, and every row on the screen from top to bottom. When scanning to the lower right corner of the screen, it will reposition to the upper left corner of the screen and repeat the above behavior
Most of the pixel information used for drawing is learned from the framebuffer. The framebuffer is an array of pixels stored in RAM.
***application
- Graphic rendering: Used to prevent unwanted experiences such as flicker delay when displaying graphics.
- Audio processing and data acquisition: Reduce display flickering or audio interruption caused by refresh, and improve system response speed and stability.
- Multi-threaded environment: Improve system performance and reduce data competition by separating read and write operations.
***Data structure
- Double buffer consists of two buffers, called A buffer and B buffer respectively. During the data transmission process, the sender first stores the data in buffer A, and the receiver reads the data from buffer B. When the data transmission of one buffer is completed, the sender will be notified to store the next batch of data in another buffer.
***advantage
- Reduce data competition: Double buffering ensures that producers and consumers operate different buffers by separating read and write, thereby avoiding data competition.
- Improve performance: The waiting time is reduced through asynchronous reading and writing, and the system's throughput is effectively improved.
- Meet real-time needs: In real-time systems, rapid data updates and displays are particularly important. Double buffering can reduce display flickering or audio interruption caused by refresh
***Example 1: Task Scheduling System
Schedule: Implement the task scheduling function
using System;
using;
using UnityEngine;
public class Schedule : MonoBehaviour
{
// Double buffered list to prevent direct modification of the timer queue during the timer callback
[SerializeField] private List<Task> _Front; // _Front is used to collect newly added tasks
[SerializeField] private List<Task> _Back; // _Back is used to iterate and process tasks
// Collect Schedule objects that need to be removed to avoid directly modifying the _Back list during the iteration process
[SerializeField] private List<Task> _Garbage;
private static Schedule Instance;
private void Awake()
{
if (Instance == null)
Instance = this;
DontDestroyOnLoad(this);
_Front = new List<Task>();
_Back = new List<Task>();
_Garbage = new List<Task>();
}
// Set up a new scheduled task
public Task SetSchedule(string bindName, float time, Action<Task> callback, bool usingWorldTimeScale = false
, bool isLoop = false, bool isPause = false)
{
// Create a new Schedule instance and add it to the _Front queue
var sd = new Task(bindName, time, callback, usingWorldTimeScale, isLoop, isPause);
_Front.Add(sd);
("Schedule: " + _Front.Count + " tasks added.");
return sd;
}
public void SetSchedule(Task sd)
{
if (_Back.Contains(sd))
{
// If already in _Back, you don't need to add it again
return;
}
if (!_Front.Contains(sd))
{
// If not in _Front, add back
_Front.Add(sd);
}
}
public void RemoveSchedule(Task sd)
{
if (sd == null) return;
_Front.Remove(sd);
_Back.Remove(sd);
}
// Update the status of all scheduled tasks
private void Update()
{
// Transfer all new tasks in _Front to _Back, and clear _Front if (_Front.Count > 0)
{
_Back.AddRange(_Front);
_Front.Clear();
}
float dt = ; // Get the time difference since the last call
foreach (Task s in _Back)
{
// Check whether the task has been cancelled. If canceled, it will be marked as garbage and skipped
if ()
{
_Garbage.Add(s);
continue;
}
if ()
{
continue;
}
Task sd = s;
// Calculate the remaining time and whether to use the world time ratio
float tmpTime = ;
var InGameTimeScale = 1.0f; // Assuming that the game is not paused and the time ratio is 1.0f, it can be accelerated or slowed down
tmpTime -= ? dt * InGameTimeScale : dt;
// Update the remaining time of Schedule
(tmpTime);
if (tmpTime > 0) continue;
// If the time has reached or exceeded the trigger point, execute the callback function
?.Invoke(s);
if ()
{
(); // Reset time to original time
}
else
{
_Garbage.Add(s); // Mark as garbage
}
}
// Clean up completed or canceled tasks
("Schedule: " + _Garbage.Count + " garbage tasks removed.");
foreach (Task s in _Garbage)
{
if (_Back.Contains(s))
{
_Back.Remove(s); // Remove garbage tasks from _Back
}
}
_Garbage.Clear(); // Clear the garbage list
}
}Task: A serialized class that represents a separate task
using System;
[Serializable]
public class Task
{
public bool Canceled; // Whether to cancel the task
public float OriginalTime; // Store original time
public float Time; // Task duration
public bool UsingWorldTimeScale; // Whether to use the world time ratio
public bool IsLoop; // Whether to loop
public bool IsPause; // Whether to pause
public string TaskName; // Task name
public Action<Task> Callback; // Callback function when the task is completed
public Task(string taskTaskName, float time, Action<Task> callback, bool usingWorldTimeScale = false
, bool isLoop = false, bool isPause = false)
{
Time = time;
OriginalTime = time;
UsingWorldTimeScale = usingWorldTimeScale;
TaskName = taskTaskName;
IsLoop = isLoop;
IsPause = isPause;
Callback = callback;
}
public Task(float t, Action<Task> callback)
{
Time = t;
Callback = callback;
}
public void Cancel()
{
Canceled = true;
}
public void ResetTime(float t)
{
Time = t;
}
}TaskPanel: A custom window in the Unity editor is used to create a user interface to manage tasks. It is mainly used for learning. The actual task scheduling should be implemented by the code.
using System;
using UnityEngine;
using UnityEditor;
public class TaskPanel : EditorWindow
{
public string taskName = "New Task";
public float time = 1.0f;
public bool usingWorldTimeScale = false;
public bool isLoop = false;
public bool isPause = false;
public int selectedCallbackIndex = 0; // Used to store the selected callback function index
private Schedule schedule;
private string[] callbackFunctionNames; // Array that stores callback function names
[MenuItem("Tools/Task Panel")]
public static void ShowWindow()
{
GetWindow<TaskPanel>("Task Panel");
}
private void OnEnable()
{
// Initialize the callback function name array
callbackFunctionNames = new[] { "Callback1", "Callback2", "Callback3", };
}
private void OnGUI()
{
("Task Panel", );
taskName = ("Task Name", taskName);
time = ("Time", time);
usingWorldTimeScale = ("Use World Time Scale", usingWorldTimeScale);
isLoop = ("Is Loop", isLoop);
isPause = ("Is Pause", isPause);
// Select the callback function in the drop-down menu
selectedCallbackIndex = ("Callback Function", selectedCallbackIndex, callbackFunctionNames);
if (("Create Task"))
{
CreateTask();
}
}
private void CreateTask()
{
Action<Task> callback = null;
if (selectedCallbackIndex >= 0 && selectedCallbackIndex < )
{
string callbackFunctionName = callbackFunctionNames[selectedCallbackIndex];
callback = (Action<Task>)(typeof(Action<Task>), this, callbackFunctionName);
}
// Assume here that Schedule is a singleton or can be accessed in other ways
schedule = FindObjectOfType<Schedule>();
if (schedule != null)
{
(taskName, time, callback, usingWorldTimeScale, isLoop, isPause);
}
else
{
("Schedule object not found!");
}
}
// Sample callback function
public void Callback1(Task task)
{
("Callback1: Task " + + " completed!");
}
public void Callback2(Task task)
{
("Callback2: Task " + + " completed!");
}
public void Callback3(Task task)
{
("Callback3: Task " + + " completed!");
}
}Game loop
1. FPS depends on constant gaming speed
const int FRAMES_PER_SECOND = 25; //Constant number of frames
const int SKIP_TICKS = 1000 / FRAMES_PER_SECOND;
DWORD next_game_tick = GetTickCount();
// GetTickCount() returns the current number of million seconds
// that have elapsed since the system was started
int sleep_time = 0;
bool game_is_running = true;
while( game_is_running ) {
update_game();
display_game();
next_game_tick += SKIP_TICKS;
sleep_time = next_game_tick - GetTickCount();
if( sleep_time >= 0 ) {
Sleep( sleep_time );
}
else {
// Shit, we are running behind!
}
}Two important variables to control the constant frame count:next_game_tick: The time point when this frame is completedsleep_time: If it is greater than 0, the time has not reached the time point for completing this frame. Enable Sleep to wait for the arrival of the time point; if it is less than 0, the work of the frame is not completed.
The benefits of constant frame count: prevents the entire game from tearing the picture due to frame skipping. Lower performance hardware will appear slower; high performance hardware will waste hardware resources
2. Game speed depends on variable FPS
DWORD prev_frame_tick;
DWORD curr_frame_tick = GetTickCount（）;
bool game_is_running = true;
while（game_is_running）{
prev_frame_tick = curr_frame_tick;
curr_frame_tick = GetTickCount（）;
update_game（curr_frame_tick - prev_frame_tick）;
display_game（）;
}
Two important variables to control the constant frame count:prev_frame_tick: The point in time when the previous frame was completedcurr_frame_tick: Current time pointcurr_frame_tickandprev_frame_tickThe difference is the time required for one frame. According to this variable, the time of each frame is different. FPS is also variable.
Slow hardware can sometimes cause some delays at certain points and the game becomes stuttering.
Fast hardware can also have problems, and variable frame count means that there will inevitably be calculation errors during calculations.
This game loop seems good to love at first sight, but don't be fooled. Both slow and fast hardware can cause serious problems in the game. In addition, the implementation of game update functionality is more difficult than when using a fixed frame rate, so why use it?
3. Constant gaming speed with maximum FPS
const int TICKS_PER_SECOND = 50;
const int SKIP_TICKS = 1000 / TICKS_PER_SECOND;
const int MAX_FRAMESKIP = 10;
DWORD next_game_tick = GetTickCount();
int loops;
bool game_is_running = true;
while( game_is_running ) {
loops = 0;
while( GetTickCount() > next_game_tick && loops < MAX_FRAMESKIP) {
update_game();
next_game_tick += SKIP_TICKS;
loops++;
}
display_game();
}
MAX_FRAMESKIP : The lowest multiple of frame reduction
The maximum number of frames is 50 frames. When the frames are too low, the rendered frames will be reduced (display_game()), and the lowest number of frames can be as low as 5 frames (the maximum number of frames is reduced by 10 times), and the update frames will remain unchanged (update_game())
On slow hardware, frames per second drop, but the game itself is expected to run at normal speeds.
There is no problem with the fast hardware, but like the first solution, you're wasting a lot of valuable clock cycles that can be used for higher frame rates. It is crucial to find a balance between fast update rates and being able to run on slow hardware. (The most important reason is that the number of frames is limited)
Disadvantages are similar to the first solution
4. Constant gaming speed is independent of variable FPS
const int TICKS_PER_SECOND = 25;
const int SKIP_TICKS = 1000 / TICKS_PER_SECOND;
const int MAX_FRAMESKIP = 5;
DWORD next_game_tick = GetTickCount();
int loops;
float interpolation;
bool game_is_running = true;
while( game_is_running ) {
loops = 0;
while( GetTickCount() > next_game_tick && loops < MAX_FRAMESKIP) {
update_game();
next_game_tick += SKIP_TICKS;
loops++;
}
interpolation = float( GetTickCount() + SKIP_TICKS - next_game_tick )
/ float( SKIP_TICKS );
display_game( interpolation );
}
Rendering frames are implemented by prediction and interpolation.interpolationCalculate the equivalent frame count
The game loop is more than expected. There is one thing that should be avoided, and this is the one where variable FPS determines the speed of the game. A constant frame rate can be a good and easy solution for mobile devices, but when you want to get everything the hardware has, it's better to use a game loop that's completely independent of the game speed, using high frame rate prediction capabilities. If you don't want to use predictions, you can use the maximum frame rate, but finding the right game update rate for slow and fast hardware can be tricky
Iterator mode
***Iterator Pattern is a behavioral design pattern that provides a way to access individual elements in an aggregate object sequentially without exposing its internal representation.
Iterator mode is widely used in unity game development
.NET framework providesIEnumerableandIEnumeratorinterface
onecollectionNeed to supportForeachIt is necessary to perform traversalIEnumerableand somehow return the iterator object:IEnumerable
*** Application scenarios
- When multiple ways to traverse aggregate objects are needed.
- When it is necessary to provide a unified interface for traversing different aggregation structures.
- When accessing the content of an aggregate object without exposing its internal details.
***Data structure
-
Iterator: Defines the interface to access and traverse elements, usually including
hasNext()、next()etc. - Concrete Iterator: Implement the iterator interface and track the current location to traverse elements in the aggregate object.
-
Aggregate: Define the interface to create the corresponding iterator object, usually including a method that returns an iterator instance, such as
iterator()。 - ConcreteAggregate: Implement the interface to create the corresponding iterator and return an instance of the specific iterator.
***Implementation method
- The iterator pattern is implemented by separating the traversal behavior of the aggregated object and abstracting it into an iterator class. The purpose is to allow external code to transparently access the aggregated internal data without exposing the internal structure of the aggregated object.
***advantage
- Encapsulation: Iterator mode encapsulates the responsibility of traversing the collection into a separate object, protecting the internal representation of the collection and improving the encapsulation of the code.
- Extensibility: Iterator mode allows new traversal methods to be added without modifying the aggregated class code. Just implement a new iterator class.
- flexibility: The iterator mode provides a variety of traversal methods, such as sequential traversal, reverse traversal, multi-thread traversal, etc. You can choose the appropriate traversal method according to actual needs.
Unity's Transform uses the iterator mode:
public partial class Transform: Component, IEnumerable
{
// Implement the GetEnumerator method of the IEnumerable interface, returning an enumerator to traverse the child objects of Transform.
public IEnumerator GetEnumerator()
{
return new (this);
}
// The inner class Enumerator implements the IEnumerator interface, which is used to traverse the child objects of Transform.
private class Enumerator: IEnumerator
{
// Refer to an external Transform instance to represent the parent Transform to traverse.
Transform outer;
// The index currently enumerated, -1 means that it has not started or ended.
int currentIndex = -1;
// The constructor takes a Transform instance as a parameter and initializes the outer field.
internal Enumerator(Transform outer)
{
= outer;
}
// Returns the child Transform object of the current index position.
public object Current
{
get { return (currentIndex); }
}
// Move to the next element and return whether it has been successfully moved to a new valid element.
public bool MoveNext()
{
// Get the number of child objects and check whether the current index is in range.
int childCount = ;
return ++currentIndex < childCount;
}
// Reset the state of the enumerator and set currentIndex to -1 to indicate that you return to the starting state.
public void Reset()
{
currentIndex = -1;
}
}
}Implement the iterator mode:
namespace Iterator
{
public interface IAggregate//IAggregate interface defines the method to create the corresponding iterator
{
void Add(object obj);
void Remove(object obj);
IIterator GetIterator();
}
}namespace Iterator
{
The public interface IIterator//IIterator interface defines the method required to traverse the aggregated object
{
object First();
object Next();
bool HasNext();
}
}namespace Iterator
{
public class ConcreteIterator: IIterator//ConcreteIterator class implements the IIterator interface, providing iterative logic for specific aggregate objects
{
private List<object> _list = null;
private int _index = -1;
public ConcreteIterator(List<object> list)
{
_list = list;
}
public bool HasNext()
{
return _index < _list.Count - 1;
}
public object First()
{
_index = 0;
return _list[_index];
}
public object Next()
{
if (HasNext())
{
_index++;
return _list[_index];
}
return null;
}
}
}namespace Iterator
{
public class ConcreteAggregate: IAggregate//ConcreteAggregate class implements the IAggregate interface and encapsulates a specific aggregate object
{
private List<object> _list = new List<object>();
public void Add(object obj)
{
_list.Add(obj);
}
public void Remove(object obj)
{
_list.Remove(obj);
}
public IIterator GetIterator()
{
return new ConcreteIterator(_list);
}
}
}namespace Iterator
{
public class IteratorPatternDemo
{
static void Main(string[] args)
{
IAggregate aggregate = new ConcreteAggregate();
("Sunshan University");
("South China Science and Technology");
("Shaoguan College");
("The content of the aggregate is:");
IIterator iterator = ();
While (())
{
object obj = ();
(() + "\t");
}
object firstObj = ();
("\nFirst:" + ());
}
}
}Responsibility chain model
*** Avoid coupling the sender of a request with the receiver, giving multiple objects the opportunity to process the request. Connect the recipient's object into a line and pass the request along this chain until it knows that there is an object that can handle it
The Chain of Responsibility Pattern is a behavioral design pattern that connects multiple processors (processing objects) in a chain structure so that requests are passed along the chain until one processor processes the request. The main purpose of this pattern is to decouple the sender and receiver of the request, so that multiple objects have the potential to receive the request, and the sender does not need to know which object will handle it
*** Application scenarios
- Multiple objects may handle the same request: When the request processing is not fixed, or it needs to dynamically decide which object handles the request.
- The processor object collection needs to be dynamically determined: Scenario where the processor order is dynamically adjusted as needed during runtime.
- Enhance the flexibility of the system: Through the responsibility chain model, the handlers in the responsibility chain can be flexibly added or removed.
***Implementation method
- Handler: Define an interface for processing requests, including a method that sets the next processor and a method that handles the request.
- ConcreteHandler: The implementation object of Handler, which can process requests or pass requests to the next handler in the chain.
- Client: Create handler objects and set the order between them.
***advantage
- Reduce coupling: The responsibility chain pattern makes an object less likely to know which object handles its request and the structure of the chain, and the coupling degree between the sender and the receiver is reduced.
- Flexibility and scalability: Through the responsibility chain mode, processing objects can be dynamically combined and processing processes can be flexibly configured. This decoupling makes the system more flexible and scalable
public abstract class AbstractSkillHandler
{
protected AbstractSkillHandler _nextSkill;
public AbstractSkillHandler(AbstractSkillHandler nextSkill)
{
_nextSkill = nextSkill;
}
public abstract bool CanHandle(int energy);
public virtual void Handle(int energy)
{
_nextSkill?.Handle(energy); //If the next skill exists, call the next Handle method
}
}Component Mode
***Component Pattern, which splits a large object into multiple small components, each with independent responsibilities and behaviors, and can be combined with each other to build complex systems. This mode allows developers to independently develop and maintain various functional modules in the game (such as the protagonist status module, backpack module, equipment module, skill module and combat module), thereby improving the reusability and maintainability of the code.
*** Application scenarios
- In game development and simulation, in which game entities (such as characters, items) can have dynamic abilities or states.
- Systems that require highly modularity, as well as systems that may require changing behavior at runtime without inheriting hierarchies.
- When a class becomes larger and more difficult to develop.
***Data structure
- Component Class: Defines the interface and behavior of components.
- Combination class: Combine multiple components together to form more complex objects.
***Implementation method
- Component pattern solves complex systems problems by creating separate component classes for graphics and sound, allowing for flexible and independent development. This modular approach enhances maintainability and scalability.
***advantage
- Flexibility and reusability: Components can be reused in different entities, making it easier to add new features or modify existing features.
- Decoupling: Reduces the dependence between game entity state and behavior, making it easier to make changes and maintenance.
- Dynamic combination: Entities can change their behavior at runtime by adding or removing components, providing great flexibility for game design
using System;
using UnityEngine;
namespace ComponentPattern
{
public class Player : MonoBehaviour
{
private JumpComponent jumpComponent;
private MoveComponent moveComponent;
private void Awake()
{
jumpComponent = <JumpComponent>();
moveComponent = <MoveComponent>();
}
private void Update()
{
if (())
();
if (())
(false, 1);
if (())
(true, 1);
}
}
}
using UnityEngine;
namespace ComponentPattern
{
public class MoveComponent : MonoBehaviour
{
public void Move(bool isRight, float speed)
{
float direction = isRight ? 1f : -1f;
( * (direction * speed * ), );
}
}
}
using UnityEngine;
namespace ComponentPattern
{
public class JumpComponent : MonoBehaviour
{
public float JumpVelocity = 1f;
public Rigidbody rb;
private void Start()
{
rb = <Rigidbody>();
}
public void Jump()
{
= * JumpVelocity;
}
}
}
Subclass sandbox mode
***SubClassSandbox is a design idea that allows subclasses to define their behavior based on these operations by defining an abstract sandbox method and some predefined set of operations in the base class. These operations are usually set to a protected state to ensure that they are only used by subclasses
*** Application scenarios
- You have a base class with a large number of subclasses.
- The base class can provide a collection of operations that all subclasses may need to perform.
- There is overlapping code between subclasses, and you want to share code more easily between them.
- You want to minimize the coupling between these inherited classes and other codes of the program.
***Implementation method
- In the subclass sandbox pattern, the base class provides a series of protected methods that are used by subclasses to implement specific behavior. Subclasses combine these operations by overriding the abstract sandbox method in the base class to realize their own functions.
***advantage
- Reduce coupling: By encapsulating operations in a base class, the coupling between subclasses is reduced because each subclass is coupled only to the base class.
- Code reuse: Subclasses can reuse operations provided by the base class, reducing code redundancy.
- Easy to maintain: When a certain part of the game system is changed, just modify the base class without modifying many subclasses.
***shortcoming
- Fragile base class problems: Since the subclass touches the rest of the game through the base class, the base class finally couples with each system required by the subclass. This spider web coupling makes it difficult for you to change the base class without destroying anything
using UnityEngine;
namespace SubclassSandboxPattern
{
public class GameController: MonoBehaviour
{
private SkyLaunch skyLaunch;
private SpeedLaunch speedLaunch;
private void Start()
{
skyLaunch = new SkyLaunch();
speedLaunch = new SpeedLaunch();
}
private void Update() //You can combine the state mode to control whether the superpower can be used
{
if (())
{
();
}
if (())
{
();
}
}
}
}
using UnityEngine;
namespace SubclassSandboxPattern
{
// Superpower abstract class is the basis of all superpowers
public abstract class Superpower
{
// Subclasses must implement this method, which represents the behavior when the superpower is activated
public abstract void Activate();
protected void Move(string where)
{
($"Moving towards {where}");
}
protected void PlaySound(string sound)
{
($"Playing sound {sound}");
}
protected void SpawnParticles(string parts)
{
($"Firing {particles}");
}
}
}
namespace SubclassSandboxPattern
{
public class SkyLaunch : Superpower
{
// Rewrite the Activate method of the parent class to define the behavior when SkyLaunch is activated.
public override void Activate()
{
PlaySound("Launch Sky sound"); // Play and emit sound
SpawnParticles("Fly"); // Generate dust particle effect
Move("sky"); // Move to the sky
}
}
}
namespace SubclassSandboxPattern
{
public class SpeedLaunch : Superpower
{
public override void Activate()
{
PlaySound("Launch Speed Launch");
SpawnParticles("dust");
Move("quickly");
}
}
}Type object pattern
***Type Object Pattern allows the creation of flexible and reusable objects by creating a class with a field representing the object's "type". This design pattern is very valuable for scenarios where undefined types need to be defined in advance or where types need to be modified or added. It extracts some type system from inheritance and puts it into configurable data
*** Application scenarios
- When you need to define different "genres" of things, but the language's own type system is too stiff.
- When you don't know what other types are needed later, or want to modify or add new types without changing the code or recompiling.
***Implementation method
- The type object pattern is implemented by defining type object classes and typed object classes. Each type object instance represents a different logical type. Each typed object holds a reference to a type object that describes its type. The data related to the instance is stored in the instance with typed objects, and the data or behavior shared by the same type is stored in the typed objects.
***advantage
- Create a new type object at runtime: Allows the dynamic creation of new type objects at runtime.
- Avoid subclass expansion: Through the type object pattern, excessive expansion of subclasses can be avoided.
- Client programs do not need to understand the separation of instances and types: Client programs do not need to understand the separation of instances and types.
- Types can be changed dynamically: Type object pattern allows dynamic changes to types
using UnityEngine;
namespace TypeObjectController
{
public class TypeObjectController: MonoBehaviour
{
private void Start()
{
// Create various animal instances and set whether they can fly.
Bird ostrich = new Bird("ostrich", canFly: false);
Bird pigeon = new Bird("pigeon", canFly: true);
Mammal rat = new Mammal("rat", canFly: false);
Mammal bat = new Mammal("bat", canFly: true);
Fish flyingFish = new Fish("flying fish", canFly: true);
Fish goldFish = new Fish("goldfish", canFly: false);
// Call the Talk method to output information about whether each animal can fly.
();
();
();
();
();
();
}
}
}
namespace TypeObjectController
{
//Define a contract for a type that can fly. Any class that implements this interface needs to provide an implementation of the CanIFly() method, which returns a Boolean value to indicate whether the type can fly.
public interface IFlyingType
{
bool CanIFly();
}
}
namespace TypeObjectController
{
//The specific classes of the IFlyingType interface are implemented, representing the types that can fly and cannot fly respectively.
public class ICanFly : IFlyingType
{
public bool CanIFly()
{
return true;
}
}
public class ICantFly : IFlyingType
{
public bool CanIFly()
{
return false;
}
}
}
namespace TypeObjectController
{
public abstract class Animal
{
protected string name;
protected IFlyingType flyingType;
protected Animal(string name, bool canFly)
{
= name;
flyingType = canFly ? new ICanFly() : new ICantFly();
}
public abstract void Talk();
}
}
using UnityEngine;
namespace TypeObjectController
{
public class Bird : Animal
{
public Bird(string name, bool canFly) : base(name, canFly) { }
public override void Talk()
{
string canFlyString = () ? "can" : "can't";
($"Hello this is {name}, I'm a bird, and I {canFlyString} fly!");
}
}
}
using UnityEngine;
namespace TypeObjectController
{
public class Mammal : Animal
{
public Mammal(string name, bool canFly) : base(name, canFly) { }
public override void Talk()
{
string canFlyString = () ? "can" : "can't";
($"Hello this is {name}, I'm a mammal, and I {canFlyString} fly!");
}
}
}
using UnityEngine;
namespace TypeObjectController
{
public class Fish : Animal
{
public Fish(string name, bool canFly) : base(name, canFly) { }
public override void Talk()
{
string canFlyString = () ? "can" : "can't";
($"Hello this is {name}, I'm a fish, and I {canFlyString} fly!");
}
}
}Command Queue Mode
***Command Queue Pattern is used to manage and execute a series of commands. This pattern is often used to ensure that commands are executed in a specific order and that only one command is running at a time. It is very useful in game development, event processing systems, and other scenarios where command scheduling is required.
*** Application scenarios
- When multiple commands need to be executed in a specific order.
- When it is necessary to ensure that only one command is running at a time.
- When a flexible command scheduling mechanism is required.
***Implementation method
- The command queue mode is implemented by defining the command interface (ICommand), specific command classes, command queue classes (CommandQueue) and executors (Invoker). Each specific command class implements a command interface, which contains the specific logic of executing commands. The Command Queue class manages a command queue to ensure that the commands are executed in order. The executor is responsible for adding the command to the queue and triggering the execution of the command.
***advantage
- Ensure commands are executed in sequence: Command queue mode ensures that commands are executed in a specific order.
- Avoid concurrent execution problems: Avoid concurrent execution problems by ensuring that only one command is running at a time.
- Improve system flexibility and scalability: Command queue mode provides a flexible and extensible command scheduling mechanism.
- Simplify the management and execution of commands: By centrally managing the execution of commands, the management and execution of commands is simplified.
using UnityEngine;
namespace
{
public class GameController: MonoBehaviour
{
public Popup firstPopUp, secondPopup, thirdPopup;
private CommandQueue _commandQueue;
private void Start()
{
// create a command queue
_commandQueue = new CommandQueue();
StartCommands();
}
public void StartCommands()
{
_commandQueue.Clear();
// add commands
_commandQueue.Enqueue(new FirstCmd(this));
_commandQueue.Enqueue(new SecondCmd(this));
_commandQueue.Enqueue(new ThirdCmd(this));
("Commands enqueued");
}
}
}
using;
namespace
{
//This class manages a command queue to ensure that the commands are executed in order and that only one command is running at a time
public class CommandQueue
{
private readonly Queue<ICommand> _queue;
public bool _isPending; // it's true when a command is running
public CommandQueue()
{
_queue = new Queue<ICommand>();
_isPending = false;
}
public void Enqueue(ICommand cmd)
{
_queue.Enqueue(cmd);
if (!_isPending) // if no command is running, start to execute commands
DoNext();
}
public void DoNext()
{
if (_queue.Count == 0)
return;
ICommand cmd = _queue.Dequeue();
// setting _isPending to true means this command is running
_isPending = true;
// listen to the OnFinished event
+= OnCmdFinished;
();
}
private void OnCmdFinished()
{
// current command is finished
_isPending = false;
// run the next command
DoNext();
}
public void Clear()
{
_queue.Clear();
_isPending = false;
}
}
}
using System;
namespace
{
// The command interface defines the methods that all commands must implement
public interface ICommand
{
Action OnFinished { get; set; }
void Execute();
}
}
using System;
using UnityEngine;
namespace
{
//Represents a user interface component that can be displayed and closed
public class Popup : MonoBehaviour
{
public Action onClose;
public void Close()
{
onClose?.Invoke();
}
}
}
using System;
namespace
{
public class BaseCommand : ICommand
{
public Action OnFinished { get; set; }
protected readonly GameController _owner;
protected BaseCommand(GameController owner)
{
_owner = owner;
}
public virtual void Execute() { }
protected virtual void OnClose() { }
}
}
using UnityEngine;
namespace
{
public class FirstCmd : BaseCommand
{
public FirstCmd(GameController owner) : base(owner) { }
public override void Execute()
{
_owner.(true); //Activate the first pop-up window and subscribe to its closing event
_owner. += OnClose;
("Executing First Command");
}
protected override void OnClose()
{
_owner. -= OnClose; //Remove subscriptions to close events to prevent memory leaks
_owner.(false);
OnFinished?.Invoke();
("First Command Finished");
}
}
}
using UnityEngine;
namespace
{
public class SecondCmd : BaseCommand
{
public SecondCmd(GameController owner) : base(owner) { }
public override void Execute()
{
_owner.(true);
_owner. += OnClose;
("Second command executed");
}
protected override void OnClose()
{
_owner. -= OnClose;
_owner.(false);
OnFinished?.Invoke();
("Second command finished");
}
}
}
using UnityEngine;
namespace
{
public class ThirdCmd : BaseCommand
{
public ThirdCmd(GameController owner) : base(owner) { }
public override void Execute()
{
_owner.(true);
_owner. += OnClose;
("Third command executed");
}
protected override void OnClose()
{
_owner. -= OnClose;
_owner.(false);
OnFinished?.Invoke();
("Third command finished");
}
}
}Event Queue Mode
***Event Queue Pattern is a design pattern used to manage and process a series of events. This pattern is often used to ensure that events are processed in a specific order and that events can be processed asynchronously. It is very useful in graphical user interface (GUI) programming, game development, and other scenarios where event-driven mechanisms are required.
*** Application scenarios
- When multiple events need to be processed in a specific order.
- When events need to be processed asynchronously to avoid blocking the main thread.
- When a flexible event handling mechanism is required.
***Implementation method
- The event queue mode is implemented by defining event interfaces, specific event classes, event queue classes (EventQueues) and event handlers (EventHandlers). Each specific event class implements an event interface, including the specific data of the event and processing logic. The event queue class manages an event queue to ensure that events are processed sequentially. The event handler is responsible for fetching events from the queue and processing them.
***advantage
- Ensure event sequence processing: Event queue mode ensures that events are processed in a specific order.
- Support asynchronous event processing: Avoid blocking the main thread by processing events asynchronously.
- Improve system flexibility and scalability: Event queue mode provides a flexible and scalable event processing mechanism.
- Simplify management and handling of events: Through centralized management of event processing, simplified event management and processing
namespace
{
using;
using UnityEngine;
public class EventQueue : MonoBehaviour
{
public GameObject PosIndicator;
public Holder Holder;
private Queue<Transform> _destinationQueue;
private Transform _destination;
public float Speed = 10;
private void Start()
{
+= AddDestination;
_destinationQueue = new Queue<Transform>();
}
private void OnDestroy()
{
-= AddDestination;
}
private void AddDestination()
{
Ray ray = (); //Convert screen coordinates to world coordinate rays
/*
*? In three-dimensional space, a ray is a line that starts from a certain starting point and extends infinitely in a certain direction. The Ray structure in Unity has two main properties:
*? origin: The starting point of the ray, usually a three-dimensional coordinate (x, y, z) *? direction: The direction of the ray, is also a three-dimensional vector, indicating the direction of the ray extension
*? The GetPoint(float distance) method accepts a floating point parameter that specifies the distance from the starting point of the ray. This method calculates and returns the coordinates of the point on the ray at the unit length of the starting point distance from the starting point
* GetPoint(10) returns a point 10 units away from the starting point of the ray (i.e. the camera position). This means that no matter where you click on the screen, you will get a new location that is fixed distance from the camera as your destination
* Select 10 units as a fixed value to ensure that the generated destination is not too close or too far
* If the distance is set too small, it may cause the target point to appear very close to the camera;
* If it is too large, it may make the target point beyond reasonable range or be difficult to control.
*/ Vector3 destination = (10);
GameObject indicator = Instantiate(PosIndicator, destination, );
_destinationQueue.Enqueue();
}
private void Update()
{
if (_destination == null && _destinationQueue.Count > 0)
{
_destination = _destinationQueue.Dequue();
}
if (_destination == null) return;
Vector3 startPosition = ;
Vector3 destinationPosition = _destination.position;
float distance = (startPosition, destinationPosition); //Calculate the distance between the current position and the target position
//Use the Lerp method to move smoothly toward the target position
startPosition = (startPosition, destinationPosition, Mathf.Clamp01(( * Speed) / distance));
= startPosition;
(destinationPosition);
if (distance < 0.01f)
{
Destroy(_destination.gameObject);
_destination = null;
}
}
}
}
using UnityEngine;
namespace
{
public interface IHolder
{
public void ExecuteEvent(Vector3 targetPos);
}
}
using UnityEngine;
namespace
{
public class Holder : MonoBehaviour, IHolder
{
public virtual void ExecuteEvent(Vector3 targetPos) { }
}
}
using UnityEngine;
public class MouseInputManager: MonoBehaviour
{
public delegate void MouseInputeHandler();
public MouseInputeHandler OnMouseClick;
public static MouseInputManager Instance;
private void Awake()
{
Instance = this;
}
private void Update()
{
if ((0))
{
OnMouseClick();
}
}
}
using UnityEngine;
namespace
{
public class Dragon : Holder
{
public override void ExecuteEvent(Vector3 targetPos)
{
Vector3 direction = targetPos - ; // Calculate direction vector
Quaternion targetRotation = (direction); // Calculate the rotation angle
= (, targetRotation, * 5f);
}
}
}Service Locator Mode
***Service locator mode is a design pattern used to help applications find and obtain the required service objects. It provides an indirect way to access services, encapsulating the specific creation and search logic of the service in a central locator component.
*** Application scenarios
- When an application needs to access multiple services in a flexible and maintainable way.
- When decoupling service callers and specific service implementations are needed.
***Implementation method
- The service locator mode is implemented by defining the service locator interface, the service locator implementation, the service interface and specific services. The service locator manages the registration and search of services, and the client accesses the required services through the service locator.
***advantage
- Decoupled service access: Separate the service access logic from the business logic that uses the service.
- Centralized management: Centralized management of access points of the service, easy to maintain and expand.
- flexibility: Easy to add, modify or replace services.
- Delayed instantiation: Service instances can be instantiated on the first request (Lazy Instantiation), thus saving resources.
***shortcoming
- Performance issues: Service locators may introduce performance overhead, especially when each service request is searched.
- Hide dependencies: The service locator provides services through global access points, which may lead to unclear dependencies, resulting in reduced readability and testability of the code.
***Usage suggestions
- When considering using the service locator mode, you should avoid over-dependence on the service locator because it may mask the dependencies of the system, making debugging and optimization difficult.
using UnityEngine;
namespace
{
public class GameController: MonoBehaviour
{
private void Start()
{
// Create a ConsoleAudio instance and register the instance as the audio service provider for the current game through Locator.
// If you want to disable the audio function, you can pass null to the Provide method.
var consoleAudio = new ConsoleAudio();
(consoleAudio);
//(null); // Used to test the behavior of NullAudio
}
private void Update()
{
// Get the current audio service provider from Locator.
Audio locatorAudio = ();
if (())
{
(twenty three);
}
else if (())
{
(twenty three);
}
else if (())
{
();
}
}
}
}
namespace
{
// Define an abstract class Audio, which specifies the methods that all audio services must implement
public abstract class Audio
{
public abstract void PlaySound(int soundID);
public abstract void StopSound(int soundID);
public abstract void StopAllSounds();
}
}
namespace
{
//As a service locator, it is responsible for holding the currently active Audio service instance
public class Locator
{
private static NullAudio nullService;
private static Audio service;
// Static constructor, ensuring that the default service instance is initialized before the first access to the Locator class
static Locator()
{
nullService = new NullAudio();
// Set to nullService during initialization to prevent forgetting to register the actual Audio implementation
service = nullService;
}
// Return the currently registered audio service instance
public static Audio GetAudio()
{
return service;
}
// Allow external code to register or replace the current audio service instance through this method
public static void Provide(Audio _service)
{
// If null is passed in, nullService is used instead, which is usually used to disable the audio function
service = _service ?? nullService;
}
}
}
using UnityEngine;
namespace
{
public class ConsoleAudio : Audio
{
// Output a message on the console to indicate that the sound with the specified ID is started to play.
public override void PlaySound(int soundID)
{
($"Sound {soundID} has started");
}
// Output a message on the console to stop playing the sound with the specified ID.
public override void StopSound(int soundID)
{
($"Sound {soundID} has stopped");
}
// Output a message on the console to stop all playing sounds.
public override void StopAllSounds()
{
("All sounds have stopped");
}
}
}
using UnityEngine;
namespace
{
// The NullAudio class provides an audio service implementation that does not perform any operations.
// This design allows the system to not crash when there is a lack of valid audio service, but instead can elegantly ignore all audio requests.
public class NullAudio : Audio
{
public override void PlaySound(int soundID)
{
("Do nothing - PlaySound");
}
public override void StopSound(int soundID)
{
("Do nothing - StopSound");
}
public override void StopAllSounds()
{
("Do nothing - StopAllSounds");
}
}
}*** Another implementation:
using System;
using;
using UnityEngine;
namespace
{
// Service locator class, using static context to store registered objects and allow parsing (get) these objects from anywhere.
public static class ServiceLocator
{
// Use ConcurrentDictionary to store registered service instances to ensure thread-safe and efficient search.
private static readonly ConcurrentDictionary<Type, object> _registeredServices;
// Static constructor, automatically executed before using the static member of the class for the first time or creating the first instance of the class, does not require explicit call to the static constructor
static ServiceLocator()
{
_registeredServices = new ConcurrentDictionary<Type, object>();
}
// The Register method is used to register a service instance to the service locator.
// T is a generic type parameter, and it can only be a class type.
public static bool Register<T>(T service) where T : class
{
try
{
if (_registeredServices.ContainsKey(typeof(T))))
throw new Exception($"ServiceLocator: {typeof(T)} has already been registered."); // This type has been registered and an exception is thrown
_registeredServices[typeof(T)] = service;
($"ServiceLocator: Registered {typeof(T)}");
return true;
} catch (Exception e)
{
($"ServiceLocator: Failed to register {typeof(T)}: {}");
return false;
}
}
// The Unregister method cancels a specific service instance from the service locator.
// Called if the instance is no longer needed or the object is destroyed.
public static bool Unregister<T>(T instance) where T : class
{
if (!_registeredServices.TryGetValue(typeof(T), out object obj)) return false;
if (!ReferenceEquals(obj, instance)) return false; //Compare whether two objects of reference type point to the same memory address. For reference types, this means that they are actually pointing to the same object instance
if (!_registeredServices.TryRemove(typeof(T), out _)) return false;
($"ServiceLocator: Unregistered {typeof(T)}");
return true;
}
// The Resolve method attempts to parse a service instance of the specified type.
// Returns the instance if found, otherwise returns null.
public static T Resolve<T>() where T : class
{
if (_registeredServices.TryGetValue(typeof(T), out object obj))
{
return (T)obj;
}
return null;
}
}
}
using UnityEngine;
namespace
{
public class GameController: MonoBehaviour
{
private void Start()
{
var firstService = <FirstService>();
var secondService = <SecondService>();
var thirdService = <ThirdService>();
if (firstService != null)
{
();
}
if (secondService != null)
{
();
}
if (thirdService != null)
{
();
}
(firstService);
(secondService);
(thirdService);
}
}
}
using UnityEngine;
namespace
{
public class FirstService : MonoBehaviour
{
private void Awake()
{
(this);
//(this);//Exception is thrown because it has been registered
}
private void OnDestroy()
{
(this);
}
public void SayHi()
{
("Hi, this is the " + nameof(FirstService));
}
}
}
using UnityEngine;
namespace
{
public class SecondService : MonoBehaviour
{
private void Awake()
{
(this);
}
private void OnDestroy()
{
(this);
}
public void SimpleMethod()
{
("Hey, this is just a simple method from " + nameof(SecondService));
}
}
}Bytecode mode
*** Application scenarios
- When you need to define a lot of behavior and the implementation language of the game is not appropriate, use the bytecode mode because:
- It's too low to make programming tedious or error-prone.
- Bytecode mode involves instructions that encode behavior into virtual machines, which are often very underlying operations. This underlying operation can make programming cumbersome and error-prone, as developers need to deal with a lot of details and low-level operations
- It takes a long time to iterate over it due to slow compile time or other tool issues.
- In game development, when using heavy languages like C++, every update of the code needs to be compiled. Due to the huge amount of code, the compilation time can be very long. Bytecode mode mitigates this problem by stripping mutable content out of core code, reducing the number of times it needs to be recompiled after each change
- It has too much trust. If you want to make sure that the defined behavior does not break the game, you need to sandbox it with the rest of the code base.
- The behavior defined by bytecode patterns may have too much dependence on other parts of the game. To ensure that these behaviors do not ruin the game, they need to be isolated from the rest of the code base, i.e. sandboxed. This prevents the execution of the behavior from adversely affecting other parts of the game
- It's too low to make programming tedious or error-prone.
Sandboxing is a computer security mechanism that is mainly used to isolate the program running environment to prevent malicious code or applications from damaging the system and data.***Implementation method
- Bytecode mode is implemented by defining a virtual machine class. The virtual machine takes instructions as input and executes them to provide game object behavior. It uses a stack to manage operands and performs different operations according to different instructions, such as setting health values, wisdom values, agility values, playing sounds and generating particles.
***advantage
- High density and linear execution: Bytecode is a continuous binary data block and no byte is wasted. The linear execution level is high. Except for the control flow jump, other instructions are executed sequentially.
- Underlying execution: Its execution instructions are inseparable and the simplest execution unit.
using;
using UnityEngine;
namespace BytecodePattern
{
public class Wizard
{
public int Health { get; set; } = 0;
public int Wisdom { get; set; } = 0;
public int Agility { get; set; } = 0;
}
public class GameController: MonoBehaviour
{
private Dictionary<int, Wizard> wizards = new();
private void Start()
{
(0, new Wizard());
(1, new Wizard());
var bytecode = new[] {
(int)Instruction.INST_LITERAL, 0, // Load index 0 to top of the stack
(int)Instruction.INST_LITERAL, 75, // Load the constant value 75 to the top of the stack
(int)Instruction.INST_SET_HEALTH, // Set health value
(int)Instruction.INST_LITERAL, 1, // Load index 1 to top of the stack
(int)Instruction.INST_LITERAL, 50, // Load the constant value 50 to the top of the stack
(int)Instruction.INST_SET_WISDOM, // Set the smart value
(int)Instruction.INST_LITERAL, 1, // Load index 1 to top of the stack
(int)Instruction.INST_LITERAL, 60, // Load constant value 60 to top of the stack
(int)Instruction.INST_SET_AGILITY, // Set agility value
(int)Instruction.INST_LITERAL, 0, // Load index 0 to top of the stack
(int)Instruction.INST_GET_HEALTH, // Get the health value and push it to the top of the stack
(int)Instruction.INST_LITERAL, 5, // Load the constant value 5 to the top of the stack
(int)Instruction.INST_ADD, // Perform addition
};
var vm = new VM(this);
(bytecode);
}
public void SetHealth(int wizardID, int amount)
{
wizards[wizardID].Health = amount;
($"Wizard {wizardID} sets health {amount}");
}
public void SetWisdom(int wizardID, int amount)
{
wizards[wizardID].Wisdom = amount;
($"Wizard {wizardID} sets wisdom {amount}");
}
public void SetAgility(int wizardID, int amount)
{
wizards[wizardID].Agility = amount;
($"Wizard {wizardID} sets agility {amount}");
}
public int GetHealth(int wizardID)
{
($"Wizard {wizardID} has health {wizards[wizardID].Health}");
return wizards[wizardID].Health;
}
public int GetWisdom(int wizardID)
{
($"Wizard {wizardID} has wisdom {wizards[wizardID].Wisdom}");
return wizards[wizardID].Wisdom;
}
public int GetAgility(int wizardID)
{
($"Wizard {wizardID} has agility {wizards[wizardID].Agility}");
return wizards[wizardID].Agility;
}
}
}
namespace BytecodePattern
{
// Selectable instructions in the programming language
public enum Instruction
{
//Write stats
INST_SET_HEALTH,
INST_SET_WISDOM,
INST_SET_AGILITY,
//Literal
INST_LITERAL,
//Read stats
INST_GET_HEALTH,
INST_GET_WISDOM,
INST_GET_AGILITY,
//Arithmetic
INST_ADD,
INST_SUBTRACT,
INST_MULTIPLY,
INST_DIVIDE,
INST_MODULO,
}
}
using;
using UnityEngine;
namespace BytecodePattern
{
public class VM
{
private GameController gameController;
private Stack<int> stackMachine = new(); //Will store values for later use in the switch statement
private const int MAX_STACK = 128; //The max size of the stack
public VM(GameController gameController)
{
= gameController;
}
public void Interpret(int[] bytecode)
{
();
// Read and execute the instructions
for (var i = 0; i < ; i++)
{
// Convert from int to enum
var instruction = (Instruction)bytecode[i];
switch (instruction)
{
case Instruction.INST_SET_HEALTH:
{
int amount = Pop();
int wizard = Pop();
(wizard, amount);
break;
}
case Instruction.INST_SET_WISDOM:
{
int amount = Pop();
int wizard = Pop();
(wizard, amount);
break;
}
case Instruction.INST_SET_AGILITY:
{
int amount = Pop();
int wizard = Pop();
(wizard, amount);
break;
}
case Instruction.INST_LITERAL:
{
Push(bytecode[++i]);
break;
}
case Instruction.INST_GET_HEALTH:
{
int wizard = Pop();
Push((wizard));
break;
}
case Instruction.INST_GET_WISDOM:
{
int wizard = Pop();
Push((wizard));
break;
}
case Instruction.INST_GET_AGILITY:
{
int wizard = Pop();
Push((wizard));
break;
}
case Instruction.INST_ADD:
{
int b = Pop();
int a = Pop();
Push(a + b);
break;
}
case Instruction.INST_SUBTRACT:
{
int b = Pop();
int a = Pop();
Push(a - b);
break;
}
case Instruction.INST_MULTIPLY:
{
int b = Pop();
int a = Pop();
Push(a * b);
break;
}
case Instruction.INST_DIVIDE:
{
int b = Pop();
int a = Pop();
if (b != 0)
{
Push(a /b);
}
else
{
("Division by zero error");
}
break;
}
case Instruction.INST_MODULO:
{
int b = Pop();
int a = Pop();
if (b != 0)
{
Push(a % b);
}
else
{
("Modulo by zero error");
}
break;
}
default:
{
($"The VM couldn't find the instruction {instruction} :(");
break;
}
}
}
}
private int Pop()
{
if ( == 0)
{
("The stack is empty :(");
}
return ();
}
private void Push(int number)
{
// Check for stack overflow, it's useful when someone makes a mod that tries to destroy your game
if ( + 1 > MAX_STACK)
{
("Stack overflow is not just a place where you copy and paste code!");
}
(number);
}
}
}Dirty sign
***Dirty flags Use a Boolean variable (dirty flag) to indicate whether an object or resource has been modified since the last time it was processed or updated. This flag is set to "dirty" when changing the object, and is set to "clean" when the object is processed or updated.
*** Application scenarios
- Compute and synchronize tasks: The dirty flag mode is mainly used in the two tasks of "calculation" and "synchronization". It is suitable for situations where the speed of change of the original data is much higher than the speed of use of the exported data, and incremental updates are very difficult.
- Performance optimization: Only when the performance problem is large enough, use this pattern to increase the complexity of the code. Dirty flags are applied on two tasks: "Computation" and "Synchronous".
- Avoid unnecessary work: Delay the work until necessary to avoid unnecessary work.
***Things to note
- Setting and clearing of dirty marks: Each time the state changes, the identifier must be set, and the interface to modify the data uniformly in the project. Get the previous derivation data to be saved in memory. This pattern requires the derivation data to be saved in memory in case of use. Exchange space for time.
- Avoid lag: Delayed to execute when results are needed, but when this work itself is time-consuming, it will cause lag.
using UnityEngine;
using;
namespace DirtyFlag
{
public class UnsavedChangesController : MonoBehaviour
{
// A private boolean variable used as a dirty flag to indicate whether changes have occurred since the last save.
private bool isSaved = true;
private readonly float speed = 5f;
public Button saveBtn;
public GameObject warningMessage;
private void Start()
{
(Save);
}
private void Update()
{
if (())
{
(speed * * );
// Mark as modified (not saved)
isSaved = false;
}
if (())
{
(speed * * -);
// Mark as modified (not saved)
isSaved = false;
}
if (())
{
(speed * * -);
// Mark as modified (not saved)
isSaved = false;
}
if (())
{
(speed * * );
// Mark as modified (not saved)
isSaved = false;
}
(!isSaved); // If isSaved is false, a warning message is displayed, prompting the user to have unsaved changes.
}
private void Save()
{
("Game was saved");
isSaved = true;
}
}
}Object pool
***Object Pool Pattern is a creative design pattern used to manage and reuse a set of pre-created objects. The main purpose of this pattern is to improve performance and save resources, especially for scenarios where the creation of objects is expensive and the objects are frequently used.
*** Application scenarios:
- When an application needs to create and destroy objects frequently, and the creation cost of objects is high.
- When it is necessary to restrict the use of resources, such as database connections or network connections.
- There are limited numbers of objects in memory, such as threads or database connections.
***Implementation method:
- The object pool pattern is implemented by defining an object pool manager, which is responsible for the creation, storage, allocation and recycling of objects.
- The Object Pool Manager pre-creates a certain number of objects and maintains them in the pool.
- When an object is needed, you can get an object from the pool; after use, return the object to the pool instead of destroying it.
***advantage:
- Resource reuse: Reduce the overhead of object creation and destruction, especially for objects with high cost creation.
- Performance optimization: Improve application performance by reducing the time for object creation and garbage collection.
- Management convenience: Centrally manage the life cycle of objects and flexibly control the use of resources.
[Unity three object pool implementations (simple, optimized, unityNative)](file:///D:/StudyProject/unity/GameDesignPattern_U3D_Version/Assets/ObjectPool)
A separate object pool class implementation:
Simple:
using;
using UnityEngine;
namespace
{
// Simple object pool implementation
public class BulletObjectPoolSimple: ObjectPoolBase
{
// Bullet prefabricated parts, used to instantiate new bullets
public MoveBullet bulletPrefab;
// Save the pooled bullet object
private readonly List<GameObject> bullets = new();
private void Start()
{
if (bulletPrefab == null)
{
("References required for bullet prefabs");
}
// Instantiate a new bullet and put it in a list for later use
for (var i = 0; i < INITIAL_POOL_SIZE; i++)
{
GenerateBullet();
}
}
// Generate a single new bullet and put it in the list
private void GenerateBullet()
{
GameObject newBullet = Instantiate(, transform);
(false); // Disable the bullet and prepare to be placed in the pool
(newBullet); // Add bullets to the pool
}
// Get a bullet from the pool
public GameObject GetBullet()
{
// Try to find an inactivated bullet
foreach (GameObject bullet in bullets)
{
if (!) // Check if the bullet is inactive
{
(true); // Activate the bullet
return bullet; // Return the activated bullet
}
}
// If there are no available bullets and the pool is not full, create a new bullet
if ( < MAX_POOL_SIZE)
{
GenerateBullet();
// New bullet is the last element in the list
GameObject lastBullet = bullets[^1];
(true);
return lastBullet;
}
// If the pool is full or the available bullet cannot be found, return null
return null;
}
}
}Optimized:
using;
using UnityEngine;
namespace
{
// This object pool implementation is more complex but has better performance
public class BulletObjectPoolOptimized : ObjectPoolBase
{
// Bullet prefabricated parts, used to instantiate new bullets
public MoveBulletOptimized bulletPrefab;
// Save pooled bullets
private readonly List<MoveBulletOptimized> bullets = new();
// The first available bullet is not required to traverse the list to find
// Create a linked list, all unused bullets are linked together
private MoveBulletOptimized firstAvailable;
private void Start()
{
if (bulletPrefab == null)
{
("References required for bullet prefabs");
}
// Instantiate a new bullet and put it in a list for later use
for (var i = 0; i < INITIAL_POOL_SIZE; i++)
{
GenerateBullet();
}
// Build a link list
firstAvailable = bullets[0];
// Each bullet points to the next
for (var i = 0; i < - 1; i++)
{
bullets[i].next = bullets[i + 1];
}
// The last bullet termination link list
bullets[^1].next = null;
}
// Generate a single new bullet and put it in the list
private void GenerateBullet()
{
MoveBulletOptimized newBullet = Instantiate(bulletPrefab, transform);
(false);
(newBullet);
= this; // Set the object pool reference for the bullet
}
// Add to the linked list when the bullet is deactivated
public void ConfigureDeactivatedBullet(MoveBulletOptimized deactivatedObj)
{
// Use it as the first element of the linked list to avoid checking whether the first one is null
= firstAvailable;
firstAvailable = deactivatedObj;
}
// Get a bullet
public GameObject GetBullet()
{
// Instead of traversing the list to find inactive objects, you can directly obtain the firstAvailable object
if (firstAvailable == null)
{
// If no more bullets are available, we decide whether to instantiate the new bullet based on the maximum pool size
if ( < MAX_POOL_SIZE)
{
GenerateBullet();
MoveBulletOptimized lastBullet = bullets[^1];
ConfigureDeactivatedBullet(lastBullet);
}
else
{
return null;
}
}
// Remove from the linked list
MoveBulletOptimized newBullet = firstAvailable;
firstAvailable = ;
GameObject newBulletGO = ;
(true);
return newBulletGO;
}
}
}
namespace
{
// Inherited from the BulletBase class, used to optimize bullet movement logic
public class MoveBulletOptimized : BulletBase
{
// Used to optimize the performance of the object pool and create a linked list structure
[] public MoveBulletOptimized next;
// Object pool references to notify object pool when bullets are deactivated
[] public BulletObjectPoolOptimized objectPool;
private void Update()
{
MoveBullet(); // Call base class method to move the bullet
// If the bullet exceeds the valid distance, deactivate it
if (IsBulletDead())
{
// Tell the object pool that this bullet has been deactivated
(this);
(false); // Game object that disables bullets
}
}
}
}Unity comes with:
using UnityEngine;
using;
namespace
{
// Use Unity's native object pooling system
public class BulletObjectPoolUnity : ObjectPoolBase
{
// Bullet prefabricated parts, used to instantiate new bullets
public MoveBulletUnity bulletPrefab;
// Unity's native object pool
private ObjectPool<MoveBulletUnity> allBullets;
private void Start()
{
if (bulletPrefab == null)
{
("References required for bullet prefabs");
}
// Create a new object pool
allBullets = new ObjectPool<MoveBulletUnity>(
CreatePooledItem, // Create callback function for objects in the pool
OnTakeFromPool, // Callback function when taking object from pool
OnReturnedToPool, // Callback function when returning an object to the pool
OnDestroyPoolObject, // Callback function that destroys the object when the pool reaches capacity and an object is returned
true, // Whether to enable collection checking (prevent repeated release)
INITIAL_POOL_SIZE, // Initial pool size
MAX_POOL_SIZE); // Maximum pool size
}
private void Update()
{
// Debug information: Display the current pool status
($"In pool: {}, Active: {}, Inactive: {}");
// Press K key to clear the object pool
if (())
{
(); // Clear the object pool instead of Dispose(), because Dispose() will completely destroy the pool.
}
}
// Create new items and add them to the pool
private MoveBulletUnity CreatePooledItem()
{
GameObject newBullet = Instantiate(, transform);
var moveBulletScript = <MoveBulletUnity>();
= allBullets; // Set the object pool reference of the bullet to return to the pool when the bullet dies
return moveBulletScript;
}
// Called when getting an object from the pool
private void OnTakeFromPool(MoveBulletUnity bullet)
{
(true); // Activate the bullet
}
// Called when the object is returned to the pool
private void OnReturnedToPool(MoveBulletUnity bullet)
{
(false); // Deactivate bullets
}
// If the pool capacity is full, any returned object will be destroyed
private void OnDestroyPoolObject(MoveBulletUnity bullet)
{
("Destroy pooled objects");
Destroy(); // Destroy bullets
}
// Get a bullet from the pool
public GameObject GetBullet()
{
// Get an instance from the pool. If the pool is empty, create a new instance
return ().gameObject;
}
}
}
using;
namespace
{
public class MoveBulletUnity : BulletBase
{
// Object pool reference, used to return the bullet to the pool when it is deactivated
public IObjectPool<MoveBulletUnity> objectPool;
private void Update()
{
MoveBullet(); // Move bullets
// If the bullet exceeds the valid distance, deactivate it
if (IsBulletDead())
{
// Return the instance to the pool
(this);
}
}
}
}Space partition mode
***Spatial Partition Pattern is an optimization mode that effectively manages and querys spatial data by dividing space into non-overlapping areas. This pattern is widely used in computer graphics, game development and geographic information systems, especially for optimizing operations such as collision detection, ray projection and nearest neighbor search.
*** Application scenarios
- When efficiently positioning and accessing objects in space.
- In game development, it is used to manage game objects, such as enemies, bullets, obstacles, etc.
- In computer graphics, it is used to quickly determine which objects need to be rendered.
***Implementation method
- Fixed grid: Divide the space into fixed-sized grids, each grid stores objects in that area.
- Four-fork tree: Recursively divides the space into four quadrants until a specific condition (such as the number of objects) is met.
- k-d tree: Recursively divide space on each dimension, suitable for rapid retrieval of multidimensional data.
- BSP Tree: Similar to a quad-tree, but used in three-dimensional space, often used for visibility judgment in game development.
***advantage
- Improve efficiency: Improve query efficiency by reducing the number of objects that need to be checked.
- Simplify query: Make spatial query more intuitive and easy to implement.
- Optimize performance: Improve performance by reducing the amount of calculations.
***shortcoming
- Memory usage: Additional memory may be required to store spatial data structures.
- Update overhead: When the object moves, the spatial data structure needs to be updated.
- Implement complexity: For dynamically changing spatial data, the implementation may be more complicated.
***Usage suggestions
- Used in scenarios where there are a large number of objects and frequent spatial query is required.
- Select the appropriate spatial data structure according to the application scenario, such as a fixed grid suitable for static scenarios, and a quad-tree suitable for dynamically changing scenarios.
- Pay attention to balancing memory usage and query efficiency to avoid waste of resources caused by excessive optimization.
using;
using UnityEngine;
namespace
{
// Units can fight each other, they will change the color and the color will remain for a while to observe the effect
public class GameController: MonoBehaviour
{
public Unit unitPrefab;
public Transform unitParentTrans;
private Grid grid;
private const int NUMBER_OF_UNITS = 100; // Number of units moved on the map
private HashSet<Unit> allUnits = new(); // Used to track all units in order to move them
private Material gridMaterial;
private Mesh gridMesh;
private void Start()
{
grid = new Grid();
float battlefieldWidth = Grid.NUM_CELLS * Grid.CELL_SIZE;
for (var i = 0; i < NUMBER_OF_UNITS; i++)
{
float randomX = (0f, battlefieldWidth);
float randomZ = (0f, battlefieldWidth);
var randomPos = new Vector3(randomX, 0f, randomZ);
Unit newUnit = Instantiate(unitPrefab, unitParentTrans);
// Initialize the unit, which adds it to the grid
(grid, randomPos);
// Add units to a collection of all units
(newUnit);
}
}
private void Update()
{
foreach (Unit unit in allUnits)
{
();
}
();
}
private void LateUpdate()
{
// Show grid
if (gridMaterial == null)
{
// Create grid material and set color to black
gridMaterial = new Material(("Unlit/Color"));
= ;
}
if (grid == null)
{
return;
}
if (gridMesh == null)
{
// Initialize the grid object
gridMesh = InitGridMesh();
}
// Draw the mesh
(gridMesh, , gridMaterial, 0, , 0);
}
private Mesh InitGridMesh()
{
// Generate vertex
var lineVertices = new List<Vector3>();
float battlefieldWidth = Grid.NUM_CELLS * Grid.CELL_SIZE;
Vector3 linePosX = ;
Vector3 linePosY = ;
for (var x = 0; x <= Grid.NUM_CELLS; x++)
{
(linePosX);
(linePosX + ( * battlefieldWidth));
(linePosY);
(linePosY + ( * battlefieldWidth));
linePosX += * Grid.CELL_SIZE;
linePosY += * Grid.CELL_SIZE;
}
// Generate index
var indices = new List<int>();
for (var i = 0; i < ; i++)
{
(i);
}
// Generate grid
var gridMesh = new Mesh();
(lineVertices);
(indices, , 0);
return gridMesh;
}
}
}
using UnityEngine;
namespace
{
// Grid class, dealing with combat at the same time
public class Grid
{
public const int NUM_CELLS = 6;
public const int CELL_SIZE = 6;
private Unit[] cells;
// How many units are there on the grid, which is faster than iterating through all cells and counting
public int unitCount { get; private set; }
public Grid()
{
cells = new Unit[NUM_CELLS * NUM_CELLS];
for (var x = 0; x < NUM_CELLS; x++)
{
for (var y = 0; y < NUM_CELLS; y++)
{
cells[GetIndex(x, y)] = null;
}
}
}
private int GetIndex(int x, int y)
{
return (y * NUM_CELLS) + x;
}
// Add units to grid
// This method is also used when the unit is already in the grid and moved to a new cell
public void Add(Unit newUnit, bool isNewUnit = false)
{
// Determine the grid cell where the unit is located
Vector2Int cellPos = ConvertFromWorldToCell();
// Add units to the front of the cell list
= null;
= cells[GetIndex(, )];
// Associate a cell with the unit
cells[GetIndex(, )] = newUnit;
// If there are already units in the cell, it should point to the new unit
if ( != null)
{
= newUnit;
}
if (isNewUnit)
{
unitCount += 1;
}
}
// Move units on the grid = Check if it changes the cell
// Make sure newPos is a valid location within the grid
public void Move(Unit unit, Vector3 oldPos, Vector3 newPos)
{
// View the cell it was in before
Vector2Int oldCellPos = ConvertFromWorldToCell(oldPos);
// View the cell it moves to
Vector2Int newCellPos = ConvertFromWorldToCell(newPos);
// If it does not change the cell, we have done
if ( == && == )
{
return;
}
// Unlink from the linked list of old cells
UnlinkUnit(unit);
// If the unit is the header of the linked list of the cell, remove it
if (cells[GetIndex(, )] == unit)
{
cells[GetIndex(, )] = ;
}
// Add it back to a new cell in the grid
Add(unit);
}
// Unlink the unit from the linked list
private void UnlinkUnit(Unit unit)
{
if ( != null)
{
// The previous unit should obtain a new next unit
= ;
}
if ( != null)
{
// The next unit should obtain a new previous unit
= ;
}
}
// Help method, convert Vector3 to cell position
public Vector2Int ConvertFromWorldToCell(Vector3 pos)
{
// Divide coordinates by cell size and convert from world space to cell space
// Convert to int type, convert from cell space to cell index
int cellX = ( / CELL_SIZE);
int cellY = ( / CELL_SIZE); // z instead of y, because y is the upward axis in the Unity coordinate system
var cellPos = new Vector2Int(cellX, cellY);
return cellPos;
}
// Test whether the position is a valid position (= Whether it is inside the grid)
public bool IsPosValid(Vector3 pos)
{
Vector2Int cellPos = ConvertFromWorldToCell(pos);
return is >= 0 and < NUM_CELLS && is >= 0 and < NUM_CELLS;
}
// Battle handling
public void HandleMelee()
{
for (var x = 0; x < NUM_CELLS; x++)
{
for (var y = 0; y < NUM_CELLS; y++)
{
HandleCell(x, y);
}
}
}
// Handle combat in a single cell
private void HandleCell(int x, int y)
{
Unit unit = cells[GetIndex(x, y)];
// Let each unit in this cell fight another unit once
While (unit != null)
{
// Try to fight other units in this cell
HandleUnit(unit, );
// We should also try to fight units in the surrounding 8 cells, as they may also be within the attack range.
// But we can't check all 8 cells, because in this way some units may fight twice, so we only check half (which half doesn't matter)
// We also have to check if there are surrounding cells, because the current cell may be a border
// This assumes that the attack distance is smaller than the cell size, otherwise we may need to check more cells
if (x > 0 && y > 0)
{
HandleUnit(unit, cells[GetIndex(x - 1, y - 1)]);
}
if (x > 0)
{
HandleUnit(unit, cells[GetIndex(x - 1, y - 0)]);
}
if (y > 0)
{
HandleUnit(unit, cells[GetIndex(x - 0, y - 1)]);
}
if (x > 0 && y < NUM_CELLS - 1)
{
HandleUnit(unit, cells[GetIndex(x - 1, y + 1)]);
}
unit = ;
}
}
// Handle the battle between individual units and units in the linked list
private void HandleUnit(Unit unit, Unit other)
{
While (other != null)
{
// If they are in similar positions, let them fight - use square distance because it is faster
if (( - ).sqrMagnitude < Unit.ATTACK_DISTANCE * Unit.ATTACK_DISTANCE)
{
HandleAttack(unit, other);
}
//Update other variable to point to the next unit in the linked list. This way, during the next loop iteration, the distance between the current unit and the next unit will be checked
other = ;
}
}
// Handle attacks between two units
private void HandleAttack(Unit one, Unit two)
{
// Insert combat mechanism
();
();
}
}
}
using;
using UnityEngine;
namespace
{
public class Unit : MonoBehaviour
{
public GameObject unitBody;
private Grid grid;
[] public Unit prev;
[] public Unit next;
private MeshRenderer meshRenderer;
private Color unitColor = ;
private float unitSpeed;
public const float ATTACK_DISTANCE = 1.0f;
private void Awake()
{
meshRenderer = <MeshRenderer>();
if (meshRenderer == null)
{
("MeshRenderer not found on unit body.");
}
unitSpeed = (1f, 5f);
= unitColor;
}
public void InitUnit(Grid grid, Vector3 startPos)
{
= grid ?? throw new (nameof(grid), "Grid cannot be null when initializing a unit.");
= startPos;
prev = null;
next = null;
(this, true);
= GetRandomDirection();
}
public void Move(float dt)
{
Vector3 oldPos = ;
Vector3 newPos = oldPos + ( * (unitSpeed * dt));
bool isValid = grid != null && (newPos); // Whether the new position is a valid position in the grid
if (isValid)
{
= newPos;
(this, oldPos, newPos); // Update the grid because the unit may have changed the cell
}
else
{
// Try to find a new effective direction
for (var i = 0; i < 10; i++) // Try up to 10 times
{
= GetRandomDirection();
newPos = oldPos + ( * (unitSpeed * dt));
if ((newPos))
{
= newPos;
(this, oldPos, newPos);
break;
}
}
}
}
private Quaternion GetRandomDirection()
{
return (new Vector3(0f, (0f, 360f), 0f));
}
public void StartFighting()
{
StopAllCoroutines(); // Stop all FightCoolddown coroutines
StartCoroutine(FightCoolddown());
}
private IEnumerator FightCoolddown()
{
= ;
yield return new WaitForSeconds(0.2f);
= unitColor;
}
}
}Decorative mode
***Decorator Pattern allows a pattern that dynamically adds some responsibilities (i.e., adds its extra functionality) to the object without changing the structure of the existing object. It wraps the real object by creating a wrapper object (i.e., a decorator), which dynamically adds or undos functions as needed at runtime.
*** Application scenarios
- Dynamic expansion features: Decoration mode is great when it is necessary to decide whether to add additional behavior to the object at runtime. For example, different access rights are dynamically assigned in the system according to the user's permission level.
- Flexible combination of object behavior: Decoration mode allows adding multiple behaviors to objects by combining different decorators. This allows various behavior combinations to be constructed as needed to meet different business needs.
- Avoid explosions: When inheritance is used to extend object functionality, it may cause a sharp increase in the number of classes (i.e., class explosion). The decorative pattern provides an alternative to extending functionality through combination rather than inheritance, thereby simplifying the class structure.
***advantage
- Dynamic expansion: The responsibilities of an object can be dynamically added or revoked at runtime without modifying the object's code.
- flexibility: Different decorators can be freely combined and arranged to create various customized objects.
- Simplify the class structure: By using decorative mode, you can avoid creating a large number of subclasses to support various combinations.
***shortcoming
- Decorative mode adds many subcategories, and overuse can make the program complicated.
- Not easy to debug: Debugging can become relatively difficult because the decorator pattern involves the interaction of multiple objects. Especially when the decorator chain is long, tracking the path to requests and responses can become complicated
using;
using UnityEngine;
namespace DecoratorPattern
{
// Decorator mode controller, manage order logic.
public class OrderSystemController: MonoBehaviour
{
private void Start()
{
// Order 1: Add Draco thruster to Roadster
_Car roadster = new Roadster(); // Create basic Roadster instance
roadster = new DracoThruster(roadster, 5); // Add Draco thruster to Roadster
($"You ordered: {()} and have to pay ${()}");
// Order 2: Add Draco thruster and ejection seat for Cybertruck
_Car cybertruck = new Cybertruck(); // Create basic Cybertruck instance
cybertruck = new DracoThruster(cybertruck, 2); // Add Draco thruster for Cybertruck
cybertruck = new EjectionSeat(cybertruck, 1); // Add ejection seat for Cybertruck
($"You ordered: {()} and have to pay ${()}");
// Order 3: Order Model S No additional accessories added
_Car modelS = new ModelS(); // Create basic Model S instance
($"You ordered: {()} and have to pay ${()}");
// After a period of simulation, some prices have changed.
-= 20;
-= 100f;
+= 30f;
("Price changes!");
// Print out the updated order price
($"You ordered: {()} and have to pay ${()}");
($"You ordered: {()} and have to pay ${()}");
($"You ordered: {()} and have to pay ${()}");
}
}
}
namespace DecoratorPattern
{
// Price list class is used to store the price of the vehicle's basic price and the price of additional accessories.
public static class PriceList
{
// Basic model price
public static float cybertruck = 150f; // Basic price of Cybertruck
public static float modelS = 200f; // Basic price of Model S
public static float roadster = 350f; // Basic price of Roadster
// Extra accessories price
public static float dracoThruster = 20f; // Price of Draco thruster
public static float ejectionSeat = 200f; // Price of ejection seat
}
}
namespace DecoratorPattern
{
// Abstract class _Car is the basis of all concrete car classes, defining methods for obtaining descriptions and calculating costs.
public abstract class _Car
{
protected string description; // Store the car description information
// Get the description information of the car, which is implemented by the subclass.
public abstract string GetDescription();
// Calculate the cost of the car, implemented by subclasses.
public abstract float Cost();
}
}
namespace DecoratorPattern
{
public class Roadster: _Car
{
public Roadster()
{
description = "Roadster";
}
public override string GetDescription()
{
return description;
}
public override float Cost()
{
return ;
}
}
}
namespace DecoratorPattern
{
public class Cybertruck : _Car
{
public Cybertruck()
{
description = "Cybertruck";
}
public override string GetDescription()
{
return description;
}
public override float Cost()
{
return ;
}
}
}
namespace DecoratorPattern
{
public class ModelS: _Car
{
public ModelS()
{
description = "Model S";
}
public override string GetDescription()
{
return description;
}
public override float Cost()
{
return ;
}
}
}
namespace
{
// Abstract class _CarExtras is used as the basic class for all auto parts, and it inherits from the _Car class
// This class allows us to create specific decorators to dynamically add behavior to car objects
public abstract class _CarExtras : _Car
{
protected int howMany; // Number of accessories
protected _Car prevCarPart; // Reference to the decorated car object
// The constructor receives a _Car object to be decorated and the number of accessories
public _CarExtras(_Car prevCarPart, int howMany)
{
= prevCarPart;
= howMany;
}
}
}
namespace
{
// The specific decorator class DracoThruster is inherited from the _CarExtras class, used to add Draco thrusters to cars
public class DracoThruster : _CarExtras
{
public DracoThruster(_Car prevCarPart, int howMany) : base(prevCarPart, howMany) { }
public override string GetDescription()
{
return $"{()}, {howMany} Draco Thruster";
}
public override float Cost()
{
return ( * howMany) + ();
}
}
}
namespace
{
// The specific decorator class EjectionSeat inherits from the _CarExtras class, which is used to add ejection seats to cars.
public class EjectionSeat: _CarExtras
{
public EjectionSeat(_Car prevCarPart, int howMany) : base(prevCarPart, howMany) { }
public override string GetDescription()
{
return $"{()}, {howMany} Ejection Seat";
}
public override float Cost()
{
return ( * howMany) + ();
}
}
}Factory model
*** Factory Pattern is a creative design pattern that provides the best way to create objects. In factory mode, we do not expose the creation logic to the client when creating an object, and we point to the newly created object by using a common interface. The factory model can be divided into the following types:
-
Simple Factory Pattern
The simple factory pattern is not a formal design pattern, it simply creates objects through a factory class, but does not involve interfaces or abstract classes. It usually contains a factory method that returns different object instances according to the input parameters. -
Factory Method Pattern
The factory method pattern defines an interface to create objects, but allows subclasses to change the instantiated type. The factory method allows the class to defer instantiation to a subclass. -
Abstract Factory Pattern
The abstract factory pattern provides an interface to create a series of related or interdependent objects without specifying their concrete classes. The abstract factory pattern emphasizes the creation of a series of related objects rather than a single object.
*** Application scenarios
- When a class does not know the class of the object it must create.
- When a class wants its subclass to specify the object it creates.
- When creating complex objects, it is necessary to ensure consistency or reusability of objects.
***advantage
- Single responsibility principle: Factory mode separates the creation and use of objects, reducing the complexity of the system.
- Opening and closing principle: The system can introduce new products without modifying existing code, just introduce new specific factories.
- Flexibility and scalability: The factory model improves the flexibility and scalability of the system, and different products can be obtained by configuring different factories.
*Auto factory: The previous decorative mode code was used
using;
using DecoratorPattern;
using UnityEngine;
namespace
{
// Showcase the combination of factory mode and decorator mode to create car objects in different configurations.
public class CarFactoryController: MonoBehaviour
{
// The Start method is one of Unity's lifecycle methods and is called immediately after the scene is loaded and initialized.
private void Start()
{
// Create two different factory instances representing the US factory and the Chinese factory respectively.
_CarFactory US_Factory = new USFactory(); // US factory instance
_CarFactory China_Factory = new ChinaFactory(); // China factory instance
// Use a U.S. factory to make a car with Model S model and add EjectionSeat accessories.
_Car order1 = US_Factory.ManufactureCar(new CarInfo(, new List<CarExtras> { , }, 1));
FinalizeOrder(order1); // Process completed orders
// Made a Cybertruck model car with a factory in China and add DracoThruster accessories.
_Car order2 = China_Factory.ManufactureCar(
new CarInfo(, new List<CarExtras> { , }, 1));
FinalizeOrder(order2); // Process completed orders
// Use a U.S. factory-made Roadster model car again and add multiple DracoThruster accessories
_Car order3 = US_Factory.ManufactureCar(new CarInfo(, new List<CarExtras> { , }, 2));
FinalizeOrder(order3); // Process completed orders
}
// FinalizeOrder method is used to process completed orders and print out the car description and price information.
private void FinalizeOrder(_Car finishedCar)
{
(finishedCar == null // If the finished car is empty, it means that the order cannot be manufactured
? $"Sorry but we can't manufacture your order, please try again!" // Output error message
: $"Your order: {()} is ready for delivery as soon as you pay ${()}"); // Output the car description and the amount to be paid
}
}
public struct CarInfo
{
public CarModels Model;
public List<CarExtras> Extras;
public int ExtrasNumber;
public CarInfo(CarModels model, List<CarExtras> extras, int number)
{
Model = model;
Extras = extras;
ExtrasNumber = number;
}
}
// The CarModels enumeration defines available car models
public enum CarModels
{
ModelS,
Roadster,
Cybertruck,
}
// The CarExtras enumeration defines optional auto accessories
public enum CarExtras
{
EjectionSeat, // Ejection seat
DracoThruster, // Thruster
}
}
using DecoratorPattern;
namespace
{
// Abstract factory class defines a method to manufacture cars
public abstract class _CarFactory
{
// This method is called the "factory method" which is used to create a specific type of car
public abstract _Car ManufactureCar(CarInfo carInfo);
}
}
using;
using DecoratorPattern;
using;
using UnityEngine;
namespace
{
public class ChinaFactory: _CarFactory
{
public override _Car ManufactureCar(CarInfo carInfo)
{
_Car car = null;
// Create the corresponding car instance based on the incoming model parameters.
if ( == )
{
car = new ModelS();
}
else if ( == )
{
car = new Roadster();
}
// Note: The Cybertruck model is not processed here, so it cannot be produced by a Chinese factory!
if (car == null)
{
("Sorry but this factory can't manufacture this model :(");
return car;
}
// Add additional configuration items to the car.
foreach (CarExtras carExtra in )
{
// Create the corresponding decorator according to the configuration item type and apply it to the car.
if (carExtra == )
{
car = new DracoThruster(car, );
}
else if (carExtra == )
{
car = new EjectionSeat(car, );
}
else
{
("Sorry but this factory can't add this car extra :(");
}
}
return car;
}
}
}
using;
using DecoratorPattern;
using;
using UnityEngine;
namespace
{
public class USFactory: _CarFactory
{
public override _Car ManufactureCar(CarInfo carInfo)
{
_Car car = null;
if ( == )
{
car = new Cybertruck();
}
else if ( == )
{
car = new ModelS();
}
else if ( == )
{
car = new Roadster();
}
if (car == null)
{
("Sorry but this factory can't manufacture this model :(");
return car;
}
foreach (CarExtras carExtra in )
{
if (carExtra == )
{
car = new DracoThruster(car, );
}
else if (carExtra == )
{
("Sorry but this factory can't add this car extra :(");
}
else
{
("Sorry but this factory can't add this car extra :(");
}
}
return car;
}
}
}*Sound Factory: Factory Method Mode
using UnityEngine;
namespace
{
// The SoundFactoryController class is a controller used to manage sound systems.
// It uses factory method mode to create different types of sound system instances.
public class SoundFactoryController: MonoBehaviour
{
private void Start()
{
// Create a software-implemented sound system and play a sound with ID 1.
ISoundSystem soundSystemSoftware = ();
(1);
// Create a hardware-implemented sound system and play sounds with ID 2.
ISoundSystem soundSystemHardware = ();
(2);
// Create a different sound system and play a sound with ID 3.
ISoundSystem soundSystemOther = ();
(3);
// Stop playing all previously started sounds.
(1);
(2);
(3);
}
}
}
namespace
{
// The SoundSystemFactory class is responsible for creating specific sound system objects.
public class SoundSystemFactory
{
// The SoundSystemType enumeration defines different types of sound systems that can be created.
public enum SoundSystemType
{
SoundSoftware, // Software Sound System
SoundHardware, // Hardware sound system
SoundSomethingElse // Other types of sound systems
}
// CreateSoundSystem is a static method that returns a new sound system instance based on the provided type parameters.
public static ISoundSystem CreateSoundSystem(SoundSystemType type)
{
ISoundSystem soundSystem = null; // Initialize to empty
// Select and create the corresponding sound system instance according to the type parameters passed in.
switch (type)
{
case:
soundSystem = new SoundSystemSoftware(); // If it is a software sound system, create a new instance of the class.
break;
case:
soundSystem = new SoundSystemHardware(); // If it is a hardware sound system, create a new instance of the class.
break;
case:
soundSystem = new SoundSystemOther(); // If it is another type of sound system, create a new instance of the class.
break;
default:
// Return null if the type does not match any predefined options.
// In this case, an exception may need to be thrown or an error case is handled.
break;
}
return soundSystem; // Return the created sound system instance
}
}
}
namespace
{
// Define the ISoundSystem interface, declaring the methods that all specific sound systems must implement.
public interface ISoundSystem
{
bool PlaySound(int soundId);
bool StopSound(int soundId);
}
}
using UnityEngine;
namespace
{
public class SoundSystemSoftware: ISoundSystem
{
public bool PlaySound(int soundId)
{
($"Played the sound with id {soundId} on the software");
return true; // Assume that the sound is always played successfully.
}
public bool StopSound(int soundId)
{
($"Stopped the sound with id {soundId} on the software");
return true; // Assume that the sound is always stopped successfully.
}
}
}
using UnityEngine;
namespace
{
public class SoundSystemOther : ISoundSystem
{
public bool PlaySound(int soundId)
{
($"Played the sound with id {soundId} on some other system");
return true;
}
public bool StopSound(int soundId)
{
($"Stopped the sound with id {soundId} on some other system");
return true;
}
}
}
using UnityEngine;
namespace
{
public class SoundSystemHardware: ISoundSystem
{
public bool PlaySound(int soundId)
{
($"Played the sound with id {soundId} on the hardware");
return true;
}
public bool StopSound(int soundId)
{
($"Stopped the sound with id {soundId} on the hardware");
return true;
}
}
}Implement abstract factory github link using abstract class
*UI Factory: Abstract Factory Pattern
using UnityEngine;
namespace
{
public class UIFactoryController:MonoBehaviour
{
private IUIButton _button;
private IUITextField _textField;
private void Start()
{
// Choose the factory you want to use
IUIFactory factory = GetSelectedFactory();
// Create UI elements with selected factory
_button = ();
_textField = ();
// Render UI elements
_button.Render();
_textField.Render();
}
private IUIFactory GetSelectedFactory()
{
// Here you can choose different factories according to certain conditions
return new ModernIUIFactory(); // or new RetroGuiFactory(); }
}
}
namespace
{
public interface IUIButton
{
void Render();
}
public interface IUITextField
{
void Render();
}
}
using UnityEngine;
namespace
{
public class ModernUIButton : MonoBehaviour, IUIButton
{
public void Render()
{
("Rendering a modern button.");
}
}
}
using UnityEngine;
namespace
{
public class ModernUITextField : MonoBehaviour, IUITextField
{
public void Render()
{
("Rendering a modern text field.");
}
}
}
using UnityEngine;
namespace
{
public class RetroUIButton : MonoBehaviour, IUIButton
{
public void Render()
{
("Rendering a retro button.");
}
}
}
using UnityEngine;
namespace
{
public class RetroUITextField : MonoBehaviour, IUITextField
{
public void Render()
{
("Rendering a retro text field.");
}
}
}
namespace
{
public interface IUIFactory
{
IUIButton CreateButton();
IUITextField CreateTextField();
}
}
using UnityEngine;
namespace
{
public class ModernIUIFactory : IUIFactory
{
public IUIButton CreateButton()
{
return new GameObject("ModernButton").AddComponent<ModernUIButton>();
}
public IUITextField CreateTextField()
{
return new GameObject("ModernTextField").AddComponent<ModernUITextField>();
}
}
}
using UnityEngine;
namespace
{
public class RetroIUIFactory : IUIFactory
{
public IUIButton CreateButton()
{
return new GameObject("RetroButton").AddComponent<RetroUIButton>();
}
public IUITextField CreateTextField()
{
return new GameObject("RetroTextField").AddComponent<RetroUITextField>();
}
}
}Appearance mode
***Facade Pattern is a structural design pattern, and its core idea is to provide a consistent interface for a set of interfaces in the subsystem. This pattern simplifies the interaction between the client and the subsystem by introducing a look class, thus hiding the complexity of the system.
***definition
Appearance mode defines a high-level interface, making subsystems easier to use. It allows clients to communicate with the system through a unified entry point without the need to understand the specific details and complexity within the system.
***Applicable scenarios
- Appearance mode is a powerful tool when it is necessary to simplify the use and understanding of complex systems. It can hide the complexity of the system behind it and provide a concise interface to the client.
- When a system consists of multiple subsystems and the client needs to interact with these subsystems through different interfaces, the appearance mode can integrate these interactions into a unified interface to facilitate the use of the client.
***advantage
- Simplifies the call process without having to understand deep into the subsystem to prevent risks.
- Reduce system dependence and loose coupling.
- Better divide access levels.
- Comply with the Dimitese law, that is, the principle of least knowledge.
***shortcoming
- Increasing subsystems and expanding subsystem behaviors can easily introduce risks.
- Not in line with the principle of opening and closing.
***Implementation method
- Create Appearance Class: Define a appearance class as an intermediary between the client and the subsystem
- Encapsulation subsystem operation: Appearance class encapsulates complex subsystem operations into simple methods
using UnityEngine;
namespace FacadePattern
{
//Get random numbers through the RandomNumberFacade class without directly interacting with the specific random number generator
public class RandomNumbersController: MonoBehaviour
{
private void Start()
{
// Initialize the seed of the random number generator
(0);
("Float: 0 -> 1");
// Print 5 random floating point numbers between 0 and 1
for (var i = 0; i < 5; i++)
{
(RandomNumberFacade.GetRandom01());
}
("Float: -1 -> 2");
// Print 10 random floating point numbers between 1 and 2
for (var i = 0; i < 10; i++)
{
((-1f, 2f));
}
("Integer: -10 -> 20");
// Print 10 random integers between 10 and 20
for (var i = 0; i < 10; i++)
{
((-10, 21));
}
}
}
}
namespace FacadePattern
{
// Appearance role, which provides a simplified interface for the client to generate random numbers
public class RandomNumberFacade
{
private static IRandomNumberGenerator rng;
static RandomNumberFacade()
{
// Different random number generators can be selected
rng = new RandomNumbersUnity();
//rng = new RandomNumbersSystem();
}
// Initialize the seed of the random number generator
public static void InitSeed(int seed)
{
(seed);
}
// Get random floating point numbers between 0 and 1
public static float GetRandom01()
{
return rng.GetRandom01();
}
// Get random floating point numbers in the specified range [min, max]
public static float GetRandom(float min, float max)
{
return (min, max);
}
// Get random integers in the specified range [min, max)
public static int GetRandom(int min, int max)
{
return (min, max);
}
}
}
namespace FacadePattern
{
public interface IRandomNumberGenerator
{
// Initialize the seed of the random number generator
void InitSeed(int seed);
// Get random floating point numbers between 0 and 1
float GetRandom01();
// Get random floating point numbers in the specified range [min, max]
float GetRandom(float min, float max);
// Get random integers in the specified range [min, max)
int GetRandom(int min, int max);
}
}
using UnityEngine;
namespace FacadePattern
{
public class RandomNumbersUnity: IRandomNumberGenerator
{
public void InitSeed(int seed)
{
(seed);
}
public float GetRandom01()
{
return (0f, 1f);
}
public float GetRandom(float min, float max)
{
return (min, max);
}
public int GetRandom(int min, int max)
{
return (min, max);
}
}
}
namespace FacadePattern
{
public class RandomNumbersNative : IRandomNumberGenerator
{
private rng = new();
public void InitSeed(int seed)
{
rng = new (seed);
}
public float GetRandom01()
{
return (float)();
}
public float GetRandom(float min, float max)
{
return (float)((() * (max - min)) + min);
}
public int GetRandom(int min, int max)
{
return (min, max);
}
}
}Template method pattern
***Template Method Pattern is a behavioral design pattern that defines an algorithm skeleton in an operation and delays the implementation of some steps to a subclass. This pattern allows subclasses to redefine certain specific steps of the algorithm without changing the structure of the algorithm.
***definition
The template method pattern defines the skeleton of an algorithm and allows subclasses to provide implementations for one or more steps. This allows subclasses to redefine certain steps of the algorithm without changing the algorithm structure.
***The main problem solved
The template method pattern solves the problem of repeatedly implementing the same method in multiple subclasses, avoiding code duplication by abstracting common methods into parent classes.
***Usage scenarios
- When there are some common methods that can be shared among multiple subclasses.
- The overall steps of the algorithm are very fixed, but some parts of it are prone to change.
***Implementation method
- Define abstract parent class: Contains template methods and some abstract methods or specific methods.
- Implement subclasses: Inherit the abstract parent class and implement abstract methods without changing the algorithm structure.
***Key Code
- Template method: Define in the abstract parent class, call abstract methods and concrete methods.
- Abstract Methods: Implemented by a subclass, representing the variable part of the algorithm.
- Specific methods: Implemented in the abstract parent class, representing the invariant part of the algorithm.
***advantage
- Encapsulation unchanged part: The invariant part of the algorithm is encapsulated in the parent class.
- Expand variable parts: Subclasses can extend or modify variable parts of an algorithm.
- Extract public code: Reduce code duplication and facilitate maintenance.
***shortcoming
- Increase complexity: The number of classes increases, increasing system complexity.
- Inheritance disadvantages: The template method is mainly implemented through inheritance, and the inheritance relationship itself has its own shortcomings
using;
using;
using UnityEngine;
namespace TemplateMethodPattern
{
// AssembleCarsController is the control class, which is responsible for initializing the assembly line and starting to assemble different types of cars.
public class AssembleCarsController : MonoBehaviour
{
private void Start()
{
// Initialize two assembly lines: one for Cybertruck and the other for Model S
var cybertruck = new AssembleCybertruck();
var modelS = new AssembleModelS();
// Assemble the car according to the order, including selecting a specific additional configuration (CarExtras)
(new List<CarExtra>() { new(, 1), new(, 1), });
(new List<CarExtra>() { new(, 1), new(, 2), });
// Assemble Model S without additional configuration
(null);
}
}
}
using;
using;
using UnityEngine;
namespace TemplateMethodPattern
{
// _AssemblyLine is an abstract class that defines the basic framework and steps of automotive assembly.
public abstract class _AssemblyLine
{
// The AssembleCar method is a template method that defines the steps to assemble a car. Subclasses cannot override this method.
public void AssembleCar(List<CarExtra> carExtras)
{
InitAssemblyProcess(); // Initialize the assembly process
if (!CanManufactureCar()) // Check if a car can be built
return;
GetCarBase(); // Get the car chassis
GetCarBattery(); // Get the battery
GetCarBody(); // Get the body
CoffeeBreak(); // Workers' rest time
GetWheels(); // Get the wheel
GetCarExtras(carExtras); // Get additional configuration
}
// CoffeeBreak and InitAssemblyProcess are specific methods that implement behavior shared by all subclasses.
protected void CoffeeBreak()
{
("Take a coffee break");
}
protected void InitAssemblyProcess()
{
("Init" + GetType().Name);
}
// The GetCarExtras method obtains the corresponding accessories based on the provided additional configuration list.
protected void GetCarExtras(List<CarExtra> carExtras)
{
if (carExtras == null) // If there is no additional configuration, the prompt message is output
{
("This car comes with no extras");
return;
}
foreach (CarExtra extra in carExtras) // traverse the additional configuration list and process each configuration item separately
{
switch ()
{
case:
($"Get {} Draco Thruster");
break;
case:
($"Get {} Ejection Seat");
break;
}
}
}
// Abstract method, implemented by subclasses to provide specific implementation details.
protected abstract void GetCarBody();
protected abstract void GetCarBase();
protected abstract void GetCarBattery();
protected abstract void GetWheels();
// CanManufactureCar is a hook method that allows subclasses to decide whether a car can be built.
protected virtual bool CanManufactureCar()
{
return true;
}
}
}
using UnityEngine;
namespace TemplateMethodPattern
{
public class AssembleModelS: _AssemblyLine
{
// Implement abstract methods and provide specific implementations for Model S.
protected override void GetCarBase()
{
("Get Model S base");
}
protected override void GetCarBattery()
{
("Get Model S battery");
}
protected override void GetCarBody()
{
("Get Model S body");
}
protected override void GetWheels()
{
("Get Model S wheels");
}
}
}
using UnityEngine;
namespace TemplateMethodPattern
{
public class AssembleCybertruck : _AssemblyLine
{
// Implement abstract methods and provide specific implementations for Cybertruck.
protected override void GetCarBase()
{
("Get Cybertruck base");
}
protected override void GetCarBattery()
{
("Get Cybertruck battery");
}
protected override void GetCarBody()
{
("Get Cybertruck body");
}
protected override void GetWheels()
{
("Get Cybertruck wheels");
}
// Rewrite the CanManufactureCar method and return false to indicate that Cybertruck cannot be manufactured.
protected override bool CanManufactureCar()
{
("Sorry but the Cybertruck is still a prototype so we can't manufacturing it!");
return false;
}
}
}Memo mode
***Memento Pattern is a behavioral design pattern that allows the object's internal state to be captured and saved without destroying the object's encapsulation, so as to restore to its previous state in the future. This mode is particularly suitable for the function of implementing Undo operations.
***definition
- Originator: Create and restore the object of the memo, responsible for defining which states belong to the backup scope.
- Memento: Stores snapshots of the initiator's internal state and prevents other objects from accessing the memo. Memos are usually only accessible to the sponsor.
- Manager (Caretaker): Responsible for saving and restoring memos, but cannot check or operate the contents of memos.
*** Application scenarios
- Text editor: Implements undo and redo functions.
- Game Development: Save the game progress and allow players to start over if they fail.
- Database transaction: Saves the status before the transaction begins so that it rolls back when the transaction fails.
- Graphic interface: Save the canvas or drawing state so that the user can undo previous drawing operations.
***Implementation method
- The Originator class, which is responsible for maintaining internal state and can create memorandum objects and restore state from memorandum objects.
- Memento class, used to store the initiator's internal state. The memo class should provide methods to get and set state.
- The Caretaker class, which manages memo objects. Usually, administrators maintain a memo list that can add and retrieve memo objects.
- Add methods in Initiating Humans to create and restore state from the Memorandum object.
***advantage
- Provides a mechanism to restore states, conveniently restore data to a certain historical state.
- Implements the encapsulation of internal states, and other objects cannot access these state information except for the initiator that created it.
- Simplified the initiator. The initiator does not need to manage and save various backups of its internal state. All state information is saved in a memo and managed by the administrator.
*Command mode is an object-oriented implementation of the method, and memo mode is an object-oriented implementation of the storage state*using UnityEngine;
namespace MementoPattern
{
public class MementoController : MonoBehaviour
{
public Apple apple;
private MementoCaretaker _mc;
private void Start()
{
_mc = new MementoCaretaker();
var builder = new AppleBuilder("Apple"); // Create an AppleBuilder instance
apple = (); // Use AppleBuilder to generate Apple instance
_mc.AddMemento(()); // Save the initial state of Apple
}
private void Update()
{
if (())
{
_mc.AddMemento(());
($"Storage successfully, current queue number {_mc.GetMementoCount()}");
}
int offset = -1;
if ((KeyCode.Alpha0))
{
offset = 0;
}
else if ((KeyCode.Alpha1))
{
offset = 1;
}
else if ((KeyCode.Alpha2))
{
offset = 2;
}
else if ((KeyCode.Alpha3))
{
offset = 3;
}
else if ((KeyCode.Alpha4))
{
offset = 4;
}
else if ((KeyCode.Alpha5))
{
offset = 5;
}
else if ((KeyCode.Alpha6))
{
offset = 6;
}
else if ((KeyCode.Alpha7))
{
offset = 7;
}
else if ((KeyCode.Alpha8))
{
offset = 8;
}
else if ((KeyCode.Alpha9))
{
offset = 9;
}
// If a valid offset value is set, try to fall back to the specified historical state
if (offset == -1) return;
int idx = _mc.GetMementoCount() - offset;
AppleMemento memento = _mc.GetMemento(idx - 1);
if (null != memento)
{
($"Back {offset} step to {idx}");
(memento); // Restore to the specified memento state
}
else
{
("No Memento");
}
}
}
// Provides a method to build Apple objects
public class AppleBuilder
{
private string prefab;
/// <summary>
/// Constructor, receives the prefabricated body name
/// </summary>
/// <param name="prefab">Prefab Resources</param>
public AppleBuilder(string prefab)
{
= prefab;
}
// Load the prefab from the resource and instantiate a new Apple object
public Apple Generate()
{
GameObject appleObj = (<GameObject>(prefab));
var apple = <Apple>();
return apple;
}
}
}
using;
namespace MementoPattern
{
// Manage multiple AppleMemento objects and maintain a memo list
public class MementoCaretaker
{
private readonly List<AppleMemento> _mementoList = new();
//Add a new memo to the list
internal void AddMemento(AppleMemento memento)
{
_mementoList.Add(memento);
}
//Get memorandum based on index
internal AppleMemento GetMemento(int index)
{
if (index >= 0 && index < _mementoList.Count)
{
return _mementoList[index];
}
return null;
}
//Return the number of elements in the memo list
internal int GetMementoCount()
{
return _mementoList.Count;
}
}
}
using UnityEngine;
namespace MementoPattern
{
// As a snapshot of Apple object state, the position, zoom and rotation of a specific moment are saved
internal class AppleMemento
{
private readonly Vector3 _startPos;
private readonly Vector3 _scale;
private readonly Quaternion _rotation;
//Receive an Apple object and save its status
public AppleMemento(Apple apple)
{
_startPos = ();
_scale = ();
_rotation = ();
}
// Get the saved location
public Vector3 GetStartPos()
{
return _startPos;
}
// Get saved zoom
public Vector3 GetScale()
{
return _scale;
}
// Get saved rotation
public Quaternion GetRotation()
{
return _rotation;
}
}
}
using UnityEngine;
namespace MementoPattern
{
public class Apple: MonoBehaviour
{
private float speed = 5f;
private float rotationSpeed = 30f;
private void Start()
{
GetComponent<Renderer>(). = ;
}
private void Update()
{
if (() || ())
{
HandleRotation();
}
else
{
HandleMovement();
}
}
private void HandleMovement()
{
// Initialize horizontal and vertical movement amounts to 0
var horizontal = 0f;
var vertical = 0f;
if (())
{
horizontal -= 1;
}
if (())
{
horizontal += 1;
}
if (())
{
vertical += 1;
}
if (())
{
vertical -= 1;
}
Vector3 movement = new Vector3(horizontal, vertical, 0) * (speed * );
(movement, );
}
private void HandleRotation()
{
// Initialize horizontal and vertical rotation amounts to 0
var horizontal = 0f;
var vertical = 0f;
if (())
{
horizontal -= 1;
}
if (())
{
horizontal += 1;
}
if (())
{
vertical += 1;
}
if (())
{
vertical -= 1;
}
// Calculate the rotation vector
Vector3 rotation = new Vector3(vertical, 0, horizontal) * (rotationSpeed * );
// Update the rotation of the object
(rotation, );
}
// Get the current location
public Vector3 GetStartPos()
{
return ;
}
// Get the current zoom
public Vector3 GetScale()
{
return ;
}
// Get the current rotation
public Quaternion GetRotation()
{
return ;
}
// Create a memo containing the current status
internal AppleMemento CreateMemento()
{
return new AppleMemento(this);
}
//Restore status based on the provided memo
internal void Restore(AppleMemento memento)
{
= ();
= ();
= ();
}
}
}Policy Mode
***Strategy Pattern is a behavioral design pattern that allows you to change the behavior of objects at runtime. The policy pattern defines a series of algorithms, encapsulates them one by one, and makes them replace each other. This pattern makes the algorithm change independent of the client using the algorithm.
***definition
- The core of the strategy model is to define the algorithm family and encapsulate them separately so that they can be replaced by each other. The strategy model allows changes in the algorithm to not affect customers who use the algorithm. In other words, the policy pattern makes it possible for dynamic selection algorithms.
***Main role
- Strategy: Defines the common interface for all supported algorithms.
- Concrete Strategy: Specific algorithms for implementing policy interfaces.
- Context: A class that uses a policy that can dynamically change its behavior.
*** Application scenarios
- Scenarios where algorithms or behaviors need to be selected at runtime.
- There is a need for encapsulation algorithms to make the algorithms interchangeable scenarios.
- It is necessary to avoid using multiple conditions (if-else or switch-case) statements to select the algorithm scenario.
***Implementation steps
- Defines the policy interface and declares the method to perform operations.
- Create specific policy classes, implement policy interfaces, and provide different algorithm implementations.
- Defines the context class, holding a reference to a policy object.
- As needed, client code can change policy references held by the context at runtime.
***advantage
- The algorithm can vary independently of the customer using it.
- The policy pattern makes the algorithm change independent of the client using the algorithm.
- New algorithms can be easily added.
- Make the algorithm replaceable and composable.
using UnityEngine;
namespace StrategyPattern
{
public class StrategyController: MonoBehaviour
{
private void Start()
{
// Define the start position and end position
Vector3 startPos = ;
var endPos = new Vector3(10, 0, 10);
// Create a flight NPC and set its navigation planner as the flight path planner
var theFlyNPC = new NPC();
(new FlyNavPlanner());
foreach (Vector3 navPath in (startPos, endPos))
{
(The path planned by $"flyNpc is: {navPath}");
}
// Create a swimming NPC and set its navigation planner as a swimming path planner
var theSwimNPC = new NPC();
(new SwimNavPlanner());
foreach (Vector3 navPath in (startPos, endPos))
{
(The path planned by $"swimNpc is: {navPath}");
}
// Create a jump NPC and set its navigation planner as a jump path planner
var theJumpNPC = new NPC();
(new JumpNavPlanner());
foreach (Vector3 navPath in (startPos, endPos))
{
(The path planned by $"jumpNpc is: {navPath}");
}
// Create a linear moving NPC and set its navigation planner as a linear path planner
var theStraightNPC = new NPC();
(new StraightNavPlanner());
foreach (Vector3 navPath in (startPos, endPos))
{
(The path planned by $"straightNpc is: {navPath}");
}
var pos = new Vector3(1, 5, 1);
// Create a swimming-specific NPC and set a special sampling strategy for it
var swimNPC2 = new LambdaNPC();
(_ => new Vector3(, 0, )); // Force the Y axis to be 0 to simulate swimming behavior
// Test the sampling strategy of swimming NPCs
pos = new Vector3(1, 5, 1);
($"swimNPC2 samplePos {pos}->{(pos)}");
pos = new Vector3(2, 5, 2);
($"swimNPC2 samplePos {pos}->{(pos)}");
}
}
}
using UnityEngine;
namespace StrategyPattern
{
public class NPC
{
private AbstractNavPlanner _navPlanner;
// Set up the NPC navigation planner
public void SetNavPlanner(AbstractNavPlanner navPlanner)
{
_navPlanner = navPlanner;
}
// Obtain the navigation path from startPos to endPos according to the current navigation planner
public Vector3[] GetNavPath(Vector3 startPos, Vector3 endPos)
{
return _navPlanner.GetNavPath(startPos, endPos);
}
}
}
using System;
using UnityEngine;
namespace StrategyPattern
{
// LambdaNPC class, allowing setting sampling policies through Lambda expressions
public class LambdaNPC
{
private Func<Vector3, Vector3> _sampleStrategy; // Sampling Strategy
// Set the sampling strategy of LambdaNPC
public void SetSampleStrategy(Func<Vector3, Vector3> sampleStrategy)
{
_sampleStrategy = sampleStrategy;
}
// Apply the sampling policy to the specified location
public Vector3 SamplePos(Vector3 pos)
{
return _sampleStrategy(pos);
}
}
}
using UnityEngine;
namespace StrategyPattern
{
// Abstract navigation planner class, all specific navigation planners inherit from this class
public abstract class AbstractNavPlanner
{
// Get the navigation path from startPos to endPos
public abstract Vector3[] GetNavPath(Vector3 startPos, Vector3 endPos);
}
}
using UnityEngine;
namespace StrategyPattern
{
public class FlyNavPlanner : AbstractNavPlanner
{
public override Vector3[] GetNavPath(Vector3 startPos, Vector3 endPos)
{
// Returns a starting point containing、Paths to the middle high and end points
return new[] { startPos, startPos + (endPos / 2) + ( * 5), endPos, };
}
}
}
using UnityEngine;
namespace StrategyPattern
{
public class SwimNavPlanner : AbstractNavPlanner
{
public override Vector3[] GetNavPath(Vector3 startPos, Vector3 endPos)
{
// Return a path containing the starting point, a certain point in the water and the end point
return new[] { startPos, startPos + (endPos / 2) + ( * 5), endPos, };
}
}
}
using UnityEngine;
namespace StrategyPattern
{
public class StraightNavPlanner : AbstractNavPlanner
{
public override Vector3[] GetNavPath(Vector3 startPos, Vector3 endPos)
{
// Return a simple straight line path, including only the starting point and the end point
return new[] { startPos, endPos, };
}
}
}
using UnityEngine;
namespace StrategyPattern
{
public class JumpNavPlanner : AbstractNavPlanner
{
public override Vector3[] GetNavPath(Vector3 startPos, Vector3 endPos)
{
// Return a path containing the starting point, jumping high point and end point
return new[] { startPos, startPos + (endPos / 2) + , endPos, };
}
}
}+ *Reusable algorithm, using object-oriented version of policy patterns*
+ *No reusable algorithm, using Lambda expression version policy pattern*Builder Mode
***Builder Pattern is a creative design pattern that allows you to build a complex object in steps. This pattern separates the object's construction process from its representation, so that the same construction process can create different representations.
***Main role
- Product: A complex object to be built, it should contain multiple parts.
- Abstract Builder: Defines the abstract interface for building a product, including the method of building various parts of the product.
- Concrete Builder: Implement the abstract builder interface, specifically determine how to build various parts of the product, and be responsible for returning the final built product.
- Director: Responsible for calling the builder's methods to build the product. The instructor does not understand the specific construction process and only cares about the order and method of the product.
*** Application scenarios
- When the algorithm for creating an object should be independent of the components of the object and how they are assembled.
- When the construction process must allow the constructed object to have different representations.
- When it is necessary to create a complex object, but its partial construction process must be in a certain order.
- When more granular control is required during object creation.
***Implementation steps
- Defines a product class to represent the complex object being constructed.
- Defines the builder interface, including steps to build object and methods to set properties.
- Create a specific builder class, implement the builder interface, and implement the specific steps of building objects.
- Create a class of mentors that coordinates the build process and controls the order of builders.
- Use the instructor to build objects in client code.
***advantage
- Separating the construction of objects from representations allows the same construction process to create different representations, increasing program flexibility.
- Separate the construction code of complex objects from the representation code, making it easy to maintain.
- Hidden details of object construction, separate the construction code from the representation code, and improve the readability and maintainability of the code.
- Different specific builders can be replaced and expanded
using UnityEngine;
namespace BuilderPattern
{
public class BuilderController: MonoBehaviour
{
private void Start()
{
// Create a monster without weapons
var buildParam1001 = new MonsterBuilderParam("monster_1001", "Monster", 100, 100, 0, 50);
var monsterBuilder = new MonsterBuilder(buildParam1001);
var monster = (Monster)();
= new Vector3(0, 0, 0);
// Create a monster carrying weapon weapon002
var buildParam1002 = new MonsterBuilderParam("monster_1002", "Monster", 100, 100, 20, 50, "weapon002");
(buildParam1002);
var monster2 = (Monster)();
= new Vector3(2, 0, 0);
// Create the most basic monster without setting properties
var buildParam1003 = new MonsterBuilderParam("monster_1003", "Monster");
(buildParam1003);
var monster3 = (Monster)();
= new Vector3(4, 0, 0);
// Create a pet that follows monster3
var petBuilderParam = new PetBuilderParam("pet_1001", "Pet", );
var petBuilder = new PetBuilder(petBuilderParam);
//(); // Add a weapon to the pet, report an error
var pet = (Pet)();
= new Vector3(5, 0, 0);
}
}
}
namespace BuilderPattern
{
// The MonsterBuilderParam class inherits from ActorBuilderParam, providing specific parameters for monsters
public class MonsterBuilderParam: ActorBuilderParam
{
public float hp;
public float maxHp;
public float mp;
public float maxMp;
public string weaponId;
public MonsterBuilderParam(string id, string prefabName, float hp, float maxHp, float mp, float maxMp, string weaponId = null)
{
= id;
= prefabName;
= hp;
= maxHp;
= mp;
= maxMp;
= weaponId;
}
public MonsterBuilderParam(string id, string prefabName)
{
= id;
= prefabName;
}
}
}
namespace BuilderPattern
{
// Define an abstract class to encapsulate all parameters that need to be passed to the builder
public abstract class ActorBuilderParam
{
// Unique identifier and prefabricated name of each game object
public string id;
public string prefabName;
}
}
using UnityEngine;
namespace BuilderPattern
{
// The PetBuilderParam class inherits from ActorBuilderParam and provides specific parameters for pets
public class PetBuilderParam: ActorBuilderParam
{
// Pet Following Target Transform
public Transform followTarget;
public PetBuilderParam(string id, string prefabName, Transform followTarget = null)
{
= id;
= prefabName;
= followTarget;
}
}
}
using UnityEngine;
namespace BuilderPattern
{
// Abstract Builder class defines the general process of building game objects.
public abstract class ActorBuilder
{
protected Actor actor; // Actor component in the game
protected GameObject gameObject; // The game object currently being built
// Set basic properties
public abstract void SetBaseAttr();
public abstract Component AddWeapon();
public abstract Component AddAI();
public abstract Component AddBag();
public abstract Actor AddActor();
public abstract GameObject LoadModel();
public virtual bool HasBag()
{
return false;
}
public virtual bool HasWeapon()
{
return true;
}
// Reset Builder status
public virtual void Reset(ActorBuilderParam buildParam)
{
actor = null;
}
public virtual Component AddOnClickBehaviour()
{
var com = <OnClickBehaviour>();
return com;
}
// Build a complete game object, including all possible components
public Actor ConstructFull()
{
GameObject go = LoadModel();
actor = AddActor();
SetBaseAttr();
//Judge whether to add specific components according to the hook method
if (HasWeapon())
{
AddWeapon();
}
AddAI();
AddOnClickBehaviour();
if (HasBag())
{
AddBag();
}
return actor;
}
// Build a minimized game object, including only the necessary components.
public Actor ConstructMinimal()
{
GameObject go = LoadModel();
actor = AddActor();
SetBaseAttr();
return actor;
}
}
}
using UnityEngine;
namespace BuilderPattern
{
// The MonsterBuilder class inherits from ActorBuilder to implement the construction logic of specific monsters
public class MonsterBuilder : ActorBuilder
{
private MonsterBuilderParam buildParam;
public MonsterBuilder(MonsterBuilderParam buildParam)
{
= buildParam;
}
public override Component AddAI()
{
BaseAI com = <MonsterAI>(gameObject);
return com;
}
public override Component AddWeapon()
{
Weapon com = (gameObject, );
= ;
return com;
}
public override bool HasBag()
{
return false;
}
public override bool HasWeapon()
{
return != null;
}
public override Component AddBag()
{
throw new ();
}
public override void SetBaseAttr()
{
= ;
}
public override GameObject LoadModel()
{
gameObject = (GameObject)(());
= ;
return gameObject;
}
public override Actor AddActor()
{
var com = <Monster>();
= ;
= ;
= ;
= ;
return com;
}
// Rewrite the Reset method to allow reconfiguring the builder with new parameters
public override void Reset(ActorBuilderParam buildParam)
{
(buildParam);
= (MonsterBuilderParam)buildParam;
}
}
}
using UnityEngine;
namespace BuilderPattern
{
// The PetBuilder class inherits from ActorBuilder to implement the construction logic of specific pets.
public class PetBuilder : ActorBuilder
{
private PetBuilderParam buildParam;
public PetBuilder(PetBuilderParam buildParam)
{
= buildParam;
}
public override Component AddAI()
{
BaseAI com = <PetAI>(gameObject);
return com;
}
public override Component AddBag()
{
var com = <Bag>();
return com;
}
public override bool HasBag()
{
return true;
}
public override bool HasWeapon()
{
return false;
}
public override Component AddWeapon()
{
throw new ();
}
public override void SetBaseAttr()
{
= ;
}
public override GameObject LoadModel()
{
gameObject = (GameObject)(());
= ;
return gameObject;
}
// Add Pet component and set the following target
public override Actor AddActor()
{
var com = <Pet>();
= ;
return com;
}
}
}
using UnityEngine;
namespace BuilderPattern
{
// The Pet class inherits from the Actor, adding the feature of following the target.
public class Pet : Actor
{
public Transform followTransform; // The goal that the pet wants to follow
// Pet-specific initialization or update logic can be written here
}
}
namespace BuilderPattern
{
public class PetAI: BaseAI
{
// Pet-specific AI logic can be implemented here
}
}
namespace BuilderPattern
{
public class Monster : Actor
{
public float hp; // Current health value
public float maxHp; // Maximum health value
public float mp; // Current magic value
public float maxMp; // Maximum magic value
// Monster-specific initialization or update logic can be written here
}
}
namespace BuilderPattern
{
// MonsterAI inherits from BaseAI, realizing the artificial intelligence behavior of monsters.
public class MonsterAI: BaseAI
{
// Monster-specific AI logic can be implemented here
}
}
using UnityEngine;
namespace BuilderPattern
{
// Click on the behavior component to respond to the click event.
public class OnClickBehaviour : MonoBehaviour
{
// The logic for responding to click events can be written here
}
}
using UnityEngine;
namespace BuilderPattern
{
public class BaseAI: MonoBehaviour
{
// General AI logic can be written here
}
}
using UnityEngine;
namespace BuilderPattern
{
public class Bag : MonoBehaviour
{
// The logic related to backpack can be written here
}
}
using UnityEngine;
namespace BuilderPattern
{
// Weapon component, representing a weapon in a game
public class Weapon: MonoBehaviour
{
public string weaponId;
private void Start()
{ // Initialization logic
}
private void Update() { // Update logic per frame
}
}
}
using UnityEngine;
namespace BuilderPattern
{
// Weapon factory is used to create weapon instances, which can be expanded to create different types of weapons based on different parameters.
public class WeaponFactory: MonoBehaviour
{
public static Weapon CreateWeapon(GameObject go, string weaponId)
{
var weapon = <Weapon>();
= weaponId;
return weapon;
}
}
}
using UnityEngine;
namespace BuilderPattern
{
// AI factories are used to create different types of AI components.
public class AIFactory
{
//The specific AI creation logic can be implemented here.
public static BaseAI CreateAI<T>(GameObject go) where T: BaseAI
{
return <T>();
}
}
}
using UnityEngine;
namespace BuilderPattern
{
public class Actor: MonoBehaviour
{
public string id;
// public Actor(string id, string prefabName, float hp, float maxHp, float mp, float maxMp, float hasBag, string weaponId, Transform followTransform)
// {
// } public Actor()
{
}
}
}Data locality pattern
***Data Locality Pattern is a technology that optimizes the performance of computer programs, with the goal of maximizing the speed of data processing. This mode is based on the fact that the processor accesses memory close to it (such as cache) faster than accessing distant storage (such as RAM or hard disk). The core of the data locality pattern is to organize the data structure so that data often used together can be stored physically close to each other.
***Type of data locality
- Temporal Locality: The recently accessed data may be accessed again in the near future.
- Spatial Locality: If a data item is accessed, then the data item adjacent to it may also be accessed soon.
***Why data locality patterns are important
- Data localization mode is critical to improving program performance, especially when handling large amounts of data or high-performance computing tasks. By optimizing data storage, the cache miss can be reduced, thereby improving the operation efficiency of the program
*When using this mode to obtain a good cache hit rate, you will also lose in other aspects. For example, we can't use various interfaces and pointers. Because we have to ensure that they are together in memory and access the memory block directly, rather than jumping around through pointers. Therefore, the better the data localization pattern, the more you need to abandon abstracts and other things*//The pointer is traversed in the for loop, but the pointer points to another memory, which triggers a low hit rate of the cache
private void Update(){
for(int i=0;i<numEntities;i++){
entities[i].();
}
for(int i=0;i<numEntities;i++){
entities[i].();
}
for(int i=0;i<numEntities;i++){
entities[i].();
}
}
//Use data localization characteristics
private void Update(){
for(int i=0;i<numEntities;i++){
comAIs[i].Update();
}
for(int i=0;i<numEntities;i++){
renders[i].Renderer();
}
for(int i=0;i<numEntities;i++){
fsms[i].Update();
}
}