feat: add shoot and cooldown systems

Assets/_Project/Develop/Runtime/Constants/PathToResources.cs

@@ -34,6 +34,7 @@ namespace Assets._Project.Develop.Runtime.Utilities.SceneManagement
         
         public static class Entity
         {
+            public const string Projectile = "Entities/Projectile";
             public const string Hero = "Entities/Hero";
             public const string Ghost = "Entities/Ghost";
         }

Assets/_Project/Develop/Runtime/Logic/Gameplay/Entities/EntitiesFactory.cs

@@ -1,5 +1,7 @@
 using _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.Systems;
+using _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.Systems.Shoot;
 using _Project.Develop.Runtime.Logic.Gameplay.Features.Damage;
+using _Project.Develop.Runtime.Logic.Gameplay.Features.Input;
 using _Project.Develop.Runtime.Logic.Gameplay.Features.Lifetime.Systems;
 using _Project.Develop.Runtime.Logic.Gameplay.Features.Movement;
 using _Project.Develop.Runtime.Logic.Gameplay.Features.Sensors.Systems;
@@ -55,7 +57,12 @@ namespace _Project.Develop.Runtime.Entities
                 .AddStartAttackEvent()
                 .AddEndAttackEvent()
                 .AddAttackDelayTime(new ReactiveVariable<float>(2))
-                .AddAttackDelayEndEvent();
+                .AddAttackDelayEndEvent()
+                .AddInstantAttackDamage(new ReactiveVariable<float>(50))
+                .AddAttackCanceledEvent()
+                .AddAttackCooldownInitialTime()
+                .AddAttackCooldownCurrentTime()
+                .AddInAttackCooldown();
             
             ICompositeCondition canMove = new CompositeCondition()
                 .Add(new FuncCondition(() => entity.IsDead.Value == false));
@@ -76,7 +83,12 @@ namespace _Project.Develop.Runtime.Entities
             ICompositeCondition canStartAttack = new CompositeCondition()
                 .Add(new FuncCondition(() => entity.IsDead.Value == false))
                 .Add(new FuncCondition(() => entity.InAttackProcess.Value == false))
-                .Add(new FuncCondition(() => entity.IsMoving.Value == false));
+                .Add(new FuncCondition(() => entity.IsMoving.Value == false))
+                .Add(new FuncCondition(() => entity.InAttackCooldown.Value == false));
+            
+            ICompositeCondition mustCancelAttack = new CompositeCondition(LogicOperationsUtils.Or)
+                .Add(new FuncCondition(() => entity.IsDead.Value))
+                .Add(new FuncCondition(() => entity.IsMoving.Value));
 
             entity
                 .AddCanMove(canMove)
@@ -84,18 +96,24 @@ namespace _Project.Develop.Runtime.Entities
                 .AddCanApplyDamage(canApplyDamage)
                 .AddMustDie(mustDie)
                 .AddCanStartAttack(canStartAttack)
-                .AddMustSelfRelease(mustSelfRelease);
+                .AddMustSelfRelease(mustSelfRelease)
+                .AddMustCancelAttack(mustCancelAttack);
 
             entity
+                .AddSystem(new AttackByInputSystem(_playerInput))
                 .AddSystem(new MoveDirectionByInputSystem(_playerInput))
                 .AddSystem(new RotateDirectionByMoveInputSystem(_playerInput))
                 .AddSystem(new RigidbodyMovementSystem())
                 .AddSystem(new RigidbodyRotationSystem())
                 
+                .AddSystem(new AttackCancelSystem())
+                
                 .AddSystem(new StartAttackSystem())
                 .AddSystem(new ProcessAttackTimerSystem())
                 .AddSystem(new AttackDelayEndTriggerSystem())
+                .AddSystem(new InstantShootSystem(this))
                 .AddSystem(new EndAttackSystem())
+                .AddSystem(new AttackCooldownTimerSystem())
                 
                 .AddSystem(new ApplyDamageSystem())
                 
@@ -178,6 +196,63 @@ namespace _Project.Develop.Runtime.Entities
         
             return entity;
         }
