private IEnumerator RemoveSpawnMultiplicator(TwitteType _type, float _multiplicator, float _duration)
    {
        yield return(new WaitForSeconds(_duration));

        switch (_type)
        {
        case TwitteType.CritNegative:
            critNegativeTwitteSpawnRate /= _multiplicator;
            break;

        case TwitteType.CritPositive:
            critPositiveTwitteSpawnRate /= _multiplicator;
            break;

        case TwitteType.Insulte:
            insulteTwitteSpawnRate /= _multiplicator;
            break;

        case TwitteType.Compliment:
            complimentTwitteSpawnRate /= _multiplicator;
            break;

        case TwitteType.Inutile:
            inutileTwitteSpawnRate /= _multiplicator;
            break;
        }
    }
    public void SpawnMultiplicator(TwitteType _type, float _multiplicator, float _duration)
    {
        switch (_type)
        {
        case TwitteType.CritNegative:
            critNegativeTwitteSpawnRate *= _multiplicator;
            break;

        case TwitteType.CritPositive:
            critPositiveTwitteSpawnRate *= _multiplicator;
            break;

        case TwitteType.Insulte:
            insulteTwitteSpawnRate *= _multiplicator;
            break;

        case TwitteType.Compliment:
            complimentTwitteSpawnRate *= _multiplicator;
            break;

        case TwitteType.Inutile:
            inutileTwitteSpawnRate *= _multiplicator;
            break;
        }
        StartCoroutine(RemoveSpawnMultiplicator(_type, _multiplicator, _duration));
    }
    public IEnumerator BoolBackTo(TwitteType type)
    {
        yield return(new WaitForSeconds(rTDuration));

        switch (type)
        {
        case TwitteType.CritNegative:
            isRTCritNegative = false;
            break;

        case TwitteType.CritPositive:
            isRTCritPositive = false;
            break;

        case TwitteType.Insulte:
            isRTInsulte = false;
            break;

        case TwitteType.Compliment:
            isRTCompliment = false;
            break;

        case TwitteType.Inutile:
            isRTInutile = false;
            break;
        }
    }
Exemple #4
0
 public TwitteData(string _pseudo, string _corp, TwitteType _type, int _impactEgo, int _impactHappy)
 {
     pseudo      = _pseudo;
     corp        = _corp;
     twitteType  = _type;
     impactEgo   = _impactEgo;
     impactHappy = _impactHappy;
 }
 public void ReceivingTwitte(int _happinesse, int _ego, TwitteType type)
 {
     ReceivingTwitte(_happinesse, _ego, type, 0);
 }
    public void ReceivingTwitte(int _happinesse, int _ego, TwitteType type, int _popularity, bool isLiked = false)
    {
        int i = type.GetHashCode();

        if (isLiked)
        {
            happinesse += (int)(_happinesse * factorHappinesse * twitteTypeFactor[i] * likeFactor);
            ego        += (int)(_ego * factorEgo * twitteTypeFactor[i] * likeFactor);
            popularity += (int)(_popularity * likeFactor);
        }
        else
        {
            happinesse += _happinesse * factorHappinesse * twitteTypeFactor[i];
            ego        += _ego * factorEgo * twitteTypeFactor[i];
            popularity += _popularity;
        }
        if (happinesse > 100)
        {
            happinesse = 100;
        }
        if (ego > 100)
        {
            ego = 100;
        }

        float tmphappy = ((float)happinesse - 100);

        if (tmphappy < 0)
        {
            tmphappy = -tmphappy;
        }

        sliderHappy.value = tmphappy / 100f;
        //sliderHappyText.text = happinesse.ToString();

        float tmpego = ((float)ego - 100);

        if (tmpego < 0)
        {
            tmpego = -tmpego;
        }

        sliderEgo.value = tmpego / 100f;
        //sliderEgoText.text = ego.ToString();

        follower.text = "Followers " + popularity.ToString();

        switch (type)
        {
        case TwitteType.CritNegative:
            GameManager.Instance.isRTCritNegative = true;
            break;

        case TwitteType.CritPositive:
            GameManager.Instance.isRTCritPositive = true;
            break;

        case TwitteType.Insulte:
            GameManager.Instance.isRTInsulte = true;
            break;

        case TwitteType.Compliment:
            GameManager.Instance.isRTCompliment = true;
            break;

        case TwitteType.Inutile:
            GameManager.Instance.isRTInutile = true;
            break;
        }
        StartCoroutine(GameManager.Instance.BoolBackTo(type));

        UpdateFace();
    }
 public void SpawnMultiplicator(TwitteType _type)
 {
     SpawnMultiplicator(_type, rTSpawnMultiplicator, rTDuration);
 }
    private void Spawner(TwitteType type)
    {
        if (!canSpawnTwitte)
        {
            return;
        }

        if (ObjectPooler.Instance == null)
        {
            Debug.LogError("No ObjectPooler on scene");
            return;
        }

        //random pos
        Vector3 tmpPos = new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), 0).normalized *spawnRange;

        while (tmpPos.magnitude < .9f)
        {
            tmpPos = new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), 0).normalized *spawnRange;
        }

        List <TwitteData> _persoTwittes;

        switch (type)
        {
        case TwitteType.CritNegative:
            _persoTwittes = lRTCritNegative;
            break;

        case TwitteType.CritPositive:
            _persoTwittes = lRTCritPositive;
            break;

        case TwitteType.Insulte:
            _persoTwittes = lRTInsulte;
            break;

        case TwitteType.Compliment:
            _persoTwittes = lRTCompliment;
            break;

        case TwitteType.Inutile:
            _persoTwittes = lRTInutile;
            break;

        default:
            return;
        }

        int twiteNumber = Random.Range(0, _persoTwittes.Count);

        Debug.Log(twiteNumber);

        for (int i = blacklistName.Count; i-- > 0;)
        {
            if (_persoTwittes[twiteNumber].pseudo == blacklistName[i])
            {
                return;
            }
        }


        //Debug.Log(persoTwittes[twiteNumber].pseudo);
        ObjectPooler.Instance.SpawnFromPool("Twitte", (perso1Obj.transform.position + tmpPos), Quaternion.identity, perso1Obj.GetComponent <PersonalityLife>(), _persoTwittes[twiteNumber].pseudo, persoTwittes[twiteNumber].corp, _persoTwittes[twiteNumber].impactEgo, _persoTwittes[twiteNumber].impactHappy);
    }
