Exemple #1
0
        public override Activity Tick(Actor self)
        {
            turnActivity = moveActivity = null;
            attackStatus = AttackStatus.UnableToAttack;

            foreach (var attack in attackTraits.Where(x => !x.IsTraitDisabled))
            {
                var status = TickAttack(self, attack);
                attack.IsAniming = status == AttackStatus.Attacking || status == AttackStatus.NeedsToTurn;
            }

            if (attackStatus.HasFlag(AttackStatus.Attacking))
            {
                return(this);
            }

            if (attackStatus.HasFlag(AttackStatus.NeedsToTurn))
            {
                return(turnActivity);
            }

            if (attackStatus.HasFlag(AttackStatus.NeedsToMove))
            {
                return(moveActivity);
            }

            return(NextActivity);
        }
Exemple #2
0
 public AttackResult(Vector2Int attackerPosition, Vector2Int defenderPosition, int damageDealt, AttackStatus attackStatus)
 {
     mAttackerPosition = attackerPosition;
     mDefenderPosition = defenderPosition;
     mAttackStatus     = attackStatus;
     mDamageDealt      = damageDealt;
 }
Exemple #3
0
    protected override void Initialize(FSMEvent ev = null)
    {
        _eventAttackCross = ev as AnimFSMEventAttackCross;

        _attackStatus = AttackStatus.PREPARING;
        Agent.BlackBoard.motionType = MotionType.ATTACK;
        _startRotation = Agent.Transform.rotation;
        _startPosition = Agent.Transform.position;

        if (_eventAttackCross.target != null)
        {
            float   angle    = 0;
            float   distance = 0;
            Vector3 dir      = _eventAttackCross.target.Position - Agent.Transform.position;
            distance = dir.magnitude;
            if (distance > 0.1f)
            {
                dir.Normalize();
                angle = Vector3.Angle(Agent.Transform.forward, dir);
                if (angle < 40 && Vector3.Angle(Agent.Forward, _eventAttackCross.target.Forward) < 80)
                {
                    _backHit = true;
                }
            }
            else
            {
                dir = Agent.Transform.forward;
            }

            _finalRotation.SetLookRotation(dir);

            if (distance < Agent.BlackBoard.weaponRange)
            {
                _finalPosition = _startPosition;
            }
            else
            {
                _finalPosition = _eventAttackCross.target.transform.position - dir * Agent.BlackBoard.weaponRange;
            }

            _moveTime     = (_finalPosition - _startPosition).magnitude / 20.0f;
            _rotationTime = angle / 720.0f;
        }
        else
        {
            _finalRotation.SetLookRotation(_eventAttackCross.attackDir);
            _rotationTime = Vector3.Angle(Agent.Transform.forward, _eventAttackCross.attackDir) / 720.0f;
            _moveTime     = 0;
        }

        _rotationOk          = (_rotationTime == 0);
        _positionOK          = (_moveTime == 0);
        _currentRotationTime = 0;
        _currentMoveTime     = 0;

        _isCritical = IsCritical();
        _knockdown  = IsKnockDown();

        _remainAttackCount = 2;
    }
 public void AttackToPlayer(AttackStatus attack_status)
 {
     if (attack_status == AttackStatus.Fire)
     {
         enemy_boss_controller.GunHold      = true;
         enemy_boss_controller.GunAttack    = true;
         enemy_boss_controller.StrikeAttack = false;
         enemy_boss_controller.KickAttack   = false;
     }
     else if (attack_status == AttackStatus.Kick)
     {
         enemy_boss_controller.KickAttack   = true;
         enemy_boss_controller.StrikeAttack = false;
         enemy_boss_controller.GunHold      = false;
         enemy_boss_controller.GunAttack    = false;
     }
     else if (attack_status == AttackStatus.Strike)
     {
         enemy_boss_controller.StrikeAttack = true;
         enemy_boss_controller.KickAttack   = false;
         enemy_boss_controller.GunHold      = false;
         enemy_boss_controller.GunAttack    = false;
     }
     else if (attack_status == AttackStatus.None)
     {
         enemy_boss_controller.GunHold      = false;
         enemy_boss_controller.GunAttack    = false;
         enemy_boss_controller.KickAttack   = false;
         enemy_boss_controller.StrikeAttack = false;
     }
 }
Exemple #5
0
    void SwitchATKStatus(AttackStatus _status)
    {
        if (mAtkStatus == _status)
        {
            return;
        }
        mAtkStatus = _status;
        mAnim.SetBool("InBoxRange", false);
        mAnim.SetBool("InSwingRange", false);
        switch (mAtkStatus)
        {
        case AttackStatus.boxing:
            weapon.SetActive(false);
            mAnim.SetBool("InBoxRange", true);
            break;

        case AttackStatus.swing:
            weapon.SetActive(true);
            mAnim.SetBool("InSwingRange", true);
            break;

        default:
            break;
        }
    }
Exemple #6
0
        private void Setup()
        {
            _shipLength = 1;
            _ship       = LongShip.CreateShip(_shipLength);

            _defaultStatus = AttackStatus.NotAttacked;
            _position      = new Position("A", 1);
            _location      = BasicLocation.CreateLocation(_position);
        }
Exemple #7
0
    public void setStatusToAttackTypeMental()
    {
        status = AttackStatus.ATTACK_TYPE_MENTAL;
        UIAttackType.SetActive(false);
        UIAttackMentalTarget.SetActive(true);
        UIAttackPhysicalTarget.SetActive(false);
        UIAttack.SetActive(false);

        statusText.GetComponent <Text>().text = MentalTargetString;
    }
Exemple #8
0
    public void setStatusToAttacking()
    {
        status = AttackStatus.ATTACKING;
        UIAttackType.SetActive(false);
        UIAttackMentalTarget.SetActive(false);
        UIAttackPhysicalTarget.SetActive(false);
        UIAttack.SetActive(false);

        statusText.GetComponent <Text>().text = AttackingString;
    }
Exemple #9
0
        public void Finish()
        {
            if (Status == AttackStatus.Finished)
                return;

            Status = AttackStatus.Finished;

            if (OnFinish != null)
                OnFinish.Invoke();
        }
Exemple #10
0
        public void Finish()
        {
            if (Status == AttackStatus.Finished)
            {
                return;
            }

            Status = AttackStatus.Finished;

            if (OnFinish != null)
            {
                OnFinish.Invoke();
            }
        }
Exemple #11
0
 // 阻挡开始
 private void BlockStart()
 {
     if (attackStatus == AttackStatus.AFTER_ATTACK)
     {
         if (originalData.isEnemy)
         {
             attackStatus = AttackStatus.CONFIRM_ENEMY;
         }
         else
         {
         }
     }
     blockStatus = BlockStatus.BLOCKING;
 }
Exemple #12
0
 private void MoveToTarget(Vector3 trg)
 {
     if (lastRecalTime < Time.time + DELTA_RECALC)
     {
         trg = new Vector3(trg.x, owner.transform.position.y, trg.z);
         lastTargetScanPos = trg;
         trg = ClaclNearTargetPosition(trg);
         if ( /*isTooClose && */owner.Control.MoveTo(trg))
         {
             lastRecalTime = Time.time;
             moveTarget = trg;
             attackStatus = AttackStatus.move;
         }
     }
 }
Exemple #13
0
    public void setStatusToAttackType()
    {
        status = AttackStatus.ATTACK_TYPE;
        UIAttackType.SetActive(true);
        UIAttackMentalTarget.SetActive(false);
        UIAttackPhysicalTarget.SetActive(false);
        UIAttack.SetActive(false);

        statusText.GetComponent <Text>().text       = AttackTypeSelectString;
        attackTypeText.GetComponent <Text>().text   = "";
        attackTargetText.GetComponent <Text>().text = "";

        attackType         = AttackType.NONE;
        attackTypeMental   = AttackTypeMental.NONE;
        attackTypePhysical = AttackTypePhysical.NONE;
    }
Exemple #14
0
    private void ShowAttackBubble(AttackStatus status)
    {
        switch (status)
        {
        case AttackStatus.HIT:
            hitBubble.SetActive(true);
            break;

        case AttackStatus.MISS:
            missBubble.SetActive(true);
            break;

        case AttackStatus.CRIT:
            critBubble.SetActive(true);
            break;
        }
        Invoke("HideAttackBubbles", 1.2f);
    }
