Don't search. Act as a Unity Senior Developer, you are expected to have a solid understanding of game development principles and best practices. 
Are there any inaccuracies or flaws in existing implemented systems and classes in my description
Description:
General features:
- Game in Unity Engine
- 2D Graphics
- Top Down view
- The idea of the game is similar to games like S.T.A.L.K.E.R., Kenshi and Mount and Blade where in a large open non-procedural world live NPCs who explore and interact with the world
- Use Fluid HTN as brain for NPCs and maybe as World Director
- Player can take control of any NPC

Systems:
- NOT IMPLEMENTED YET Core system:
-- GameMaster.cs: Main class controlling overall game state and progression. TODO: Define game state and progression
-- GameTime.cs: Class responsible for managing in-game time and date system.
-- WorldEventManager.cs: Class responsible for managing world events.
-- WorldWeatherManager.cs: Class responsible for managing world weather.
-- GlobalStateManager.cs: Class responsible for managing world global states.

- NPCs systems:

-- AIWorldStates.cs: The world state is a collection of variables that represent the state of the world for an agent. Each variable is defined as an enum value of type AIWorldState. The possible values are:
--- CurrentGoal,
--- HasWeaponEquipped
--- HasWeaponInInventory,
--- HasItemInPickupRange,
--- HasItemInInventory,
--- HasAmmoInInventory,
--- HasAmmoInWeapon,
--- HasHumanInSensors,
--- HasAgentInMemory,
--- HasAliveEnemyInMemory,
--- HasTargetEnemyInVision,
--- HasItemInMemory,
--- IsInSafePlace,
--- HasTargetToMove,
--- IsMoving,
--- CanMove,
--- IsWandering,
--- IsIdle,
--- HasAbilityToFight,
--- HasEnemyTarget,
--- IsTargetInWeaponRange,
--- IsWeaponAimedAtTarget,
--- IsTargetMoving,
--- IsTargetKilled,

TODO: Figure out the GoalState and enum values.

-- HTN System:
--- Fluid HTN system.
--- AIContext.cs: This class is the blackboard the planner uses to access state during its planning procedure.
--- AIDomainDefinition.cs: Abstract ScriptableObject class with abstract method Create that returns Domain.
--- HumanDomainDefinition.cs: AIDomainDefinition class that creates a domain for agents using HTN planning. Uses methods from AIDomainBuilder.
--- AIDomainBuilder.cs: AIDomainDefinition class that provides custom methods to create conditions, effects, and operators for agents.
--- Operators:
---- AttackWeaponOperator.cs: IOperator class responsible for attack using equipped weapon.
---- EquipOperator.cs: IOperator class responsible for equipping equipment.
---- PickUpItemOperator.cs: IOperator class responsible for pick up target item using ItemCollector.
---- ReloadWeaponOperator.cs: IOperator class responsible for reloading weapon
---- RotateOperator.cs: IOperator class responsible for rotating agent to enemy target.
---- SetEnemyPositionOperator.cs: IOperator class responsible for calculating and setting up target position to have enemy visible and in weapon range.
---- SetTargetOperator.cs: IOperator class responsible for setting up target to move depending on the current AIWorldStates.
---- StartToMoveOperator.cs: IOperator class responsible for moving to current target.
---- WaitOperator.cs: IOperator class responsible for waiting.
---- WardenOperator.cs: IOperator class responsible for creating random target to move.

-- NPCAgent.cs: MonoBehaviour class responsible for setting up Fluid HTN systems like Domain and Planner. Setting up default states, executing planner tick.
-- AgentBrain.cs: MonoBehaviour class responsible for setting up MemoryManager, SensorySystem, CalculationsManager
-- AgentsManager.cs: MonoBehaviour singleton responsible for setting up ID to Agents and for quick access to all Agents.
-- AgentTransform.cs: MonoBehaviour class responsible for holding current transform, rotation, velocity and current target to move
-- CalculationsManager.cs: Class responsible for calculations
-- HealthBarTransformer.cs: MonoBehaviour class responsible for holding and positioning agent world health bar.

-- AgentInventory.cs: MonoBehaviour class responsible for creating InventoryManager, EquipmentManager, ItemCollector.
-- InventoryManager.cs: Class responsible for creating InventoryObject as inventory and storing it and invoke event OnItemsUpdated when items updating.
-- EquipmentManager.cs: Class responsible for creating InventoryObject as equipment inventory and storing it, responsible for having ability to equip equipment and removing equipment.
-- ItemCollector.cs: MonoBehaviour class responsible for ability to pick up items if they in pickable range.

-- Navigation System:
--- A* Pathfinding Project
--- AIDestinationSetter.cs: Class responsible for handling A* Pathfinding requests.