Exemple #9
0
    IEnumerator GetShit()
    {
        string url = "https://sheets.googleapis.com/v4/spreadsheets/" + documentId + "/values/" + idleModeSheetName + "!" + idleModeCellRange.startCell + ":" + idleModeCellRange.endCell + "?majorDimension=ROWS&key=" + apiKey;

        UnityWebRequest request = new UnityWebRequest(url);

        request.downloadHandler = new DownloadHandlerBuffer();

        request.method = UnityWebRequest.kHttpVerbGET;
        request.SetRequestHeader("content-type", "application/json; charset=utf-8");
        request.SetRequestHeader("accept", "application/json;");

        yield return(request.SendWebRequest());

        List <TwitteData> twitteDatas = new List <TwitteData>();

        if (request.isNetworkError)
        {
            Debug.Log("Error");
        }
        else if (request.isHttpError)
        {
            Debug.Log("Error: " + request.responseCode);
        }
        else
        {
            try
            {
                resultJson = request.downloadHandler.text;

                SheetData sheetData = JsonConvert.DeserializeObject <SheetData>(resultJson, new JsonSerializerSettings {
                    NullValueHandling = NullValueHandling.Ignore
                });
                for (int i = sheetData.values.Count; i-- > 0;)
                {
                    TwitteType type = TwitteType.Normal;

                    switch (sheetData.values[i][2])
                    {
                    case "critique négative":
                        type = TwitteType.CritNegative;
                        break;

                    case "critique positive":
                        type = TwitteType.CritPositive;
                        break;

                    case "insulte":
                        type = TwitteType.Insulte;
                        break;

                    case "compliment":
                        type = TwitteType.Compliment;
                        break;

                    case "inutile":
                        type = TwitteType.Insulte;
                        break;
                    }

                    twitteDatas.Add(new TwitteData(sheetData.values[i][0], sheetData.values[i][1], type, int.Parse(sheetData.values[i][3]), int.Parse(sheetData.values[i][4])));
                }
            }
            catch (Exception e)
            {
                Debug.LogError(e.StackTrace);
            }
        }

        if (GameManager.Instance != null)
        {
            GameManager.Instance.StartRound(twitteDatas);
        }
    }