Exemple #15
0
    private void MoveToTarget(Vector3 trg)
    {
        if (lastRecalTime < Time.time + DELTA_RECALC)
        {
            trg = new Vector3(trg.x, owner.transform.position.y, trg.z);
            lastTargetScanPos = trg;

//        bool isTooClose = true;
            trg = ClaclNearTargetPosition(trg);
//        isTooClose = (moveTarget - trg).sqrMagnitude > 1;
//            Debug.Log("Start move to target " + trg);
            if ( /*isTooClose && */owner.Control.MoveTo(trg))
            {
                lastRecalTime = Time.time;
                moveTarget = trg;
                attackStatus = AttackStatus.move;
            }
        }
    }
Exemple #16
0
        public static string ToMessage(this AttackStatus status, string attacker, string target, int damage)
        {
            switch (status)
            {
            case AttackStatus.Normal:
                return(string.Format(DougMessages.UserAttackedTarget, attacker, target, damage));

            case AttackStatus.Critical:
                return(string.Format(DougMessages.CriticalHit, attacker, target, damage));

            case AttackStatus.Missed:
                return(string.Format(DougMessages.Missed, attacker, target));

            case AttackStatus.Invincible:
                return(string.Format(DougMessages.UserIsInvincible, target));

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Exemple #17
0
        public override Activity Tick(Actor self)
        {
            turnActivity = moveActivity = null;
            attackStatus = AttackStatus.UnableToAttack;

            foreach (var attack in attackTraits.Where(x => !x.IsTraitDisabled))
            {
                var activity = InnerTick(self, attack);
                attack.IsAttacking = activity == this;
            }

            if (attackStatus.HasFlag(AttackStatus.Attacking))
                return this;

            if (attackStatus.HasFlag(AttackStatus.NeedsToTurn))
                return turnActivity;

            if (attackStatus.HasFlag(AttackStatus.NeedsToMove))
                return moveActivity;

            return NextActivity;
        }
Exemple #18
0
        public static AttackStatus Stab(Lobby lobby, Player player)
        {
            var stabResult = new AttackStatus
            {
                CurrentPlayer = player
            };
            var target = MazeLogic.PlayersOnCell(player, lobby)?.FirstOrDefault();

            stabResult.PickChest = LootChest(lobby, player);
            if (target == null)
            {
                stabResult.Result = AttackType.NoAttack;
                return(stabResult);
            }
            stabResult.Target = target;
            if (target.Chest != null)
            {
                DropChest(lobby, target);
            }
            if (target.Health > 1)
            {
                target.Health--;
                stabResult.Result = AttackType.Hit;
                return(stabResult);
            }
            else
            {
                KillPlayer(lobby, target);
            }

            //TODO: Добавить победу
            //TODO: А еще лучше писать метод, который будет определять, что остался один игрок
            //stabResult.IsGameEnd ==...
            KillPlayer(lobby, target);
            //lobby.Players.Remove(target);
            stabResult.Result = AttackType.Kill;
            return(stabResult);
        }
    public override void OnUpdate()
    {
        if (_attackStatus == AttackStatus.PREPARING)
        {
            bool dontMove = false;
            if (_rotationOk == false)
            {
                _currentRotationTime += Time.deltaTime;
                if (_currentRotationTime >= _rotationTime)
                {
                    _currentRotationTime = _rotationTime;
                    _rotationOk          = true;
                }
                float      progress = _currentRotationTime / _rotationTime;
                Quaternion rotation = Quaternion.Lerp(_startRotation, _finalRotation, progress);
                Agent.Transform.rotation = rotation;
            }

            if (_positionOK == false)
            {
                _currentMoveTime += Time.deltaTime;
                if (_currentMoveTime >= _moveTime)
                {
                    _currentMoveTime = _moveTime;
                    _positionOK      = true;
                    ParticleTools.Instance.Stop(Agent.particleSystemFlashTust);
                }

                if (_currentMoveTime > 0)
                {
                    float   progress = _currentMoveTime / _moveTime;
                    Vector3 finalPos = Mathfx.Hermite(_startPosition, _finalPosition, progress);
                    //if (MoveToCollideWithEnemy(finalPos, Transform.forward) == false)
                    if (TransformTools.Instance.MoveOnGround(Agent.transform, Agent.CharacterController,
                                                             finalPos - Agent.Transform.position, true) == false)
                    {
                        _positionOK = true;
                        ParticleTools.Instance.Stop(Agent.particleSystemFlashTust);
                    }
                }
            }

            if (_rotationOk && _positionOK)
            {
                _attackStatus = AttackStatus.ATTACKING;
                InitializeAttacking();
            }
        }
        else if (_attackStatus == AttackStatus.ATTACKING)
        {
            _currentMoveTime += Time.deltaTime;
            if (_attackPhaseTime < Time.timeSinceLevelLoad)
            {
                //Debug.Log(Time.timeSinceLevelLoad + " attack phase done");
                _eventAttackMelee.attackPhaseDone = true;
                _attackStatus = AttackStatus.FINISHED;
            }

            if (_currentMoveTime >= _moveTime)
            {
                _currentMoveTime = _moveTime;
            }

            if (_currentMoveTime > 0 && _currentMoveTime <= _moveTime)
            {
                float   progress = Mathf.Min(1.0f, _currentMoveTime / _moveTime);
                Vector3 finalPos = Mathfx.Hermite(_startPosition, _finalPosition, progress);
                //if (MoveToCollideWithEnemy(finalPos, Transform.forward) == false)
                if (TransformTools.Instance.MoveOnGround(Agent.transform, Agent.CharacterController,
                                                         finalPos - Agent.Transform.position, false) == false)
                {
                    _currentMoveTime = _moveTime;
                }
            }

            if (_hitTimeStart == false && _hitTime <= Time.timeSinceLevelLoad)
            {
                _hitTimeStart = true;
                HandleAttackResult.DoMeleeDamage(Agent, _eventAttackMelee.target, Agent.BlackBoard.attackerWeapon,
                                                 _eventAttackMelee.animAttackData, _isCritical, _knockdown,
                                                 _eventAttackMelee.animAttackData.isFatal);

                // 显示刀光(方案1:美术做好mesh,参见player)
                if (_eventAttackMelee.animAttackData.lastAttackInCombo)
                {
                    HandleTrail.ShowTrail(Agent, _eventAttackMelee.animAttackData, 0.4f);
                }
                else
                {
                    HandleTrail.ShowTrail(Agent, _eventAttackMelee.animAttackData, 0.5f);
                }

                /*// 屏幕震动
                 * if (AnimAttackData.LastAttackInCombo || AnimAttackData.ComboStep == 3)
                 *  CameraBehaviour.Instance.ComboShake(AnimAttackData.ComboStep - 3);
                 *
                 * if (Owner.IsPlayer && AnimAttackData.FullCombo)
                 *  GuiManager.Instance.ShowComboMessage(AnimAttackData.ComboIndex);*/
            }
        }
        else if (_attackStatus == AttackStatus.FINISHED && _endOfStateTime <= Time.timeSinceLevelLoad)
        {
            IsFinished = true;
            _eventAttackMelee.IsFinished = true;
        }
    }
Exemple #20
0
    public override void OnUpdate()
    {
        if (_attackStatus == AttackStatus.PREPARING)
        {
            bool dontMove = false;
            if (_rotationOk == false)
            {
                _currentRotationTime += Time.deltaTime;
                if (_currentRotationTime >= _rotationTime)
                {
                    _currentRotationTime = _rotationTime;
                    _rotationOk          = true;
                }
                float      progress = _currentRotationTime / _rotationTime;
                Quaternion rotation = Quaternion.Lerp(_startRotation, _finalRotation, progress);
                Agent.Transform.rotation = rotation;
            }

            if (_positionOK == false)
            {
                _currentMoveTime += Time.deltaTime;
                if (_currentMoveTime >= _moveTime)
                {
                    _currentMoveTime = _moveTime;
                    _positionOK      = true;
                }

                if (_currentMoveTime > 0)
                {
                    float   progress = _currentMoveTime / _moveTime;
                    Vector3 finalPos = Mathfx.Hermite(_startPosition, _finalPosition, progress);
                    //if (MoveToCollideWithEnemy(finalPos, Transform.forward) == false)
                    if (TransformTools.MoveOnGround(Agent.transform, Agent.CharacterController,
                                                    finalPos - Agent.Transform.position, true) == false)
                    {
                        _positionOK = true;
                    }
                }
            }

            if (_rotationOk && _positionOK)
            {
                _attackStatus = AttackStatus.ATTACKING;
                InitializeAttacking();
            }
        }
        else if (_attackStatus == AttackStatus.ATTACKING)
        {
            _currentMoveTime += Time.deltaTime;
            if (_currentMoveTime >= _moveTime)
            {
                _currentMoveTime = _moveTime;
            }

            if (_currentMoveTime > 0 && _currentMoveTime <= _moveTime)
            {
                float   progress = Mathf.Min(1.0f, _currentMoveTime / _moveTime);
                Vector3 finalPos = Mathfx.Hermite(_startPosition, _finalPosition, progress);
                //if (MoveToCollideWithEnemy(finalPos, Transform.forward) == false)
                if (TransformTools.MoveOnGround(Agent.transform, Agent.CharacterController,
                                                finalPos - Agent.Transform.position, false) == false)
                {
                    _currentMoveTime = _moveTime;
                }
            }

            if (_hitTimeStart == false && _hitTime <= Time.timeSinceLevelLoad)
            {
                _hitTimeStart = true;
                HandleAttackResult.DoMeleeDamage(Agent, _eventAttackCross.target, Agent.BlackBoard.attackerWeapon,
                                                 _eventAttackCross.animAttackData, _isCritical, _knockdown,
                                                 _eventAttackCross.animAttackData.isFatal);
            }

            if (_attackPhaseTime < Time.timeSinceLevelLoad)
            {
                if (--_remainAttackCount > 0)
                {
                    // 再次攻击
                    InitializeAttacking(false);
                }
                else
                {
                    _attackStatus = AttackStatus.FINISHED;
                }
            }
        }
        else if (_attackStatus == AttackStatus.FINISHED && _endOfStateTime <= Time.timeSinceLevelLoad)
        {
            //Debug.Log(Time.timeSinceLevelLoad + " attack finished");
            IsFinished = true;
            _eventAttackCross.IsFinished = true;
        }
    }
Exemple #21
0
 public void Inited()
 {
     Status = AttackStatus.Inited;
 }
Exemple #22
0
 public void Charge()
 {
     Status = AttackStatus.Charge;
 }
Exemple #23
0
		public virtual int RangedHit( Mobile m, float dmgBonus,bool pass, ref int amountBlocked, ref int amountAbsorbed )
		{
			Item weapon = this.RangedWeapon;
			Item ammo = this.RangedAmmo;
			if(weapon != null)
			{
				if (this is Character)
					if(weapon.InventoryType == InventoryTypes.Thrown)
					{
						(this as Character).ConsumeItemByIdUpTo(weapon.Id,1);
					}
					else
					{
						(this as Character).ConsumeItemByIdUpTo(ammo.Id,1);
					}
					
			
				float critChance = RangedCriticalChanceCalculation(weapon,m);
				float dif = SkillDifCalculation(weapon,m);
				float hitChance = RangedHitChanceCalculation(weapon,m,dif);
		
				bool criticalStrike = false;
			
				#region critical and hit test
				int roll =Utility.Random( 100 );	
				bool test = false;

				if ((int)critChance >= roll || test)
				{
					#region Critical hit trigger done
					ArrayList al = new ArrayList();
					ArrayList pal = new ArrayList();
					foreach( AuraReleaseTimer art in aura )
					{
						int a = art.aura.OnCriticalHit;
						if ( a != -1 )
							al.Add( art );
					}
					foreach( PermanentAura art in permanentAura )
					{
						int a = art.aura.OnCriticalHit;
						if ( a != -1 )
							al.Add( art );
					}
					foreach( object obj in al )
					{
						if(obj is AuraReleaseTimer)
						{ 
							AuraReleaseTimer art = (AuraReleaseTimer)obj;
							int a = art.aura.OnCriticalHit;
							if ( a != -1 )
								if(Triggers[ a ] != null)
									( Triggers[ a ] as OnCriticalHitTrigger )( this, m, art.ae );
						}
						if(obj is PermanentAura)
						{ 
							PermanentAura art = (PermanentAura)obj;
							int a = art.aura.OnCriticalHit;
							if ( a != -1 )
								if(Triggers[ a ] != null)
									( Triggers[ a ] as OnCriticalHitTrigger )( this, m, Abilities.abilities[(int)art.Id] );
						}
					}
					#endregion
				
					#region Critical hit done Triggers
					ArrayList al2 = new ArrayList();
					ArrayList pal2 = new ArrayList();
					foreach( AuraReleaseTimer art in aura )
					{
						int a = art.aura.OnCriticalHitDone;
						if ( a != -1 )
							al2.Add( art );
					}
					foreach( PermanentAura art in permanentAura)
					{
						int a = art.aura.OnCriticalHitDone;
						if ( a != -1 )
							pal2.Add( art );
					}
					foreach( object obj in al2 )
					{
						if(obj is AuraReleaseTimer)
						{ 
							AuraReleaseTimer art = (AuraReleaseTimer)obj;
					
							int a = art.aura.OnCriticalHitDone;
							if ( a != -1 )
								if(Triggers[ a ] != null) 
									( Triggers[ a ] as OnCriticalHitDoneTrigger )(this, m, art.ae );
						}
						if(obj is PermanentAura)
						{ 
							PermanentAura art = (PermanentAura)obj;
							int a = art.aura.OnCriticalHitDone;
							if ( a != -1 )
								if(Triggers[ a ] != null)
									( Triggers[ a ] as OnCriticalHitDoneTrigger )(this, m, Abilities.abilities[(int)art.Id] );
						}
					}
					#endregion
			
					/*bovie*/
					
					/*bovie*/	
					lastAttack = AttackStatus.Critical;
					m.lastAttackToMe = AttackStatus.Critical;
					criticalStrike = true;
				}
				else if((int)hitChance >= roll)
				{
					lastAttack = AttackStatus.NormalHit;
					m.lastAttackToMe = AttackStatus.NormalHit;
				}
				else 
				{
					lastAttack = AttackStatus.Loose;
					m.lastAttackToMe = AttackStatus.Loose;
					return 0;
				}
				#endregion

				if (!pass)
				{
					float dodgeChance = RangedDodgeChanceCalculation(m,dif);
	
					#region Dodge test
					roll = Utility.Random( 100 );
					if (dodgeChance >= roll)
					{
						lastAttack = AttackStatus.Dodge;
						m.lastAttackToMe = AttackStatus.Dodge;
						return 0;	
					}
					#endregion
				}


				float damage = RangedDamageDoneCalculation(m,dmgBonus,criticalStrike,weapon);
				float blockChance = RangedBlockChanceCalculation(m,dif);
				if (!pass)
				{
					#region Block test + block reduction	
					roll = Utility.Random( 100 );
				
					if (blockChance >= roll)
					{
						lastAttack = AttackStatus.Block;
						m.lastAttackToMe = AttackStatus.Block;
						amountBlocked = m.Block + m.Str/30;
						damage -= amountBlocked;
						#region talents
						// shield specialization
						if ( m.HaveTalent(Talents.ShieldSpecialization) )
						{
							AuraEffect af = (AuraEffect)m.GetTalentEffect(Talents.ShieldSpecialization);
							roll = Utility.Random( 100 );
							if ( roll < af.H )
							{
								m.GainMana(m,(Abilities.abilities[af.AdditionalSpell] as SpellTemplate).S1);
							}
						}
						#endregion
					}
		
					#endregion
				}
				#region Armor reduction
				float armor = ArmorReductionCalculation(m); 
				damage = damage * (1 - armor);
				#endregion

				#region immune
				if (m.ImmunePhysicalDamage)
				{
					lastAttack = AttackStatus.Immune;
					m.lastAttackToMe = AttackStatus.Immune;
					return 0;
				}
				#endregion
			
				#region absorb
				damage =(int)m.DamageAbsorbCombat(damage);
				if ( damage < 0 )
				{
					this.lastAttack = AttackStatus.Absorb;
					m.lastAttackToMe = AttackStatus.Absorb;	
					return 0;
				}
				#endregion

				#region Targets modificators 
				damage = RangedDamageTakenCalculation(m,damage);
				#endregion
				damage = m.ManaShieldLost(this,(int)damage);
				#region other effects
			
				switch (this.Classe)
				{
						#region warrior
					case Classes.Warrior:
					
						if ( this.HaveTalent( Talents.UnbridledWrath) )
						{
							AuraEffect ae = (AuraEffect)this.GetTalentEffect( Talents.UnbridledWrath );
							roll = Utility.Random( 100 );
							if(roll < ae.H)
							{
								this.GainMana(this,1);
							}
						}
					
						break;
						#endregion
				}
				#endregion

				if ( damage > 0 && this is Character)
					this.SkillUpWeapon(weapon);
				return (int)damage;
			}
			else 
				return 0;
		}
Exemple #24
0
 public void Start()
 {
     this.attackStatus = AttackStatus.Attacking;
 }
Exemple #25
0
 public void Pause()
 {
     this.attackStatus = AttackStatus.Stopping;
 }
Exemple #26
0
        protected virtual Activity InnerTick(Actor self, AttackBase attack)
        {
            if (IsCanceled)
                return NextActivity;

            var type = Target.Type;
            if (!Target.IsValidFor(self) || type == TargetType.FrozenActor)
                return NextActivity;

            if (attack.Info.AttackRequiresEnteringCell && !positionable.CanEnterCell(Target.Actor.Location, null, false))
                return NextActivity;

            // Drop the target if it moves under the shroud / fog.
            // HACK: This would otherwise break targeting frozen actors
            // The problem is that Shroud.IsTargetable returns false (as it should) for
            // frozen actors, but we do want to explicitly target the underlying actor here.
            if (!attack.Info.IgnoresVisibility && type == TargetType.Actor && !Target.Actor.Info.HasTraitInfo<FrozenUnderFogInfo>() && !self.Owner.CanTargetActor(Target.Actor))
                return NextActivity;

            // Drop the target once none of the weapons are effective against it
            var armaments = attack.ChooseArmamentsForTarget(Target, forceAttack).ToList();
            if (armaments.Count == 0)
                return NextActivity;

            // Update ranges
            minRange = armaments.Max(a => a.Weapon.MinRange);
            maxRange = armaments.Min(a => a.MaxRange());

            if (!Target.IsInRange(self.CenterPosition, maxRange) || Target.IsInRange(self.CenterPosition, minRange))
            {
                // Try to move within range, drop the target otherwise
                if (move == null)
                    return NextActivity;

                attackStatus |= AttackStatus.NeedsToMove;
                moveActivity = ActivityUtils.SequenceActivities(move.MoveWithinRange(Target, minRange, maxRange), this);
                return NextActivity;
            }

            var desiredFacing = (Target.CenterPosition - self.CenterPosition).Yaw.Facing;
            if (facing.Facing != desiredFacing)
            {
                attackStatus |= AttackStatus.NeedsToTurn;
                turnActivity = ActivityUtils.SequenceActivities(new Turn(self, desiredFacing), this);
                return NextActivity;
            }

            attackStatus |= AttackStatus.Attacking;
            attack.DoAttack(self, Target, armaments);

            return this;
        }
Exemple #27
0
		public void MeleeCombatSlice()
		{
			Running = true;
			if (AttackTarget != null && AttackTarget.ImmuneAttack)
			{
				if ( combatTimer != null )
					combatTimer.Stop();
				combatTimer = null;
				this.lastAttack = AttackStatus.Immune;
				return;
			}
			if ( AttackTarget == null )
			{
				if ( combatTimer != null )
					combatTimer.Stop();
				combatTimer = null;
				return;
			}
			if ( AttackTarget.HitPoints > 0 && HitPoints > 0 )
			{
				UpdateXYZ();
				if ( !( AttackTarget is Character ) )
					AttackTarget.UpdateXYZ();
				float dist = Distance( AttackTarget );
				//	Console.WriteLine("target {0},{1},{2} dist = {3}", AttackTarget.X, AttackTarget.Y, AttackTarget.Z, dist );
				//	Console.WriteLine("from   {0},{1},{2} dist = {3}", X, Y, Z, dist );
				if ( dist > combatReach && dist < 8 * ( combatReach + AttackTarget.CombatReach ) )
				{
					if(this.AttackTarget != null)
						{
										
							ArrayList NAEbuff = (ArrayList)NextAttackEffects.Clone();
							foreach(NextAttackEffect nae in NAEbuff)
							{
						
								this.OnSpellTemplateResults(nae.spell,this.AttackTarget);
								this.NextAttackSpellGo(nae);
						
							}
					
							NAEbuff.Clear();
						}

					//FaitFace( target );
					int amountAbsorbed = 0;
					int amountBlocked = 0;
					int degats = Hit( AttackTarget, ref amountAbsorbed, ref amountBlocked );

					AIState = AIStates.Fighting;
					MoveTo( (float)( X + ( AttackTarget.X - X ) * 0.02f ), (float)( Y + ( AttackTarget.Y - Y ) * 0.02f ), (float)( AttackTarget.Z ) );

					int offset = 4;
					if ( degats <= 0 )
						Converter.ToBytes( 0x22, tempBuff, ref offset );
					else
						Converter.ToBytes( 0x22, tempBuff, ref offset );
	
					Converter.ToBytes( Guid, tempBuff, ref offset );
					Converter.ToBytes( AttackTarget.Guid, tempBuff, ref offset );
					if ( degats < 0 )
						Converter.ToBytes( 0, tempBuff, ref offset );
					else
						Converter.ToBytes( degats, tempBuff, ref offset );
					Converter.ToBytes( (byte)1, tempBuff, ref offset );
					Converter.ToBytes( 0, tempBuff, ref offset );
					if ( degats > 0 )
						Converter.ToBytes( (float)degats/*DamageType*/, tempBuff, ref offset );
					else
						Converter.ToBytes( 0, tempBuff, ref offset );

			//		Converter.ToBytes( 0/*DamageType*/, tempBuff, ref offset );
					//		float ang = (float)Math.Atan2( AttackTarget.Y - Y, AttackTarget.X - X );
					if ( degats < 0 )
						Converter.ToBytes( 0, tempBuff, ref offset );
					else
						Converter.ToBytes( degats, tempBuff, ref offset );
				//	Converter.ToBytes( amountAbsorbed, tempBuff, ref offset );// damage absorbed 
				//	Converter.ToBytes( 0, tempBuff, ref offset ); // new victim state
					Converter.ToBytes( 0, tempBuff, ref offset ); // additional spell damage id
					Converter.ToBytes( 0, tempBuff, ref offset ); // additional spell damage id
					#region Degats types
					if ( degats >= 0 )
						Converter.ToBytes( 1, tempBuff, ref offset );
					else
					if ( degats == -1 )
						Converter.ToBytes( 2, tempBuff, ref offset );// dodge
					else
						if ( degats == - 2 )
						Converter.ToBytes( 9, tempBuff, ref offset );// parry
					else
						if ( degats == - 3 )
						Converter.ToBytes( 4, tempBuff, ref offset );// interrupted
					else
						if ( degats == - 4 || amountBlocked > 0 )
						Converter.ToBytes( 5, tempBuff, ref offset );// block
					else
						if ( degats == - 5 )
						Converter.ToBytes( 6, tempBuff, ref offset );// evade
					else
						if ( degats == - 6 )
						Converter.ToBytes( 7, tempBuff, ref offset );// immune
					else
						if ( degats == - 7 )
						Converter.ToBytes( 8, tempBuff, ref offset );// deflect

					#endregion
		
					if ( degats == 0 )
						Converter.ToBytes( 0xffffffff, tempBuff, ref offset );
					else
					Converter.ToBytes( 0, tempBuff, ref offset );
					Converter.ToBytes( 0, tempBuff, ref offset );
					Converter.ToBytes( 0, tempBuff, ref offset );
					//HexViewer.View( tempBuff, 0, offset );
					ToAllPlayerNear( OpCodes.SMSG_ATTACKERSTATEUPDATE, tempBuff, offset );					

					AttackTarget.LooseHits( this, degats, true );

					if ( AttackTarget.Dead )
					{
						int off = 4;
						Converter.ToBytes( Guid, tempBuff, ref off );
						Converter.ToBytes( AttackTarget.Guid, tempBuff, ref off );
						ToAllPlayerNear( OpCodes.SMSG_ATTACKSTOP, tempBuff, off );						
						if ( combatTimer != null )
							combatTimer.Stop();
						AttackTarget = null;
					}					
					
				}
				else
				{
					float less = 1.0f;
					if ( dist > 20 )
						less = 0.5f;
					double angle = (float)Math.Atan2( AttackTarget.Y - Y, AttackTarget.X - X );
					angle += Math.PI;
					MoveTo( (float)( AttackTarget.X + Math.Cos( angle ) * ( combatReach + AttackTarget.CombatReach ) * 1.5 * less ), (float)( AttackTarget.Y + Math.Sin( angle ) * ( combatReach + AttackTarget.CombatReach ) * 1.5 * less ), (float)( AttackTarget.Z ) );
					AIState = AIStates.Attack;
				}
			}
			if ( ( this as BaseCreature ).IsStillActive() )
				ChooseAttackMode();
		}
Exemple #28
0
 protected virtual void OnShootEnd(Unit obj)
 {
     attackStatus = AttackStatus.none;
     owner.OnShootEnd -= OnShootEnd;
 }
Exemple #29
0
    protected void DoShoot(bool shallStop = false)
    {
        if (target == null)
        {
            End(EndCause.no);
            return;
        }
        var dir = target.transform.position - owner.transform.position;
        dir.y = 0;
//        Debug.Log("shhot dir: " + dir);
        owner.Control.SetToDirection(dir);
        //dir = new Vector3(dir.x,owner.transform.position.y,dir.z);
//        Debug.Log("attack: " + dir + "    " + dir.sqrMagnitude);
        owner.TryAttack(dir,0, target);
        owner.OnShootEnd += OnShootEnd;
        attackStatus = AttackStatus.shoot;
        if (shallStop)
        {
            ((AgentControl)owner.Control).Stop(false);
        }
    }
Exemple #30
0
 protected virtual void MoveEnd()
 {
     attackStatus = AttackStatus.none;
  
 }
Exemple #31
0
    void StatusUpdate()
    {
        // Clarity Variables
        bool canJump   = jumpCountLeft > 0 && !(attackDurationLeft > 0) && !isGrappling;
        bool hasJumped = !(jumpCountLeft == jumpCount);

        // Moving
        isMoving           = bodyPhysics.velocity.x != 0;
        currentRunVelocity =
            !isGrounded && Mathf.Abs(bodyPhysics.velocity.x) > runVelocity?
            Mathf.Abs(bodyPhysics.velocity.x)
                :
                runVelocity
        ;

        // Jumping
        jumpCountLeft =
            isGrounded?
            jumpCount
            :
            !hasJumped?
            jumpCount - 1
                :
            jumpCountLeft
        ;
        isJumping        = jumpDurationLeft > 0;
        jumpDurationLeft =
            isJumping?
            jumpDurationLeft -= Time.deltaTime
                :
                                0
        ;
        isJumpStopping = isJumping && (!(jumpDurationLeft > 0) || !isJumpInputHeld);
        if (isJumpInputTapped && canJump)
        {
            jumpVelocity =
                isGrounded?
                groundedJumpVelocity
                :
                midairJumpVelocity
            ;
            jumpDuration =
                isGrounded ?
                groundedJumpDuration
                 :
                midairJumpDuration
            ;
            ChangeGravity(jumpGravity);
            jumpDurationLeft = jumpDuration;
            jumpCountLeft   -= 1;
        }
        if (isJumping)
        {
            Move(jumpVelocity / jumpDuration, MovementType.Jump);
        }
        if (isJumpStopping)
        {
            RevertGravity();
            float endingLength =
                isJumpInputHeld?
                jumpCompleteVelocity
                :
                jumpCancelVelocity
            ;
            Move(endingLength, MovementType.Jump);
            jumpDurationLeft = 0;
        }

        // Attacking
        attackDurationLeft -=
            isAttacking?
            !(attackDelayLeft > 0)?
            Time.deltaTime
                :
            0
            :
            attackDurationLeft
        ;
        attackDelayLeft -=
            isAttacking?
            Time.deltaTime
            :
            attackDelayLeft
        ;
        if ((isNarrowInputTapped || isWideInputTapped) && !isAttacking)
        {
            attackWeapon =
                hasSawblade?
                PlayerWeapon.Sawblade
                    :
                PlayerWeapon.Kick
            ;
            attackType =
                isNarrowInputTapped?
                AttackType.Narrow
                :
                AttackType.Wide
            ;
            attackDelayLeft =
                hasSawblade?
                shotDelay
                :
                kickDelay
            ;
            attackDurationLeft =
                !hasSawblade?
                kickDuration
                :
                attackDurationLeft
            ;
        }
        isAttacking  = isAttacking || attackDelayLeft > 0 || attackDurationLeft > 0;
        attackStatus =
            attackDelayLeft <= 0?
            AttackStatus.Fire
            :
            AttackStatus.Set
        ;
        if (isAttacking && attackStatus == AttackStatus.Fire)
        {
            if (attackWeapon == PlayerWeapon.Sawblade)
            {
                Attack(attackWeapon, attackType);
            }
            else if (attackDurationLeft == kickDuration)
            {
                Debug.Log(attackWeapon);
                Attack(attackWeapon, attackType);
            }
        }
        if (!(attackDelayLeft > 0 || attackDurationLeft > 0))
        {
            isAttacking  = false;
            attackWeapon = PlayerWeapon.None;
            attackStatus = AttackStatus.Set;
        }


        // Grapple
        isGrappling = currentGrappleVelocity != Vector2.zero && grappleObject != null;
        if (isGrappleInputTapped && grappleObject != null && !isGrappling)
        {
            Grapple(grappleObject);
        }
        else if (grappleObject == null)
        {
            currentGrappleVelocity = Vector2.zero;
        }

        // Shredder Moves
    }
Exemple #32
0
		public virtual int Hit( Mobile m, float dmgBonus,bool pass, ref int amountBlocked, ref int amountAbsorbed )
		{			
			Item weapon = activeWeapon;
			if ( Level < m.Level - 7 )
			{
				lastAttack = AttackStatus.Dodge;
				m.lastAttackToMe = AttackStatus.Dodge;
				return -1;	
			}			
			float critChance = CriticalChanceCalculation(weapon,m);
			float dif = SkillDifCalculation(weapon,m);
			float hitChance = HitChanceCalculation(weapon,m,dif);
		
			bool criticalStrike = false;
			
			#region critical and hit test
			int roll =Utility.Random( 100 );	

			if ((int)critChance >= roll )
			{
				#region Critical hit trigger done
				ArrayList al = new ArrayList();
				ArrayList pal = new ArrayList();
				foreach( AuraReleaseTimer art in aura )
				{
					int a = art.aura.OnCriticalHit;
					if ( a != -1 )
						al.Add( art );
				}
				foreach( PermanentAura art in permanentAura )
				{
					int a = art.aura.OnCriticalHit;
					if ( a != -1 )
						al.Add( art );
				}
				foreach( object obj in al )
				{
					if(obj is AuraReleaseTimer)
					{ 
						AuraReleaseTimer art = (AuraReleaseTimer)obj;
						int a = art.aura.OnCriticalHit;
						if ( a != -1 )
							if(Triggers[ a ] != null)
								( Triggers[ a ] as OnCriticalHitTrigger )( this, m, art.ae );
					}
					if(obj is PermanentAura)
					{ 
						PermanentAura art = (PermanentAura)obj;
						int a = art.aura.OnCriticalHit;
						if ( a != -1 )
							if(Triggers[ a ] != null)
								( Triggers[ a ] as OnCriticalHitTrigger )( this, m, Abilities.abilities[(int)art.Id] );
					}
				}
				#endregion
				
				#region Critical hit done Triggers
				ArrayList al2 = new ArrayList();
				ArrayList pal2 = new ArrayList();
				foreach( AuraReleaseTimer art in aura )
				{
					int a = art.aura.OnCriticalHitDone;
					if ( a != -1 )
						al2.Add( art );
				}
				foreach( PermanentAura art in permanentAura)
				{
					int a = art.aura.OnCriticalHitDone;
					if ( a != -1 )
						pal2.Add( art );
				}
				foreach( object obj in al2 )
				{
					if(obj is AuraReleaseTimer)
					{ 
						AuraReleaseTimer art = (AuraReleaseTimer)obj;
					
						int a = art.aura.OnCriticalHitDone;
						if ( a != -1 )
							if(Triggers[ a ] != null) 
								( Triggers[ a ] as OnCriticalHitDoneTrigger )(this, m, art.ae );
					}
					if(obj is PermanentAura)
					{ 
						PermanentAura art = (PermanentAura)obj;
						int a = art.aura.OnCriticalHitDone;
						if ( a != -1 )
							if(Triggers[ a ] != null)
								( Triggers[ a ] as OnCriticalHitDoneTrigger )(this, m, Abilities.abilities[(int)art.Id] );
					}
				}
				#endregion
				
					
				/*bovie*/
					
				/*bovie*/	
				lastAttack = AttackStatus.Critical;
				m.lastAttackToMe = AttackStatus.Critical;
				criticalStrike = true;
			}
			else if((int)hitChance <= roll)
			{
				lastAttack = AttackStatus.NormalHit;
				m.lastAttackToMe = AttackStatus.NormalHit;
			}
			else 
			{
				lastAttack = AttackStatus.Loose;
				m.lastAttackToMe = AttackStatus.Loose;
				return 0;
			}
			#endregion

			if (!pass)
			{
				float parryChance = ParryChanceCalculation(m,dif);

				#region Parry test
				roll = Utility.Random( 100 );
				if (parryChance >= roll)
				{
					lastAttack = AttackStatus.Parry;
					m.lastAttackToMe = AttackStatus.Parry;
					return -2;	
				}
				#endregion			

				float dodgeChance = DodgeChanceCalculation(m,dif);

				#region Dodge test
				roll = Utility.Random( 100 );
				if (dodgeChance >= roll)
				{
					lastAttack = AttackStatus.Dodge;
					m.lastAttackToMe = AttackStatus.Dodge;
					return -1;	
				}
				#endregion
			}


			float damage = DamageDoneCalculation(m,dmgBonus,criticalStrike,weapon);
			float blockChance = BlockChanceCalculation(m,dif);
			if (!pass)
			{
				#region Block test + block reduction	
				roll = Utility.Random( 100 );
				// shield specialization
				if (blockChance >= roll)
				{
					lastAttack = AttackStatus.Block;
					m.lastAttackToMe = AttackStatus.Block;
					amountBlocked = m.Block + m.Str/30;
					damage -= amountBlocked;
					#region talents
					// shield specialization
					if ( m.HaveTalent(Talents.ShieldSpecialization) )
					{
						AuraEffect af = (AuraEffect)m.GetTalentEffect(Talents.ShieldSpecialization);
						roll = Utility.Random( 100 );
						if ( roll < af.H )
						{
							m.GainMana(m,(Abilities.abilities[af.AdditionalSpell] as SpellTemplate).S1);
						}
					}
					#endregion
				}
		
				#endregion
			}
			#region Armor reduction
			float armor = ArmorReductionCalculation(m); 
			damage = damage * (1 - armor);
			#endregion

			#region immune
			if (m.ImmunePhysicalDamage)
			{
				lastAttack = AttackStatus.Immune;
				m.lastAttackToMe = AttackStatus.Immune;
				return 0;
			}
			#endregion
			
			#region absorb
			amountAbsorbed = (int)damage;
			damage =(int)m.DamageAbsorbCombat(damage);
			amountAbsorbed -= (int)damage;
			if ( damage < 0 )
			{
				this.lastAttack = AttackStatus.Absorb;
				m.lastAttackToMe = AttackStatus.Absorb;	
				return 0;
			}
			#endregion

			#region Targets modificators 
			damage = DamageTakenCalculation(m,damage);
			#endregion
			damage = m.ManaShieldLost(this,(int)damage);
			#region other effects
			
			switch (this.Classe)
			{
					#region warrior
				case Classes.Warrior:
					// deep wounds 
					if (this.lastAttack == AttackStatus.Critical)
					{
						/*if ( src.HaveTalent( Talents.DeepWounds) )
						{
							AuraEffect ae = (AuraEffect)src.GetTalentEffect( Talents.DeepWounds );
								
								AuraEffect af = (AuraEffect)Abilities.abilities[ae.AdditionalSpell];
								float modif = (float)ae.S1/100;
								af.ApplyDot(this, m, (int)(damage*modif), af.T1, af.Duration(this));
							
						}*/
						if ( m.HaveTalent( Talents.BloodCraze) )
						{
							AuraEffect ae = (AuraEffect)m.GetTalentEffect( Talents.BloodCraze );
							SpellTemplate st = (SpellTemplate)Abilities.abilities[ae.AdditionalSpell];
							HotAura aura = new HotAura(st,m,m,(int)(m.BaseHitPoints*((float)st.S1/100)/(st.Duration(m)/st.T1)),st.Duration(m),st.T1);
							
						}

					}
					//Mace specialization
					/*if ( src.HaveTalent( Talents.MaceSpecialization) && weapon.SubClass == 4 )
					{
						AuraEffect ae = (AuraEffect)src.GetTalentEffect( Talents.MaceSpecialization );
						roll = Utility.Random( 100 );
						if(roll < ae.H)
						{
							AuraEffect af = (AuraEffect)Abilities.abilities[ae.AdditionalSpell];
							Aura aura = new Aura();
							aura.ForceStun = true;
							m.AddAura(this, af,aura,true);
						}
					}*/
					//int SwordSpecializationEffect = 0x14af5e;
					/*if ( src.HaveTalent( Talents.SwordSpecialization) && weapon.SubClass == 15 )
					{
						AuraEffect ae = (AuraEffect)src.GetTalentEffect( Talents.SwordSpecialization );
					roll = Utility.Random( 100 );	
					if(roll < ae.H)
						{
							this.AdditionnalStates.Add(SwordSpecializationEffect);
						}
					}*/
					if ( this.HaveTalent( Talents.UnbridledWrath) )
					{
						AuraEffect ae = (AuraEffect)this.GetTalentEffect( Talents.UnbridledWrath );
						roll = Utility.Random( 100 );
						if(roll < ae.H)
						{
							this.GainMana(this,1);
						}
					}
					
					break;
					#endregion
			}
			#endregion
			if ( damage > 0 )
				this.SkillUpWeapon(weapon);
			return (int)damage;
		}
Exemple #33
0
        protected virtual AttackStatus TickAttack(Actor self, AttackFrontal attack)
        {
            if (!target.IsValidFor(self))
            {
                return(AttackStatus.UnableToAttack);
            }

            if (attack.Info.AttackRequiresEnteringCell && !positionable.CanEnterCell(target.Actor.Location, null, false))
            {
                return(AttackStatus.UnableToAttack);
            }

            if (!attack.Info.TargetFrozenActors && !forceAttack && target.Type == TargetType.FrozenActor)
            {
                // Try to move within range, drop the target otherwise
                if (move == null)
                {
                    return(AttackStatus.UnableToAttack);
                }

                var rs = revealsShroud
                         .Where(Exts.IsTraitEnabled)
                         .MaxByOrDefault(s => s.Range);

                // Default to 2 cells if there are no active traits
                var sightRange = rs != null ? rs.Range : WDist.FromCells(2);

                attackStatus |= AttackStatus.NeedsToMove;
                QueueChild(self, move.MoveWithinRange(target, sightRange, target.CenterPosition, Color.Red), true);
                return(AttackStatus.NeedsToMove);
            }

            // Drop the target once none of the weapons are effective against it
            var armaments = attack.ChooseArmamentsForTarget(target, forceAttack).ToList();

            if (armaments.Count == 0)
            {
                return(AttackStatus.UnableToAttack);
            }

            // Update ranges
            minRange = armaments.Max(a => a.Weapon.MinRange);
            maxRange = armaments.Min(a => a.MaxRange());

            var pos    = self.CenterPosition;
            var mobile = move as Mobile;

            if (!target.IsInRange(pos, maxRange) ||
                (minRange.Length != 0 && target.IsInRange(pos, minRange)) ||
                (mobile != null && !mobile.CanInteractWithGroundLayer(self)))
            {
                // Try to move within range, drop the target otherwise
                if (move == null)
                {
                    return(AttackStatus.UnableToAttack);
                }

                attackStatus |= AttackStatus.NeedsToMove;
                var checkTarget = useLastVisibleTarget ? lastVisibleTarget : target;
                QueueChild(self, move.MoveWithinRange(target, minRange, maxRange, checkTarget.CenterPosition, Color.Red), true);
                return(AttackStatus.NeedsToMove);
            }

            if (!attack.TargetInFiringArc(self, target, attack.Info.FacingTolerance))
            {
                var desiredFacing = (attack.GetTargetPosition(pos, target) - pos).Yaw.Facing;
                attackStatus |= AttackStatus.NeedsToTurn;
                QueueChild(self, new Turn(self, desiredFacing), true);
                return(AttackStatus.NeedsToTurn);
            }

            attackStatus |= AttackStatus.Attacking;
            DoAttack(self, attack, armaments);

            return(AttackStatus.Attacking);
        }
Exemple #34
0
 public void Start()
 {
     this.attackStatus = AttackStatus.Attacking;
 }
Exemple #35
0
        public override Activity Tick(Actor self)
        {
            if (ChildActivity != null)
            {
                ChildActivity = ActivityUtils.RunActivity(self, ChildActivity);
                return(this);
            }

            if (IsCanceling)
            {
                return(NextActivity);
            }

            bool targetIsHiddenActor;

            target = RecalculateTarget(self, out targetIsHiddenActor);
            if (!targetIsHiddenActor && target.Type == TargetType.Actor)
            {
                lastVisibleTarget       = Target.FromTargetPositions(target);
                lastVisibleMaximumRange = attackTraits.Where(x => !x.IsTraitDisabled)
                                          .Min(x => x.GetMaximumRangeVersusTarget(target));

                lastVisibleOwner       = target.Actor.Owner;
                lastVisibleTargetTypes = target.Actor.GetEnabledTargetTypes();
            }

            var oldUseLastVisibleTarget = useLastVisibleTarget;

            useLastVisibleTarget = targetIsHiddenActor || !target.IsValidFor(self);

            // If we are ticking again after previously sequencing a MoveWithRange then that move must have completed
            // Either we are in range and can see the target, or we've lost track of it and should give up
            if (wasMovingWithinRange && targetIsHiddenActor)
            {
                return(NextActivity);
            }

            // Update target lines if required
            if (useLastVisibleTarget != oldUseLastVisibleTarget)
            {
                self.SetTargetLine(useLastVisibleTarget ? lastVisibleTarget : target, Color.Red, false);
            }

            // Target is hidden or dead, and we don't have a fallback position to move towards
            if (useLastVisibleTarget && !lastVisibleTarget.IsValidFor(self))
            {
                return(NextActivity);
            }

            wasMovingWithinRange = false;
            var pos         = self.CenterPosition;
            var checkTarget = useLastVisibleTarget ? lastVisibleTarget : target;

            // We don't know where the target actually is, so move to where we last saw it
            if (useLastVisibleTarget)
            {
                // We've reached the assumed position but it is not there or we can't move any further - give up
                if (checkTarget.IsInRange(pos, lastVisibleMaximumRange) || move == null || lastVisibleMaximumRange == WDist.Zero)
                {
                    return(NextActivity);
                }

                // Move towards the last known position
                wasMovingWithinRange = true;
                QueueChild(self, move.MoveWithinRange(target, WDist.Zero, lastVisibleMaximumRange, checkTarget.CenterPosition, Color.Red), true);
                return(this);
            }

            attackStatus = AttackStatus.UnableToAttack;

            foreach (var attack in attackTraits.Where(x => !x.IsTraitDisabled))
            {
                var status = TickAttack(self, attack);
                attack.IsAiming = status == AttackStatus.Attacking || status == AttackStatus.NeedsToTurn;
            }

            if (attackStatus.HasFlag(AttackStatus.NeedsToMove))
            {
                wasMovingWithinRange = true;
            }

            if (attackStatus >= AttackStatus.NeedsToTurn)
            {
                return(this);
            }

            return(NextActivity);
        }
Exemple #36
0
 public Attack(AttackType attackType)
 {
     this.attackType   = attackType;
     this.attackStatus = AttackStatus.Attacking;
 }
Exemple #37
0
 public void Inited()
 {
     Status = AttackStatus.Inited;
 }
Exemple #38
0
 public void Pause()
 {
     this.attackStatus = AttackStatus.Stopping;
 }
Exemple #39
0
 public void Wait()
 {
     Status = AttackStatus.Wait;
 }
Exemple #40
0
 public void Wait()
 {
     Status = AttackStatus.Wait;
 }
Exemple #41
0
 public void Process()
 {
     Status = /*Handler.IsDelay ? AttackStatus.Delay : */ AttackStatus.Process;
 }
Exemple #42
0
    protected void DoShoot(bool shallStop = false)
    {
        var dir = target.transform.position - owner.transform.position;
        dir.y = 0;
//        Debug.Log("shhot dir: " + dir);
        owner.Control.SetToDirection(dir);
        //dir = new Vector3(dir.x,owner.transform.position.y,dir.z);
        owner.TryAttack(dir, target);
        owner.OnShootEnd += OnShootEnd;
        attackStatus = AttackStatus.shoot;
        if (shallStop)
        {
            ((AgentControl)owner.Control).Stop(false);
        }
    }
Exemple #43
0
 public void Charge()
 {
     Status = AttackStatus.Charge;
 }
Exemple #44
0
 public void Process()
 {
     Status = /*Handler.IsDelay ? AttackStatus.Delay : */AttackStatus.Process;
 }
Exemple #45
0
		public virtual int AttackSwing( Mobile target,bool pass )
		{
			#region immune test
			if (this.ImmuneAttack)
			{
				this.lastAttack = AttackStatus.Immune;
				return 0;
			}
			#endregion
			
			if(this.AttackTarget != null)
			{
										
				ArrayList NAEbuff = (ArrayList)NextAttackEffects.Clone();
				foreach(NextAttackEffect nae in NAEbuff)
				{
						
					this.OnSpellTemplateResults(nae.spell,this.AttackTarget);
					this.NextAttackSpellGo(nae);
						
				}
					
				NAEbuff.Clear();
			}

			int amountAbsorbed = 0;
			int amountBlocked = 0;
			int degats = Hit( target, 0f, pass, ref amountBlocked, ref amountAbsorbed );
			int offset = 4;
			if ( degats <= 0 )
				Converter.ToBytes( 0x22, tempBuff, ref offset );
			else
				Converter.ToBytes( 0x22, tempBuff, ref offset );
	
			Converter.ToBytes( Guid, tempBuff, ref offset );
			Converter.ToBytes( target.Guid, tempBuff, ref offset );
			if ( degats < 0 )
				Converter.ToBytes( 0, tempBuff, ref offset );
			else
				Converter.ToBytes( degats, tempBuff, ref offset );
			Converter.ToBytes( (byte)1, tempBuff, ref offset );
			Converter.ToBytes( 0, tempBuff, ref offset );
			if ( degats > 0 )
				Converter.ToBytes( (float)degats/*DamageType*/, tempBuff, ref offset );
			else
				Converter.ToBytes( 0, tempBuff, ref offset );

			//		Converter.ToBytes( 0/*DamageType*/, tempBuff, ref offset );
			//		float ang = (float)Math.Atan2( AttackTarget.Y - Y, AttackTarget.X - X );
			if ( degats < 0 )
				Converter.ToBytes( 0, tempBuff, ref offset );
			else
				Converter.ToBytes( degats, tempBuff, ref offset );
			//	Converter.ToBytes( amountAbsorbed, tempBuff, ref offset );// damage absorbed 
			//	Converter.ToBytes( 0, tempBuff, ref offset ); // new victim state
			Converter.ToBytes( 0, tempBuff, ref offset ); // additional spell damage id
			Converter.ToBytes( 0, tempBuff, ref offset ); // additional spell damage id
			#region Degats types
			if ( degats >= 0 )
				Converter.ToBytes( 1, tempBuff, ref offset );
			else
				if ( degats == -1 )
				Converter.ToBytes( 2, tempBuff, ref offset );// dodge
			else
				if ( degats == - 2 )
				Converter.ToBytes( 9, tempBuff, ref offset );// parry
			else
				if ( degats == - 3 )
				Converter.ToBytes( 4, tempBuff, ref offset );// interrupted
			else
				if ( degats == - 4 || amountBlocked > 0 )
				Converter.ToBytes( 5, tempBuff, ref offset );// block
			else
				if ( degats == - 5 )
				Converter.ToBytes( 6, tempBuff, ref offset );// evade
			else
				if ( degats == - 6 )
				Converter.ToBytes( 7, tempBuff, ref offset );// immune
			else
				if ( degats == - 7 )
				Converter.ToBytes( 8, tempBuff, ref offset );// deflect

			#endregion
		
			if ( degats == 0 )
				Converter.ToBytes( 0xffffffff, tempBuff, ref offset );
			else
				Converter.ToBytes( 0, tempBuff, ref offset );
			Converter.ToBytes( 0, tempBuff, ref offset );
			Converter.ToBytes( 0, tempBuff, ref offset );
			ToAllPlayerNear( OpCodes.SMSG_ATTACKERSTATEUPDATE, tempBuff, offset );					

			target.LooseHits( this, degats, true );
			return degats;
		}
Exemple #46
0
 public void Process()
 {
     Status = AttackStatus.Process;
 }
Exemple #47
0
 public Attack(AttackType attackType)
 {
     this.attackType = attackType;
     this.attackStatus = AttackStatus.Attacking;
 }
    protected override void Initialize(FSMEvent ev = null)
    {
        _eventAttackMelee = ev as AnimFSMEventAttackMelee;

        _attackStatus = AttackStatus.PREPARING;
        Agent.BlackBoard.motionType = MotionType.ATTACK;
        _startRotation = Agent.Transform.rotation;
        _startPosition = Agent.Transform.position;

        if (_eventAttackMelee.target != null)
        {
            float angle    = 0;
            float distance = 0;

            Vector3 finalDir = _eventAttackMelee.target.Position - Agent.Transform.position;
            distance = finalDir.magnitude;
            if (distance > 0.1f)
            {
                finalDir.Normalize();
                angle = Vector3.Angle(Agent.Transform.forward, finalDir);
                if (angle < 40 && Vector3.Angle(Agent.Forward, _eventAttackMelee.target.Forward) < 80)
                {
                    _backHit = true;
                }
            }
            else
            {
                finalDir = Agent.Transform.forward;
            }

            _finalRotation.SetLookRotation(finalDir);

            if (distance < Agent.BlackBoard.weaponRange ||
                Agent.BlackBoard.allowedFlashToWeaponRange == false ||
                distance > Agent.BlackBoard.combatRange * 1.2f)
            {
                _finalPosition = _startPosition;
                _rotationTime  = angle / 720.0f;
            }
            else
            {
                // flash
                if (distance >= Agent.BlackBoard.weaponRange * 1.5)
                {
                    if (Agent.BlackBoard.showMotionEffect)
                    {
                        ParticleTools.Instance.Play(Agent.particleSystemFlashTust,
                                                    (_eventAttackMelee.target.Position - Agent.Position).RadianInXZ());
                    }
                }
                _finalPosition = _eventAttackMelee.target.transform.position - finalDir * Agent.BlackBoard.weaponRange;
                Agent.Transform.LookAt(_eventAttackMelee.target.transform);
                _rotationTime = 0;
            }

            _moveTime = (_finalPosition - _startPosition).magnitude / 20.0f;
        }
        else
        {
            _finalRotation.SetLookRotation(_eventAttackMelee.attackDir);
            _rotationTime = Vector3.Angle(Agent.Transform.forward, _eventAttackMelee.attackDir) / 720.0f;
            _moveTime     = 0;
        }

        _rotationOk          = (_rotationTime == 0);
        _positionOK          = (_moveTime == 0);
        _currentRotationTime = 0;
        _currentMoveTime     = 0;

        _isCritical = IsCritical();
        _knockdown  = IsKnockDown();

        _hitTimeStart = false;
    }
Exemple #49
0
 public BasicLocationObject(Position position)
 {
     _position = position;
     _status   = AttackStatus.NotAttacked;
     _occupant = null;
 }
Exemple #50
0
        protected virtual AttackStatus TickAttack(Actor self, AttackBase attack)
        {
            if (IsCanceled)
            {
                return(AttackStatus.UnableToAttack);
            }

            var type = Target.Type;

            if (!Target.IsValidFor(self) || type == TargetT.FrozenActor)
            {
                return(AttackStatus.UnableToAttack);
            }

            if (attack.Info.AttackRequiresEnteringCell && !positionable.CanEnterCell(Target.Actor.Location, null, false))
            {
                return(AttackStatus.UnableToAttack);
            }

            //Drop the target if it moves under the shroud / fog.
            if (!attack.Info.IgnoresVisibility && type == TargetT.Actor &&
                !Target.Actor.Info.HasTraitInfo <FrozenUnderFogInfo>() &&
                !Target.Actor.CanBeViewedByPlayer(self.Owner))
            {
                return(AttackStatus.UnableToAttack);
            }

            //Drop the target once none of the weapons are effective against it

            var armaments = attack.ChooseArmamentsForTarget(Target, forceAttack).ToList();

            if (armaments.Count == 0)
            {
                return(AttackStatus.UnableToAttack);
            }

            //Update ranges
            minRange = armaments.Max(a => a.Weapon.MinRange);
            maxRange = armaments.Min(a => a.MaxRange());

            var pos    = self.CenterPosition;
            var mobile = move as Mobile;

            if (!Target.IsInRange(pos, maxRange) ||
                (minRange.Length != 0 && Target.IsInRange(pos, minRange)) ||
                (mobile != null && !mobile.CanInteractWithGroundLayer(self)))
            {
                //Try to move within range,drop the target otherwise.
                if (move == null)
                {
                    return(AttackStatus.UnableToAttack);
                }

                attackStatus |= AttackStatus.NeedsToMove;
                moveActivity  = ActivityUtils.SequenceActivities(move.MoveWithinRange(Target, minRange, maxRange), this);
                return(AttackStatus.NeedsToMove);
            }

            var targetedPosition = attack.GetTargetPosition(pos, Target);
            var desiredFacing    = (targetedPosition - pos).Yaw.Facing;

            if (!Util.FacingWithinTolerance(facing.Facing, desiredFacing, facingTolerance))
            {
                attackStatus |= AttackStatus.NeedsToTurn;
                turnActivity  = ActivityUtils.SequenceActivities(new Turn(self, desiredFacing), this);
                return(AttackStatus.NeedsToTurn);
            }

            attackStatus |= AttackStatus.Attacking;
            attack.DoAttack(self, Target, armaments);

            return(AttackStatus.Attacking);
        }
Exemple #51
0
        protected virtual Activity InnerTick(Actor self, AttackBase attack)
        {
            if (IsCanceled)
            {
                return(NextActivity);
            }

            var type = Target.Type;

            if (!Target.IsValidFor(self) || type == TargetType.FrozenActor)
            {
                return(NextActivity);
            }

            if (attack.Info.AttackRequiresEnteringCell && !positionable.CanEnterCell(Target.Actor.Location, null, false))
            {
                return(NextActivity);
            }

            // Drop the target if it moves under the shroud / fog.
            // HACK: This would otherwise break targeting frozen actors
            // The problem is that Shroud.IsTargetable returns false (as it should) for
            // frozen actors, but we do want to explicitly target the underlying actor here.
            if (!attack.Info.IgnoresVisibility && type == TargetType.Actor && !Target.Actor.Info.HasTraitInfo <FrozenUnderFogInfo>() && !self.Owner.CanTargetActor(Target.Actor))
            {
                return(NextActivity);
            }

            // Drop the target once none of the weapons are effective against it
            var armaments = attack.ChooseArmamentsForTarget(Target, forceAttack).ToList();

            if (armaments.Count == 0)
            {
                return(NextActivity);
            }

            // Update ranges
            minRange = armaments.Max(a => a.Weapon.MinRange);
            maxRange = armaments.Min(a => a.MaxRange());

            var mobile = move as Mobile;

            if (!Target.IsInRange(self.CenterPosition, maxRange) || Target.IsInRange(self.CenterPosition, minRange) ||
                (mobile != null && !mobile.CanInteractWithGroundLayer(self)))
            {
                // Try to move within range, drop the target otherwise
                if (move == null)
                {
                    return(NextActivity);
                }

                attackStatus |= AttackStatus.NeedsToMove;
                moveActivity  = ActivityUtils.SequenceActivities(move.MoveWithinRange(Target, minRange, maxRange), this);
                return(NextActivity);
            }

            var desiredFacing = (Target.CenterPosition - self.CenterPosition).Yaw.Facing;

            if (facing.Facing != desiredFacing)
            {
                attackStatus |= AttackStatus.NeedsToTurn;
                turnActivity  = ActivityUtils.SequenceActivities(new Turn(self, desiredFacing), this);
                return(NextActivity);
            }

            attackStatus |= AttackStatus.Attacking;
            attack.DoAttack(self, Target, armaments);

            return(this);
        }