+        
+        public Entity CreateProjectile(Vector3 position, Vector3 direction, float damage)
+        {
+            Entity entity = CreateEmpty();
+        
+            _monoEntitiesFactory.Create(entity, position, PathToResources.Entity.Projectile);
+
+            entity
+                .AddContactsDetectingMask(Layers.CharactersMask | Layers.EnvironmentMask)
+                .AddContactCollidersBuffer(new Buffer<Collider>(64))
+                .AddContactEntitiesBuffer(new Buffer<Entity>(64))
+                .AddMoveDirection(new ReactiveVariable<Vector3>(direction))
+                .AddRotateDirection(new ReactiveVariable<Vector3>(direction))
+                .AddMoveSpeed(new ReactiveVariable<float>(16))
+                .AddRotationSpeed(new ReactiveVariable<float>(9999))
+                .AddBodyContactDamage(new ReactiveVariable<float>(damage))
+                .AddIsDead()
+                .AddIsMoving()
+                .AddDeathMask(Layers.CharactersMask | Layers.EnvironmentMask)
+                .AddIsTouchDeathMask();
+            
+            ICompositeCondition canMove = new CompositeCondition()
+                .Add(new FuncCondition(() => entity.IsDead.Value == false));
+
+            ICompositeCondition canRotate = new CompositeCondition()
+                .Add(new FuncCondition(() => entity.IsDead.Value == false));
+            
+            ICompositeCondition mustDie = new CompositeCondition()
+                .Add(new FuncCondition(() => entity.IsTouchDeathMask.Value), 0);
+
+            ICompositeCondition mustSelfRelease = new CompositeCondition()
+                .Add(new FuncCondition(() => entity.IsDead.Value));
+
+            entity
+                .AddCanMove(canMove)
+                .AddCanRotate(canRotate)
+                .AddMustDie(mustDie)
+                .AddMustSelfRelease(mustSelfRelease);
+
+            entity
+                .AddSystem(new RigidbodyMovementSystem())
+                .AddSystem(new RigidbodyRotationSystem())
+                
+                .AddSystem(new BodyContactsDetectingSystem())
+                .AddSystem(new BodyContactsEntitiesFilterSystem(_collidersRegistryService))
+                
+                .AddSystem(new DealDamageOnContactSystem())
+                .AddSystem(new DeathMaskTouchDetectorSystem())
+                .AddSystem(new DeathSwitcherSystem())
+                
+                .AddSystem(new DisableCollidersOnDeathSystem())
+                .AddSystem(new SelfReleaseSystem(_entitiesLifeContext));
+        
+            _entitiesLifeContext.Add(entity);
+        
+            return entity;
+        }
 
         private Entity CreateEmpty() => new();
     }

Assets/_Project/Develop/Runtime/Logic/Gameplay/Entities/Generated/EntityAPI.cs

