/// <summary>
	/// Construtor
	/// </summary>
	public AttributeModifier(int originID_, 
		ENUMERATORS.Attribute.AttributeModifierTypeEnum modifierType_, 
		ENUMERATORS.Attribute.CharacterAttributeTypeEnum attributeType_, 
		ENUMERATORS.Attribute.AttributeModifierCalcTypeEnum calcType_, 
		ENUMERATORS.Attribute.AttributeModifierApplyToEnum applyTo_,
		float value_,
		float timeInSeconds_,
		float initialTime_
	)
	{
		OriginID = originID_;
		ModifierType = modifierType_;
		AttributeType = (int)attributeType_;
		CalcType = calcType_;
		ApplyTo = applyTo_;
		Value = value_;
		TimeInSeconds = timeInSeconds_;
		InitialTime = initialTime_;
		ExpireTime = InitialTime + TimeInSeconds;
		Consumed = false;
	}
    /// <summary>
    /// Verifica se uma determinada classe esta livre para ser utilizada
    /// </summary>
    /// <returns><c>true</c> if this instance is player class identifier free the specified playerClassId_; otherwise, <c>false</c>.</returns>
    /// <param name="playerClassId_">Player class identifier.</param>
    bool IsPlayerClassIdFree(ENUMERATORS.Player.PlayerClass playerClassId_)
    {
        for (int i = 0; i < myInputDevicePlayers.Length; i++)
        {
            if (myInputDevicePlayers[i] != null)
            {
                if (myInputDevicePlayers[i].IsSelectingClass_InGame)
                {
                    if (myInputDevicePlayers[i].SelectingPlayerClassID == playerClassId_)
                        return false;
                }
                else
                {
                    if (myInputDevicePlayers[i].Avatar != null && myInputDevicePlayers[i].Avatar.PlayerClass == playerClassId_)
                        return false;
                    else if (myInputDevicePlayers[i].SelectingPlayerClassID == playerClassId_)
                        return false;
                }
            }
        }

        return true;
    }
    /// <summary>
    /// Recupera uma classe disponivel para uso
    /// </summary>
    /// <returns>The free player class identifier.</returns>
    /// <param name="currentPlayerClassId">Current player class identifier.</param>
    /// <param name="ascend_">If set to <c>true</c> ascend.</param>
    ENUMERATORS.Player.PlayerClass GetFreePlayerClassId(ENUMERATORS.Player.PlayerClass currentPlayerClassId, bool ascend_)
    {
        if (ascend_)
        {
            while (true)
            {
                // Percorre as classes ordenadas
                for (int i = 0; i < PlayerSelectionOrder.Length; i++)
                {
                    // Encontrou a classe atual
                    if (currentPlayerClassId == PlayerSelectionOrder[i])
                    {
                        // Faz o loop ou seleciona a proxima da ordem
                        if (i + 1 == PlayerSelectionOrder.Length)
                            currentPlayerClassId = PlayerSelectionOrder[0];
                        else
                            currentPlayerClassId = PlayerSelectionOrder[i + 1];
						
						break;
                    }
                }

                if (IsPlayerClassIdFree(currentPlayerClassId))
                    break;
            }
        }
        else
        {
            while (true)
            {
                // Percorre as classes ordenadas
                for (int i = 0; i < PlayerSelectionOrder.Length; i++)
                {
                    // Encontrou a classe atual
                    if (currentPlayerClassId == PlayerSelectionOrder[i])
                    {
                        // Faz o loop ou seleciona a proxima da ordem
                        if (i - 1 == -1)
                            currentPlayerClassId = PlayerSelectionOrder[PlayerSelectionOrder.Length - 1];
                        else
                            currentPlayerClassId = PlayerSelectionOrder[i - 1];

						break;
                    }
                }

                if (IsPlayerClassIdFree(currentPlayerClassId))
                    break;
            }
        }

        return currentPlayerClassId;
    }
    PlayerStatusHUD GetPlayerStatusHud(ENUMERATORS.Player.PlayerClass playerClass_)
    {
        for (int i = 0; i < myPlayerStatusHUDList.Length; i++)
        {
            if (myPlayerStatusHUDList[i] != null && myPlayerStatusHUDList[i].Playerclass == playerClass_)
                return myPlayerStatusHUDList[i];
        }

        return null;
    }