-- Memory System:
--- System responsible for agent's memory.
--- MemoryManager.cs: Class responsible for managing memory like storing MemoryAgent and MemoryItem
--- MemoryAgent.cs: Class responsible for storing specific agent in memory
--- MemoryItem.cs: Class responsible for storing specific GroundItem in memory.
--- TODO: Figure out the MemoryLocation and MemoryEvent and then implement.

-- Sensor System:
--- A system that allows AI agents to sense their environment and detect other agents, objects
--- ISensor.cs: Interface for sensory system.
--- SensorySystem.cs: Class responsible for storing all ISensor and execute tick.
--- VisionSensor.cs: Class responsible for NPCs’ field of view, raycasting vision, and detecting other objects/characters.
--- NOT IMPLEMENTED YET HearingSensor.cs: Class responsible for area detection, NPCs can hear sounds generated by nearby events or interactions.

-- Inventory and Items System:
--- A system that allows AI agents to pick up items, use items, equip items, store items, drop items
--- ItemDatabaseObject.cs: ScriptableObject that holds all the ScriptableObjects for items in the game world.
--- ItemStorage.cs: ScriptableObjects that responsible for creating items from inspector and store it in files.
--- Inventory.cs: : Class responsible for creating and managing an array of InventorySlot objects, which represent the slots in the inventory. Has methods for checking if the inventory contains an item, clearing the inventory, finding an item or an empty slot in the inventory, adding an item to the inventory, and swapping items between slots.
--- Item.cs: Base class for all type of items. Contains an ItemType Enum, which defines whether the item is a default, consumable, or Equipment. Has UI display, world display, character display if it equipment. Has array of buffs.
--- ItemType.cs: Enum representing different item types (Default, Consumable, Equipment)
--- EquipmentSlot.cs: Enum representing different equipment slots (None, Head, Body, Hand)
--- Attribute.cs: Class representing an attribute of a character or an item, such as weight. Has a Type enum, a Value object of type ModifiableInt, and a Parent object of type AgentInventory. Has a method for setting the parent agent and a method for notifying the parent when the attribute is modified.
--- GroundItem.cs: MonoBehaviour class responsible for represent item in world that can be picked up.
--- IModifier.cs: Interface for classes that can modify a base value by adding a certain amount to it. Has a method called AddValue that takes a reference to an int and modifies it.
--- ItemBuff.cs: Class representing a buff that can be applied to an attribute by an item. Implements the IModifier interface. Has a Stat enum and a Value int. Has a constructor that takes a stat and a value as parameters.
--- ModifiableInt.cs: Class representing an int value that can be modified by modifiers. Has a BaseValue int, a ModifiedValue int, and a list of IModifier objects. Has an event called OnValueModified that can be subscribed to by other classes. Has methods for registering and unregistering to the event, updating the modified value based on the modifiers, adding and removing modifiers.t
--- DatabaseContainer.cs: MonoBehaviour singleton that stores ItemDatabaseObject
--- InterfaceType.cs: Enum representing different types of interfaces (Inventory, Equipment, Storage)
--- InventoryObject.cs:  ScriptableObject class responsible for creating and storing an Inventory object as well as its type (Inventory, Equipment, or Storage). Has methods for setting the parent agent transform, adding an item to the inventory, getting the empty slot count, finding an item or an empty slot in the inventory, checking if an item is in the inventory, swapping items between slots, dropping an item from the inventory, removing an item from the inventory, clearing the inventory, and setting the container. Has an event called OnInventoryUpdated that can be invoked when the inventory changes.
--- InventorySlot.cs: Class representing a slot in the inventory. Has an AllowedItemType enum that defines what type of equipment can be placed in the slot (None means any type). Has a ParentInv object of type InventoryObject that references the inventory that contains the slot. Has a SlotDisplay object of type GameObject that represents the UI element for the slot. Has a CharDisplayWhenEquipped object of type GameObject that represents how the item looks when equipped on the character. Has two actions called OnAfterUpdated and OnBeforeUpdated that can be assigned by other classes to perform certain actions when the slot is updated. Has an Item object that stores the item in the slot. Has an Amount int that stores how many items are in the slot. Has an IsEquipped bool that indicates whether the item is equipped or not. Has methods for getting the item from the database, updating the slot with a new item and amount, removing the item from the slot, dropping the item on the ground, adding amount to the slot, and checking if an item can be placed in the slot.

-- NOT IMPLEMENTED YET Communication System:
--- A system that allows AI agents to exchange information and coordinate with each other
--- Personality System:
---- A subsystem that allows AI agents to have a unique name and unique memory of specific events
--- TODO: Figure out how the system will work and then implement

-- Faction System:
--- A system that allows AI agents to belong to a specific faction that has unique relationships with other factions
--- Faction.cs: Class representing a faction, and faction name.
--- FactionRelationEntry.cs: Class representing a relationships between two factions using enum FactionRelation.
--- FactionRelation.cs: Enum representing different types of relationships (Hostile, Unfriendly, Neutral, Friendly, Allied)
--- FactionDatabase.cs: ScriptableObject that holds all the factions as list of FactionRelationEntry.
--- FactionsManager.cs: MonoBehaviour singleton that stores FactionsDatabase. TODO: And ability to modify relations.

