//1 - Le joueur appuie sur un bouton, ca lance SendMessage (enemy ou allié). Mettre 0 en EmojiEffect si l'attaque n'est pas un Emoji
    public void SendMessagesPlayer(Skill capacity, int numberForEmojiEffect)
    {
        //Le joueur ne peut pas attaquer tant que l'animation n'est pas finie
        canAttack = false;
        switch (capacity.messageType)
        {
        case Skill.typeOfMessage.Small:
            messageToSpawn = typeToSpawn.PlayerSmall;
            UpdatePosition(capacity);
            break;

        case Skill.typeOfMessage.Charging:
            PlayerChargingMessage(capacity);
            break;

        case Skill.typeOfMessage.Big:
            messageToSpawn = typeToSpawn.PlayerBig;
            UpdatePosition(capacity);
            break;

        case Skill.typeOfMessage.Emoji:
            messageToSpawn   = typeToSpawn.PlayerEmote;
            futurEmojiEffect = numberForEmojiEffect;
            UpdatePosition(capacity);
            break;

        default:
            break;
        }
    }
    public void PlayerEmojis(Skill skill)
    {
        GameObject msg = Instantiate(EmojiPlayer.gameObject, playerMsgPositions[1].transform.position, Quaternion.identity);

        msg.transform.SetParent(playerMsgPositions[1].transform);
        allMsg[1]          = msg;
        skill.messageOwner = msg;
        if (skill.comesFromCurse)
        {
            skill.messageOwner.GetComponent <Image>().color = ConversationManager.Instance.cursedColor;
            skill.comesFromCurse = false;
        }
        CombatManager.Instance.EmojiIcon(msg.GetComponent <Image>(), skill);
        CombatManager.Instance.MessageIcon(msg, skill);
        msg.GetComponent <MessageBehaviour>().teamMsg = MessageBehaviour.team.Player;
        msg.GetComponent <MessageBehaviour>().GetEffect(futurEmojiEffect);
        msg.GetComponent <MessageBehaviour>().EmojiEffectBegin();
        futurEmojiEffect = 0;

        //On stock l'emoji dans un tableau, pour réactiver son effet;
        emojis.Add(msg);

        //reset des valeurs pour instancier le prochain message.
        messageToSpawn = typeToSpawn.Null;
        canAttack      = true;
    }
    public void PlayerLargeMessage(Skill skill)
    {
        playerChargingAttack.SetActive(false);
        Player.Instance.isCharging = false;


        Debug.Log("BigMessage");
        GameObject msg = Instantiate(BigMessagePlayer.gameObject, playerMsgPositions[2].transform.position, Quaternion.identity);

        msg.transform.SetParent(playerMsgPositions[2].transform);
        allMsg[2]          = msg;
        skill.messageOwner = msg;


        if (skill.comesFromCurse)
        {
            skill.messageOwner.GetComponent <Image>().color = ConversationManager.Instance.cursedColor;
        }

        CombatManager.Instance.MessageIcon(msg, skill);
        messageManager.ChoseArray(skill, msg);

        messageToSpawn            = typeToSpawn.Null;
        canAttack                 = true;
        Player.Instance.canAttack = true;
        skill.messageType         = Skill.typeOfMessage.Charging;
        //Lancer Methode pour le Text;
    }
    public void SendMessagesEnemy(Skill capacity, int numberForEmojiEffect)
    {
        canAttack = false;
        switch (capacity.messageType)
        {
        case Skill.typeOfMessage.Small:
            messageToSpawn = typeToSpawn.EnemySmall;
            UpdatePosition(capacity);
            break;

        case Skill.typeOfMessage.Charging:
            EnemyChargingMessage(capacity);
            break;

        case Skill.typeOfMessage.Big:
            messageToSpawn = typeToSpawn.EnemyBig;
            UpdatePosition(capacity);
            break;

        case Skill.typeOfMessage.Emoji:
            messageToSpawn   = typeToSpawn.EnemyEmote;
            futurEmojiEffect = numberForEmojiEffect;
            UpdatePosition(capacity);
            break;

        default:
            break;
        }
    }