@@ -221,6 +221,207 @@ namespace _Project.Develop.Runtime.Entities
 			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Sensors.IsTouchAnotherTeam() {Value = value}); 
 		}
 
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection MoveDirectionC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> MoveDirection => MoveDirectionC.Value;
+
+		public bool TryGetMoveDirection(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddMoveDirection()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddMoveDirection(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed MoveSpeedC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> MoveSpeed => MoveSpeedC.Value;
+
+		public bool TryGetMoveSpeed(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddMoveSpeed()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddMoveSpeed(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving IsMovingC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> IsMoving => IsMovingC.Value;
+
+		public bool TryGetIsMoving(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddIsMoving()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddIsMoving(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove CanMoveC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove>();
+
+		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanMove => CanMoveC.Value;
+
+		public bool TryGetCanMove(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddCanMove(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection RotateDirectionC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> RotateDirection => RotateDirectionC.Value;
+
+		public bool TryGetRotateDirection(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddRotateDirection()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddRotateDirection(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed RotationSpeedC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> RotationSpeed => RotationSpeedC.Value;
+
+		public bool TryGetRotationSpeed(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddRotationSpeed()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddRotationSpeed(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate CanRotateC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate>();
+
+		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanRotate => CanRotateC.Value;
+
+		public bool TryGetCanRotate(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddCanRotate(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce JumpForceC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> JumpForce => JumpForceC.Value;
+
+		public bool TryGetJumpForce(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddJumpForce()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddJumpForce(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump CanJumpC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump>();
+
+		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanJump => CanJumpC.Value;
+
+		public bool TryGetCanJump(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddCanJump(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump() {Value = value}); 
+		}
+
 		public _Project.Develop.Runtime.Logic.Gameplay.Features.Lifetime.CurrentHealth CurrentHealthC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Lifetime.CurrentHealth>();
 
 		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> CurrentHealth => CurrentHealthC.Value;
@@ -427,207 +628,6 @@ namespace _Project.Develop.Runtime.Entities
 			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Lifetime.DisableCollidersOnDeath() {Value = value}); 
 		}
 
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection MoveDirectionC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection>();
-
-		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> MoveDirection => MoveDirectionC.Value;
-
-		public bool TryGetMoveDirection(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddMoveDirection()
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>() }); 
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddMoveDirection(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveDirection() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed MoveSpeedC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed>();
-
-		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> MoveSpeed => MoveSpeedC.Value;
-
-		public bool TryGetMoveSpeed(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddMoveSpeed()
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddMoveSpeed(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.MoveSpeed() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving IsMovingC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving>();
-
-		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> IsMoving => IsMovingC.Value;
-
-		public bool TryGetIsMoving(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean>);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddIsMoving()
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean>() }); 
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddIsMoving(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.IsMoving() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove CanMoveC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove>();
-
-		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanMove => CanMoveC.Value;
-
-		public bool TryGetCanMove(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddCanMove(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanMove() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection RotateDirectionC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection>();
-
-		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> RotateDirection => RotateDirectionC.Value;
-
-		public bool TryGetRotateDirection(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddRotateDirection()
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3>() }); 
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddRotateDirection(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<UnityEngine.Vector3> value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotateDirection() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed RotationSpeedC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed>();
-
-		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> RotationSpeed => RotationSpeedC.Value;
-
-		public bool TryGetRotationSpeed(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddRotationSpeed()
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddRotationSpeed(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.RotationSpeed() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate CanRotateC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate>();
-
-		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanRotate => CanRotateC.Value;
-
-		public bool TryGetCanRotate(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddCanRotate(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanRotate() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce JumpForceC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce>();
-
-		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> JumpForce => JumpForceC.Value;
-
-		public bool TryGetJumpForce(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddJumpForce()
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddJumpForce(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.JumpForce() {Value = value}); 
-		}
-
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump CanJumpC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump>();
-
-		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanJump => CanJumpC.Value;
-
-		public bool TryGetCanJump(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddCanJump(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Movement.CanJump() {Value = value}); 
-		}
-
 		public _Project.Develop.Runtime.Logic.Gameplay.Features.Damage.TakeDamageRequest TakeDamageRequestC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Damage.TakeDamageRequest>();
 
 		public _Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent<System.Single> TakeDamageRequest => TakeDamageRequestC.Value;
@@ -719,6 +719,68 @@ namespace _Project.Develop.Runtime.Entities
 			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Damage.BodyContactDamage() {Value = value}); 
 		}
 
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InstantAttackDamage InstantAttackDamageC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InstantAttackDamage>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> InstantAttackDamage => InstantAttackDamageC.Value;
+
+		public bool TryGetInstantAttackDamage(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InstantAttackDamage component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddInstantAttackDamage()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InstantAttackDamage() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddInstantAttackDamage(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InstantAttackDamage() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.ShootPoint ShootPointC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.ShootPoint>();
+
+		public UnityEngine.Transform ShootPoint => ShootPointC.Value;
+
+		public bool TryGetShootPoint(out UnityEngine.Transform value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.ShootPoint component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(UnityEngine.Transform);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddShootPoint(UnityEngine.Transform value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.ShootPoint() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack CanStartAttackC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack>();
+
+		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanStartAttack => CanStartAttackC.Value;
+
+		public bool TryGetCanStartAttack(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddCanStartAttack(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack() {Value = value}); 
+		}
+
 		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.StartAttackRequest StartAttackRequestC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.StartAttackRequest>();
 
 		public _Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent StartAttackRequest => StartAttackRequestC.Value;
@@ -767,25 +829,6 @@ namespace _Project.Develop.Runtime.Entities
 			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.StartAttackEvent() {Value = value}); 
 		}
 
-		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack CanStartAttackC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack>();
-
-		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition CanStartAttack => CanStartAttackC.Value;
-
-		public bool TryGetCanStartAttack(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack component);
-			if(result)
-				value = component.Value;
-			else
-				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
-			return result;
-		}
-
-		public _Project.Develop.Runtime.Entities.Entity AddCanStartAttack(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
-		{
-			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.CanStartAttack() {Value = value}); 
-		}
-
 		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.EndAttackEvent EndAttackEventC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.EndAttackEvent>();
 
 		public _Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent EndAttackEvent => EndAttackEventC.Value;
@@ -930,5 +973,120 @@ namespace _Project.Develop.Runtime.Entities
 			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackDelayEndEvent() {Value = value}); 
 		}
 
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.MustCancelAttack MustCancelAttackC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.MustCancelAttack>();
+
+		public _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition MustCancelAttack => MustCancelAttackC.Value;
+
+		public bool TryGetMustCancelAttack(out _Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.MustCancelAttack component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddMustCancelAttack(_Project.Develop.Runtime.Utilities.Conditions.ICompositeCondition value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.MustCancelAttack() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCanceledEvent AttackCanceledEventC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCanceledEvent>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent AttackCanceledEvent => AttackCanceledEventC.Value;
+
+		public bool TryGetAttackCanceledEvent(out _Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCanceledEvent component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddAttackCanceledEvent()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCanceledEvent() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddAttackCanceledEvent(_Project.Develop.Runtime.Utils.ReactiveManagement.Event.ReactiveEvent value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCanceledEvent() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownInitialTime AttackCooldownInitialTimeC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownInitialTime>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> AttackCooldownInitialTime => AttackCooldownInitialTimeC.Value;
+
+		public bool TryGetAttackCooldownInitialTime(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownInitialTime component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddAttackCooldownInitialTime()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownInitialTime() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddAttackCooldownInitialTime(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownInitialTime() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownCurrentTime AttackCooldownCurrentTimeC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownCurrentTime>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> AttackCooldownCurrentTime => AttackCooldownCurrentTimeC.Value;
+
+		public bool TryGetAttackCooldownCurrentTime(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownCurrentTime component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddAttackCooldownCurrentTime()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownCurrentTime() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddAttackCooldownCurrentTime(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Single> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.AttackCooldownCurrentTime() {Value = value}); 
+		}
+
+		public _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InAttackCooldown InAttackCooldownC => GetComponent<_Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InAttackCooldown>();
+
+		public _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> InAttackCooldown => InAttackCooldownC.Value;
+
+		public bool TryGetInAttackCooldown(out _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> value)
+		{
+			bool result = TryGetComponent(out _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InAttackCooldown component);
+			if(result)
+				value = component.Value;
+			else
+				value = default(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean>);
+			return result;
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddInAttackCooldown()
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InAttackCooldown() { Value = new _Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean>() }); 
+		}
+
+		public _Project.Develop.Runtime.Entities.Entity AddInAttackCooldown(_Project.Develop.Runtime.Utils.ReactiveManagement.ReactiveVariable<System.Boolean> value)
+		{
+			return AddComponent(new _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.InAttackCooldown() {Value = value}); 
+		}
+
 	}
 }

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/AttackComponents.cs

@@ -2,21 +2,30 @@
 using _Project.Develop.Runtime.Utilities.Conditions;
 using _Project.Develop.Runtime.Utils.ReactiveManagement;
 using _Project.Develop.Runtime.Utils.ReactiveManagement.Event;
+using UnityEngine;
 
 namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Attack
 {
-    public class StartAttackRequest : IEntityComponent { public ReactiveEvent Value; }
-    public class StartAttackEvent : IEntityComponent { public ReactiveEvent Value; }
+    public class InstantAttackDamage : IEntityComponent { public ReactiveVariable<float> Value; }
+    
+    public class ShootPoint : IEntityComponent { public Transform Value; }
     
     public class CanStartAttack : IEntityComponent { public ICompositeCondition Value; }
-
+    public class StartAttackRequest : IEntityComponent { public ReactiveEvent Value; }
+    public class StartAttackEvent : IEntityComponent { public ReactiveEvent Value; }
     public class EndAttackEvent : IEntityComponent { public ReactiveEvent Value; }
-
+    
     public class AttackProcessInitialTime : IEntityComponent { public ReactiveVariable<float> Value; }
     public class AttackProcessCurrentTime : IEntityComponent { public ReactiveVariable<float> Value; }
-    
     public class InAttackProcess : IEntityComponent { public ReactiveVariable<bool> Value; }
     
     public class AttackDelayTime : IEntityComponent { public ReactiveVariable<float> Value; }
     public class AttackDelayEndEvent : IEntityComponent { public ReactiveEvent Value; }
+    
+    public class MustCancelAttack : IEntityComponent { public ICompositeCondition Value; }
+    public class AttackCanceledEvent : IEntityComponent { public ReactiveEvent Value; }
+
+    public class AttackCooldownInitialTime : IEntityComponent { public ReactiveVariable<float> Value; }
+    public class AttackCooldownCurrentTime : IEntityComponent { public ReactiveVariable<float> Value; }
+    public class InAttackCooldown : IEntityComponent { public ReactiveVariable<bool> Value; }
 }

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/ShootPointEntityRegistrator.cs

@@ -0,0 +1,15 @@
+using _Project.Develop.Runtime.Entities;
+using UnityEngine;
+
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Attack
+{
+    public class ShootPointEntityRegistrator : MonoEntityRegistrator
+    {
+        [SerializeField] private Transform _shootPoint;
+
+        public override void Register(Entity entity)
+        {
+            entity.AddShootPoint(_shootPoint);
+        }
+    }
+}

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/ShootPointEntityRegistrator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1675979b03c84ec3b990009a37f3d6d9
+timeCreated: 1771692788

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/Systems/Base/AttackCancelSystem.cs

@@ -0,0 +1,35 @@
+using _Project.Develop.Runtime.Entities;
+using _Project.Develop.Runtime.Utilities.Conditions;
+using _Project.Develop.Runtime.Utils.ReactiveManagement;
+using _Project.Develop.Runtime.Utils.ReactiveManagement.Event;
+
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.Systems
+{
+    public class AttackCancelSystem : IInitializableSystem, IUpdatableSystem
+    {
+        private ReactiveVariable<bool> _inAttackProcess;
+        private ReactiveEvent _attackCanceledEvent;
+
+        private ICompositeCondition _mustCancelAttack;
+
+        public void OnInit(Entity entity)
+        {
+            _inAttackProcess = entity.InAttackProcess;
+            _attackCanceledEvent = entity.AttackCanceledEvent;
+
+            _mustCancelAttack = entity.MustCancelAttack;
+        }
+
+        public void OnUpdate(float deltaTime)
+        {
+            if (_inAttackProcess.Value == false)
+                return;
+
+            if (_mustCancelAttack.Evaluate())
+            {
+                _inAttackProcess.Value = false;
+                _attackCanceledEvent.Invoke();
+            }
+        }
+    }
+}

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/Systems/Base/AttackCancelSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: afac0aa4f8e842d08a5326a7c89bcd53
+timeCreated: 1771693765

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/Systems/Base/AttackCooldownTimerSystem.cs

@@ -0,0 +1,53 @@
+using System;
+using _Project.Develop.Runtime.Entities;
+using _Project.Develop.Runtime.Utils.ReactiveManagement;
+using _Project.Develop.Runtime.Utils.ReactiveManagement.Event;
+using UnityEngine;
+
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.Systems
+{
+    public class AttackCooldownTimerSystem : IInitializableSystem, IUpdatableSystem, IDisposableSystem
+    {
+        private ReactiveVariable<float> _currentTime;
+        private ReactiveVariable<float> _initialTime;
+        private ReactiveVariable<bool> _inAttackCooldown;
+
+        private ReactiveEvent _endAttackEvent;
+
+        private IDisposable _endAttackEventDisposable;
+
+        public void OnInit(Entity entity)
+        {
+            _currentTime = entity.AttackCooldownCurrentTime;
+            _initialTime = entity.AttackCooldownInitialTime;
+            _inAttackCooldown = entity.InAttackCooldown;
+            _endAttackEvent = entity.EndAttackEvent;
+
+            _endAttackEventDisposable = _endAttackEvent.Subscribe(OnEndAttack);
+        }
+
+        private void OnEndAttack()
+        {
+            _currentTime.Value = _initialTime.Value;
+            _inAttackCooldown.Value = true;
+        }
+
+        public void OnUpdate(float deltaTime)
+        {
+            if (_inAttackCooldown.Value == false)
+                return;
+
+            _currentTime.Value -= deltaTime;
+
+            if (CooldownIsOver())
+                _inAttackCooldown.Value = false;
+        }
+
+        private bool CooldownIsOver() => _currentTime.Value <= 0;
+
+        public void OnDispose()
+        {
+            _endAttackEventDisposable.Dispose();
+        }
+    }
+}

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/Systems/Base/AttackCooldownTimerSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 781d9ce92c044a06b9279a90539e041b
+timeCreated: 1771693960

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/Systems/Base/StartAttackSystem.cs

@@ -32,6 +32,11 @@ namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.Systems
             {
                 _inAttackProcess.Value = true;
                 _startAttackEvent.Invoke();
+                Debug.Log("Старт атаки");
+            }
+            else
+            {
+                Debug.Log("Не могу атаковать!");
             }
         }
 

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/Systems/Shoot/InstantShootSystem.cs

@@ -0,0 +1,50 @@
+using System;
+using _Project.Develop.Runtime.Entities;
+using _Project.Develop.Runtime.Utils.ReactiveManagement;
+using _Project.Develop.Runtime.Utils.ReactiveManagement.Event;
+using UnityEngine;
+
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Attack.Systems.Shoot
+{
+    public class InstantShootSystem : IInitializableSystem, IDisposableSystem
+    {
+        private readonly EntitiesFactory _entitiesFactory;
+
+        private ReactiveEvent _attackDelayEndEvent;
+        
+        private Entity _entity;
+
+        private ReactiveVariable<float> _damage;
+        private Transform _shootPoint;
+
+        private IDisposable _attackDelayEndDisposable;
+
+        public InstantShootSystem(EntitiesFactory entitiesFactory)
+        {
+            _entitiesFactory = entitiesFactory;
+        }
+
+        public void OnInit(Entity entity)
+        {
+            _entity = entity;
+
+            _attackDelayEndEvent = entity.AttackDelayEndEvent;
+
+            _damage = entity.InstantAttackDamage;
+            _shootPoint = entity.ShootPoint;
+
+            _attackDelayEndDisposable = _attackDelayEndEvent.Subscribe(OnAttackDelayEnd);
+        }
+
+        private void OnAttackDelayEnd()
+        {
+            _entitiesFactory.CreateProjectile(_shootPoint.position, _shootPoint.forward, _damage.Value);
+        }
+
+        public void OnDispose()
+        {
+            _attackDelayEndDisposable.Dispose();
+        }
+
+    }
+}

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Attack/Systems/Shoot/InstantShootSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8380bd6de9cc46cdbb48f281c3ce660e
+timeCreated: 1771693051

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Input/AttackByInputSystem.cs

@@ -0,0 +1,36 @@
+using _Project.Develop.Runtime.Entities;
+using _Project.Develop.Runtime.Utils.InputManagement;
+using _Project.Develop.Runtime.Utils.ReactiveManagement.Event;
+using UnityEngine;
+
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Input
+{
+    public class AttackByInputSystem : IInitializableSystem, IDisposableSystem
+    {
+        private readonly IPlayerInput _playerInput;
+        
+        private ReactiveEvent _startAttackRequest;
+
+        public AttackByInputSystem(IPlayerInput playerInput)
+        {
+            _playerInput = playerInput;
+        }
+
+        public void OnInit(Entity entity)
+        {
+            _startAttackRequest = entity.StartAttackRequest;
+
+            _playerInput.Interact.Enter += OnAttackRequest;
+        }
+
+        private void OnAttackRequest(float value)
+        {
+            _startAttackRequest.Invoke();
+        }
+
+        public void OnDispose()
+        {
+            _playerInput.Interact.Enter -= OnAttackRequest;
+        }
+    }
+}

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Input/AttackByInputSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3b9a5877786f409aa00af044e4b0ab10
+timeCreated: 1771695880

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Input/MoveDirectionByInputSystem.cs

@@ -3,7 +3,7 @@ using _Project.Develop.Runtime.Utils.InputManagement;
 using _Project.Develop.Runtime.Utils.ReactiveManagement;
 using UnityEngine;
 
-namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Movement
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Input
 {
     public class MoveDirectionByInputSystem : IInitializableSystem, IUpdatableSystem
     {

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Input/RotateDirectionByMoveInputSystem.cs

@@ -3,7 +3,7 @@ using _Project.Develop.Runtime.Utils.InputManagement;
 using _Project.Develop.Runtime.Utils.ReactiveManagement;
 using UnityEngine;
 
-namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Movement
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Input
 {
     public class RotateDirectionByMoveInputSystem : IInitializableSystem, IUpdatableSystem
     {

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Movement/Systems/TransformRotationSystem.cs

@@ -1,4 +1,5 @@
 using _Project.Develop.Runtime.Entities;
+using _Project.Develop.Runtime.Utilities.Conditions;
 using _Project.Develop.Runtime.Utils.ReactiveManagement;
 using UnityEngine;
 
@@ -9,6 +10,7 @@ namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Movement
         private ReactiveVariable<Vector3> _direction;
         private ReactiveVariable<float> _speed;
         private Transform _transform;
+        private ICompositeCondition _canRotate;
         
         private const float DeadZone = 0.1f;
 
@@ -17,10 +19,17 @@ namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Movement
             _direction = entity.RotateDirection;
             _speed = entity.RotationSpeed;
             _transform = entity.Transform;
+            _canRotate = entity.CanRotate;
+            
+            if (_direction.Value != Vector3.zero)
+                _transform.rotation = Quaternion.LookRotation(_direction.Value.normalized);
         }
 
         public void OnUpdate(float deltaTime)
         {
+            if (_canRotate.Evaluate() == false)
+                return;
+            
             if (_direction.Value.magnitude < DeadZone)
                 return;
             

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Sensors/Systems/DeathMaskTouchDetectorSystem.cs

@@ -0,0 +1,37 @@
+using _Project.Develop.Runtime.Entities;
+using _Project.Develop.Runtime.Utilities;
+using _Project.Develop.Runtime.Utils.ReactiveManagement;
+using UnityEngine;
+
+namespace _Project.Develop.Runtime.Logic.Gameplay.Features.Sensors.Systems
+{
+    public class DeathMaskTouchDetectorSystem : IInitializableSystem, IUpdatableSystem
+    {
+        private Buffer<Collider> _contacts;
+        private ReactiveVariable<bool> _isTouchDeathMask;
+        private LayerMask _deathMask;
+
+        public void OnInit(Entity entity)
+        {
+            _contacts = entity.ContactCollidersBuffer;
+            _isTouchDeathMask = entity.IsTouchDeathMask;
+            _deathMask = entity.DeathMask;
+        }
+
+        public void OnUpdate(float deltaTime)
+        {
+            for (int i = 0; i < _contacts.Count; i++)
+            {
+                if (MatchWithDeathLayer(_contacts.Items[i]))
+                {
+                    _isTouchDeathMask.Value = true;
+                    return;
+                }
+            }
+
+            _isTouchDeathMask.Value = false;
+        }
+
+        private bool MatchWithDeathLayer(Collider collider) => ((1 << collider.gameObject.layer) & _deathMask) != 0;
+    }
+}

Assets/_Project/Develop/Runtime/Logic/Gameplay/Features/Sensors/Systems/DeathMaskTouchDetectorSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3d117def644741f292aef71042b65c6b
+timeCreated: 1771695342