Example #5
0
	public virtual void ApplyDamage(Character damager_, ENUMERATORS.Combat.DamageType damageType_, ENUMERATORS.Player.PlayerClass classe, float damage_)
    {
        float damage = damage_ - this.Armor.MaxWithModifiers;

        if (damage < 0)
            damage = 1;

        this.HitPoint.Current -= damage;
		if (classe == ENUMERATORS.Player.PlayerClass.SPECIALIST && !disable) {
			if (this.HitPoint.CurrentWithModifiers <= 0) {
				sound.clip = gemidos [6];
				sound.Play (); 
				_animator.SetBool ("Death", true);
				colisao.enabled = !colisao.enabled;
				script.enabled = false;
				scriptCharacter.enabled = false;
				disable = true;
			} 
			else if(audioisplaying){
				sound.clip = gemidos [0];
				sound.Play (); 
				audioisplaying = false;
				StartCoroutine ("EsperarSomTerminar");
			}
		}
		else if (classe == ENUMERATORS.Player.PlayerClass.ENGINEER && !disable) {
			if (this.HitPoint.CurrentWithModifiers <= 0) {
				sound.clip = gemidos [6];
				sound.Play (); 
				_animator.SetBool ("Death", true);
				colisao.enabled = !colisao.enabled;
				script.enabled = false;
				scriptCharacter.enabled = false;
				disable = true;
			} else if(audioisplaying){
				sound.clip = gemidos [1];
				sound.Play (); 
				audioisplaying = false;
				StartCoroutine ("EsperarSomTerminar");
			}
		}
		else if (classe == ENUMERATORS.Player.PlayerClass.DEFENDER && !disable) {
			if (this.HitPoint.CurrentWithModifiers <= 0) {
				sound.clip = gemidos [6];
				sound.Play (); 
				_animator.SetBool ("Death", true);
				colisao.enabled = !colisao.enabled;
				script.enabled = false;
				scriptCharacter.enabled = false;
				disable = true;
			} else if(audioisplaying){	
				sound.clip = gemidos [2];
				sound.Play (); 
				audioisplaying = false;
				StartCoroutine ("EsperarSomTerminar");
			}
		}
		else if (classe == ENUMERATORS.Player.PlayerClass.MEDIC && !disable) {
			if (this.HitPoint.CurrentWithModifiers <= 0) {
				sound.clip = gemidos [6];
				sound.Play (); 
				_animator.SetBool ("Death", true);
				colisao.enabled = !colisao.enabled;
				script.enabled = false;
				scriptCharacter.enabled = false;
				disable = true;
			} else if(audioisplaying){
				sound.clip = gemidos [3];
				sound.Play (); 
				audioisplaying = false;
				StartCoroutine ("EsperarSomTerminar");
			}
		}
		else if (classe == ENUMERATORS.Player.PlayerClass.ASSAULT && !disable) {
			if (this.HitPoint.CurrentWithModifiers <= 0) {
				sound.clip = gemidos [6];
				sound.Play (); 
				_animator.SetBool ("Death", true);
				colisao.enabled = !colisao.enabled;
				script.enabled = false;
				scriptCharacter.enabled = false;
				disable = true;
			} else if(audioisplaying){
				sound.clip = gemidos [4];
				sound.Play (); 
				audioisplaying = false;
				StartCoroutine ("EsperarSomTerminar");
			}
		}
		else if (classe == ENUMERATORS.Player.PlayerClass.ROBOT && audioisplaying) {
			sound.clip = gemidos[5];
			sound.Play (); 
			audioisplaying = false;
			StartCoroutine ("EsperarSomTerminar");
		}
			



        //Attributes[(int)ENUMERATORS.Attribute.CharacterAttributeTypeEnum.HitPoint].Current -= damager_.CalculateDamage();
        /*if (OnHitPointChanged != null)
            OnHitPointChanged(this);*/
    }
Example #6
0
    /// <summary>
    /// Metodo responsavel por calcular o dano recebido do personagem
    /// </summary>
    /// <param name="damager_">Oponente que deferiu o dano</param>
    /// <param name="damageType_">Tipo do Dano</param>
	public virtual void ApplyDamage(Character damager_, ENUMERATORS.Combat.DamageType damageType_, ENUMERATORS.Player.PlayerClass classe)
    {
		ApplyDamage(damager_, damageType_, classe, damager_.CalculateDamage());
    }
Example #7
0
	public override void ApplyDamage(Character damager_, ENUMERATORS.Combat.DamageType damageType_, ENUMERATORS.Player.PlayerClass classe, float damage_)
    {
        if (!(damager_ is BaseEnemy))
        {
            if ((this.State & EnemyState.Dead) != EnemyState.Dead)
            {
                if (damage_ == -1)
					base.ApplyDamage(damager_, damageType_, classe);
                else
					base.ApplyDamage(damager_, damageType_, classe, damage_);

                // Verifica se a Vida é menor que Zero
                if (HitPoint.CurrentWithModifiers <= 0)
                {
                    if (OnBeforeDie != null)
                        OnBeforeDie(this);

                    Die();
                }
            }
        }
    }
Example #8
0
	public override void ApplyDamage(Character damager_, ENUMERATORS.Combat.DamageType damageType_, ENUMERATORS.Player.PlayerClass classe)
    {
		ApplyDamage(damager_, damageType_, classe, -1);
    }
    /// <summary>
    /// Retorna a referencia da tabela de objetos 
    /// </summary>
    /// <typeparam name="T">The 1st type parameter.</typeparam>
    /*public SkillBase GetSpellPool<T>()
	{
		for (int i = 0;  i < SpellTable.Length; i++)
		{
			if (SpellTable[i] is T)
				return SpellTable[i];
		}

		return null;
	}*/

    public SkillBase GetSpellPool(ENUMERATORS.Spell.SkillID spellId_)
    {
        for (int i = 0; i < SpellTable.Length; i++)
        {
            if ((int)SpellTable[i].SkillID == (int)spellId_)
                return SpellTable[i];
        }

        return null;
    }