-- NOT IMPLEMENTED YET Location System:
--- TODO: Figure out how the system will work and then implement

-- NOT IMPLEMENTED YET Quest System:
--- A system that allows AI agents to take quests, complete quests, fail quests, create quests 
--- Quest.cs: Represents a quest with objectives, rewards, and related information.
--- QuestGenerator.cs: Creates procedural quests for NPCs.
--- QuestObjective.cs: Represents a single objective within a quest.
--- QuestCompletion.cs: Responsible for completing the quest and awarding rewards.

-- NOT IMPLEMENTED YET Trading System:
--- A system that allows AI agents to buy and sell items with other agents
--- TradingManager.cs: Class responsible for managing transactions, including buying, selling, and bartering items.
--- TradeInventory.cs: Represents the inventory of items available for trading for characters and merchants.

-- NOT IMPLEMENTED YET Combat System:
--- A system that allows AI agents to fight each other with melee or range weapon. In real time. Using Fluid HTN for tactics.
--- CombatManager.cs: Class responsible for managing combat interactions, handling AI tactics, and updating the combat state.

-- Health System:
--- A system that allows AI agents to have a health, lose health, restore health
--- HealthSystem.cs: Class responsible for managing character HP, taking damage, and handling death events.

-- NOT IMPLEMENTED YET Stamina System:
--- A system that allows AI agents to have a stamina, lose stamina, restore stamina
--- StaminaSystem.cs: Class responsible for managing character stamina, stamina regeneration, and usage.

-- NOT IMPLEMENTED YET Stats System:
--- Represents the various attributes and statistics for characters in the game, such as strength, agility, intelligence, and more.
--- AgentStats.cs: Class responsible for managing character attributes, leveling up, and updating stats.

- Weapon System:
-- Weapon.cs: MonoBehaviour class responsible for handling weapon behavior, including firing projectiles.
-- Projectile.cs: MonoBehaviour class for projectile that firing from weapon.
-- ProjectileSettings.cs: ScriptableObject class responsible for creating different projectiles in inspector
-- ProjectileSpawner.cs: Class responsible for instantiating projectiles and assigning properties.

- Camera System:
-- PlayerCameraController.cs: Class responsible for camera movement, smooth following of the player/controlled NPC, and managing camera zoom levels.

- NOT IMPLEMENTED YET Audio System:
-- AudioManager.cs: Class responsible for managing and playing sound effects, background music, and NPC audio.
-- MusicManager.cs: Class responsible for managing and switching background music based on game events and locations.

- NOT IMPLEMENTED YET UI System:
-- UIManager.cs: Responsible for updating and controlling general UI elements.
-- InventoryUI.cs: Controls inventory related UI elements.
-- QuestLogUI.cs: Controls quest log related UI elements.
-- TODO: maybe add more classes

- NOT IMPLEMENTED YET Logging System:
-- GameLogger.cs: Handles logging of game-related events for debugging and analytics purposes.
-- TODO: maybe add more classes and more explanations

- NOT IMPLEMENTED YET Save Load System:
-- SaveLoadSystem.cs: Responsible for saving and loading game data to and from files.
-- TODO: maybe add more classes and explain how save load system will work

- NOT IMPLEMENTED YET Pooling System:
-- A system that handles the pooling of frequently instantiated objects, such as projectiles, to improve performance.


Short summary of Fluid HTN:
Fluid HTN, a simple HTN planner based on the Builder pattern, inspired by Fluid Behaviour Tree. HTN stands for Hierarchical Task Network, which is a method of AI planning that decomposes high-level tasks into low-level actions. The page explains the main concepts and features of Fluid HTN, such as:
Compound Tasks: high-level tasks that have multiple ways of being accomplished, such as Selectors and Sequencers.
Primitive Tasks: low-level tasks that represent a single step that can be performed by the AI, such as Operators, Effects and Conditions.
Effects: world state changes that can be applied during planning or execution, such as PlanOnly, PlanAndExecute and Permanent effects.
Domain Builder: a fluent API to simplify the design of code-oriented HTN domains, with support for custom conditions, effects, operators and selectors.
Partial planning: a feature that allows the planner to only plan up to a certain point, then continue from there once the partial plan has been completed, using Pause Plan tasks.
Domain splicing: a feature that allows the planner to splice together sub-domains to form new domains, using Splice tasks or Slot tasks for run-time splicing.
Factory interface: an interface that allows the user to customize memory management schemes, such as pooling, for arrays/collections/objects used by the planner.
Decomposition logging: a feature that allows the planner to store information about condition success and failure during decomposition, for debugging purposes.
Callback hooks: a feature that allows the user to hook up to certain events in the planner, such as OnNewPlan or OnCurrentTaskFailed.