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 systems 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:
--- HasWeaponEquipped
--- HasWeaponInInventory,
--- HasItemInPickupRange,
--- HasItemInInventory,
--- HasAmmoInInventory,
--- HasAmmoInWeapon,
--- HasHumanInSensors,
--- HasAgentInMemory,
--- HasAliveEnemyInMemory,
--- HasTargetEnemyInVision,
--- HasItemInMemory,
--- IsInSafePlace,
--- HasTargetToMove,
--- IsMoving,
--- CanMove,
--- IsWandering,
--- IsIdle,
--- HasAbilityToFight,
--- HasEnemyTarget,
--- IsTargetInWeaponRange,
--- IsWeaponAimedAtTarget,
--- IsTargetMoving,
--- IsTargetKilled,

Question: do we need enum GoalState or not

-- 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.

-- 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: TODO fill out
--- 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: TODO fill out
--- GroundItem.cs: MonoBehaviour class responsible for represent item in world that can be picked up.
--- IModifier.cs: TODO fill out
--- ItemBuff.cs: TODO fill out
--- ModifiableInt.cs: TODO fill out
--- DatabaseContainer.cs: MonoBehaviour singleton that stores ItemDatabaseObject
--- InterfaceType.cs: Enum representing different types of interfaces (Inventory, Equipment, Storage)
--- InventoryObject.cs: TODO fill out
--- InventorySlot.cs: TODO fill out

-- 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

-- 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.