Exemple #5
0
    public void EnemyEmojis(Skill skill)
    {
        GameObject msg = Instantiate(EmojiEnemy.gameObject, enemyMsgPositions[1].transform.position, Quaternion.identity);

        msg.transform.SetParent(enemyMsgPositions[1].transform);
        allMsg[1]          = msg;
        skill.messageOwner = msg;
        CombatManager.Instance.EmojiIcon(msg.GetComponent <Image>(), skill);
        CombatManager.Instance.MessageIcon(msg, skill);
        msg.GetComponent <MessageBehaviour>().teamMsg = MessageBehaviour.team.Enemy;
        msg.GetComponent <MessageBehaviour>().GetEffect(futurEmojiEffect);
        futurEmojiEffect = 0;
        msg.GetComponent <MessageBehaviour>().EmojiEffectBegin();
        emojis.Add(msg);

        //reset des valeurs pour instancier le prochain message.
        messageToSpawn = typeToSpawn.Null;
        canAttack      = true;
    }
    public void EnemySmallMessage(Skill skill)
    {
        //A lancer à la fin de la coroutine.
        GameObject msg = Instantiate(SmallMessageEnemy.gameObject, enemyMsgPositions[1].transform.position, Quaternion.identity);

        msg.transform.SetParent(enemyMsgPositions[1].transform);
        allMsg[1]          = msg;
        skill.messageOwner = msg;
        if (skill.comesFromCurse)
        {
            skill.messageOwner.GetComponent <Image>().color = ConversationManager.Instance.cursedColor;
        }

        CombatManager.Instance.MessageIcon(msg, skill);
        messageManager.ChoseArray(skill, msg);
        skill.MonsterEffect();
        messageToSpawn = typeToSpawn.Null;
        canAttack      = true;
        //Lancer Methode pour le Text;
    }
    public void PlayerSmallMessage(Skill skill)
    {
        GameObject msg = Instantiate(SmallMessagePlayer.gameObject, playerMsgPositions[1].transform.position, Quaternion.identity);

        msg.transform.SetParent(playerMsgPositions[1].transform);
        allMsg[1] = msg;

        skill.messageOwner = msg;

        if (skill.comesFromCurse)
        {
            skill.messageOwner.GetComponent <Image>().color = ConversationManager.Instance.cursedColor;
        }

        CombatManager.Instance.MessageIcon(msg, skill);
        //Debug.Log(skill);
        messageManager.ChoseArray(skill, msg);
        skill.PlayerEffect();
        messageToSpawn = typeToSpawn.Null;
        canAttack      = true;
        //Lancer Methode pour le Text;
    }
    public void EnemyLargeMessage(Skill skill)
    {
        enemyChargingAttack.SetActive(false);
        Enemy.Instance.isCharging = false;
        GameObject msg = Instantiate(BigMessageEnemy.gameObject, enemyMsgPositions[2].transform.position, Quaternion.identity);

        msg.transform.SetParent(enemyMsgPositions[2].transform);
        allMsg[2]          = msg;
        skill.messageOwner = msg;

        if (skill.comesFromCurse)
        {
            skill.messageOwner.GetComponent <Image>().color = ConversationManager.Instance.cursedColor;
        }

        CombatManager.Instance.MessageIcon(msg, skill);
        messageManager.ChoseArray(skill, msg);

        messageToSpawn           = typeToSpawn.Null;
        canAttack                = true;
        Enemy.Instance.canAttack = true;
        skill.messageType        = Skill.typeOfMessage.Charging;
    }
    public void EnemyChargingMessage(Skill skill)
    {
        //Initialisation.
        enemyChargingAttack.SetActive(true);
        skill.messageOwner        = enemyChargingAttack;
        skill.messageType         = Skill.typeOfMessage.Big;
        Enemy.Instance.isCharging = true;

        //Changer la couleur du message qui se charge en fonction de si il est curse ou non.
        if (skill.comesFromCurse)
        {
            skill.messageOwner.GetComponent <Image>().color = ConversationManager.Instance.cursedColor;
        }
        //else
        //{
        //    skill.messageOwner.GetComponent<Image>().color = Color.red;
        //}

        messageToSpawn           = typeToSpawn.Null;
        canAttack                = true;
        Enemy.Instance.canAttack = false;
        StartCoroutine(Enemy.Instance.EndEnemyChargeAttack(skill));
    }
    public void PlayerChargingMessage(Skill skill)
    {
        Debug.Log("ChargingAttack");
        playerChargingAttack.SetActive(true);
        skill.messageOwner         = playerChargingAttack;
        skill.messageType          = Skill.typeOfMessage.Big;
        Player.Instance.isCharging = true;

        if (skill.comesFromCurse)
        {
            skill.messageOwner.GetComponent <Image>().color = ConversationManager.Instance.cursedColor;
        }
        //else
        //{
        //    //Mettre la couleur Cyan
        //    skill.messageOwner.GetComponent<Image>().color = cyanColor;
        //}

        messageToSpawn            = typeToSpawn.Null;
        canAttack                 = true;
        Player.Instance.canAttack = false;
        StartCoroutine(Player.Instance.EndPlayerChargeAttack(skill));
    }