/// <summary>
    /// Get Training data modified by player stats.
    /// </summary>
    /// <param name="train"></param>
    /// <returns></returns>
    public Training GetTraining(Training.Train train)
    {
        Training training = Trainings.trainings[train].DeepCopy();

        foreach (PlayerData.PP pref in training.modifier.Keys.ToList())
        {
            training.modifier[pref] += 0.003f * playerData.GetDictData(PlayerData.PP.COMPREHENSION) / 100;
        }

        return(training);
    }
Exemple #2
0
    //initializer
    public Batter(int _index, PlayerData _playerData, PlayerStatistics _stats, Training.Train _train, float first = 0, float second = 0, float third = 0, float fourth = 0)
        : base(_index, _playerData, _stats, _train)
    {
        finalStats = new SerializableDict <string, float>
        {
            d = new Dictionary <string, float>()
            {
                { "STR", first },
                { "CTR", second },
                { "CON", third },
                { "INT", fourth }
            }
        };

        playerData.SetData(PlayerData.PP.OVERALL, GetOverall());

        CalcFinalStats();
    }
    public Player(int _index, PlayerData _playerData, PlayerStatistics _stats, Training.Train _train)
    {
        index = _index;

        playerData = new PlayerData(_playerData.GetData(PlayerData.PP.NAME));

        foreach (KeyValuePair <PlayerData.PP, object> pd in _playerData.data.d)
        {
            playerData.data.d[pd.Key] = pd.Value;
        }

        playerData.SetData(PlayerData.PP.AGE, GetAge());

        stats = new PlayerStatistics(1);

        foreach (KeyValuePair <DateTime, SerializableDict <PlayerStatistics.PS, float> > ps in _stats.statistics.d)
        {
            foreach (KeyValuePair <PlayerStatistics.PS, float> data in ps.Value.d)
            {
                stats.SetStat(data.Value, data.Key, ps.Key);
            }
        }

        train = _train;
        order = -1;

        //Debug.Log("STAT:   " + stats.statistics.d.Count);
        //Debug.Log("SEASON: " + stats.seasonStats.d.Count);

        //foreach (KeyValuePair<int, SerializableDict<PlayerStatistics.PS, float>> ps in stats.seasonStats.d)
        //{
        //    Debug.Log(ps.Key + " G: " + ps.Value[PlayerStatistics.PS.G]);
        //}

        //Debug.Log(stats.seasonStats[Values.date.Year][PlayerStatistics.PS.G]);

        //Debug.Log(stats.GetStat(PlayerStatistics.PS.G, new DateTime(2019, 1, 1)));

        CalcStats();
    }
Exemple #4
0
    //initializers
    public Pitcher(int _index, PlayerData _playerData, PlayerStatistics _stats, Training.Train _train, Dictionary <Pitch, float> _pitches = null, float first = 0, float second = 0, float third = 0, float fourth = 0)
        : base(_index, _playerData, _stats, _train)
    {
        if (_pitches != null)
        {
            pitches = new SerializableDict <Pitch, float>();
            foreach (KeyValuePair <Pitch, float> pitch in _pitches)
            {
                pitches.d.Add(pitch.Key, pitch.Value);
            }
        }
        else
        {
            pitches = new SerializableDict <Pitch, float>()
            {
                d =
                {
                    { Pitch.FOURSEAM,  50 },
                    { Pitch.CURVEBALL, 50 }
                }
            };
        }

        finalStats = new SerializableDict <string, float>
        {
            d = new Dictionary <string, float>()
            {
                { "STR", first },
                { "CTR", second },
                { "CON", third },
                { "INT", fourth }
            }
        };

        playerData.SetData(PlayerData.PP.OVERALL, GetOverall());

        CalcFinalStats();
    }
Exemple #5
0
    /// <summary>
    /// Creats a random player.
    /// </summary>
    /// <param name="isPitcher"></param>
    /// <param name="metaPosition"></param>
    /// <returns></returns>
    public static Player CreatePlayer(bool isPitcher = true, Player.MetaPosition metaPosition = Player.MetaPosition.STARTER_PITCHER)
    {
        PlayerData       playerData = new PlayerData("", 0, 0, 0, metaPosition);
        PlayerStatistics stats      = new PlayerStatistics(1);

        playerData.SetData(PlayerData.PP.NAME, RandomNameGenerator.MakeName());
        playerData.SetData(PlayerData.PP.NUMBER, UnityEngine.Random.Range(0, 100));
        playerData.SetData(PlayerData.PP.BIRTH_DATE, new DateTime(UnityEngine.Random.Range(1970, 2000), UnityEngine.Random.Range(1, 13), UnityEngine.Random.Range(1, 28)));
        playerData.SetData(PlayerData.PP.HEIGHT, UnityEngine.Random.Range(170f, 190f));
        playerData.SetData(PlayerData.PP.WEIGHT, UnityEngine.Random.Range(60f, 90f));
        playerData.SetData(PlayerData.PP.IS_LEFT_HANDED, RandomHanded());
        playerData.SetData(PlayerData.PP.CONDITION, UnityEngine.Random.Range(80f, 100f));

        foreach (PlayerData.PP metaPref in PlayerData.serializableDictPrefs.Keys.ToList())
        {
            if (metaPref == PlayerData.PP.PITCH)
            {
                continue;
            }
            foreach (PlayerData.PP pref in ((SerializableDictPP)playerData.data.d[metaPref]).d.Keys.ToList())
            {
                playerData.SetDictData(metaPref, UnityEngine.Random.Range(30f, 100f), pref);
            }
        }

        //training
        Training.Train train = (Training.Train)UnityEngine.Random.Range(0, Training.trainString.Count);

        //pitcher
        if (isPitcher)
        {
            //Sets pitches.
            float valueTemp = UnityEngine.Random.Range(30f, 100f);
            Dictionary <Pitcher.Pitch, float> pitches = new Dictionary <Pitcher.Pitch, float>
            {
                { Pitcher.Pitch.FOURSEAM, valueTemp }
            };

            playerData.data.d.Add(PlayerData.PP.PITCH, new SerializableDictPP());
            playerData.SetDictData(PlayerData.PP.PITCH, valueTemp, (PlayerData.PP)PlayerData.PPString.IndexOf(Pitcher.PitchString[(int)Pitcher.Pitch.FOURSEAM]));
            for (int i = 0; i < UnityEngine.Random.Range(1, 6); ++i)
            {
                Pitcher.Pitch pitch;
                do
                {
                    pitch = (Pitcher.Pitch)UnityEngine.Random.Range(0, Enum.GetNames(typeof(Pitcher.Pitch)).Length);
                } while (pitches.ContainsKey(pitch));
                float value = UnityEngine.Random.Range(30f, 100f);
                pitches.Add(pitch, value);
                playerData.SetDictData(PlayerData.PP.PITCH, value, (PlayerData.PP)PlayerData.PPString.IndexOf(Pitcher.PitchString[(int)pitch]));
            }

            //Sets random pitcher stat data.
            for (int year = Values.date.Year - UnityEngine.Random.Range(1, 3); year <= Values.date.Year; ++year)
            {
                int gameTotal = UnityEngine.Random.Range(20, 33);
                for (int game = 0; game < gameTotal; ++game)
                {
                    DateTime date = new DateTime(year, game / 28 + 1, game % 28 + 1);
                    stats.SetStat(1, PlayerStatistics.PS.G, date);
                    foreach (PlayerStatistics.PS stat in PlayerStatistics.pitcherPS)
                    {
                        stats.SetStat(UnityEngine.Random.Range(1, 3), stat, date);
                    }
                }
            }

            Player.AddPlayerCreated();
            return(new Pitcher(Player.GetPlayerCreated(), playerData, stats, train, pitches, playerData.GetData(PlayerData.PP.STRENGTH), playerData.GetData(PlayerData.PP.CONTROL), playerData.GetData(PlayerData.PP.CONSISTENCY), playerData.GetData(PlayerData.PP.INTELLECT)));
        }
        //batter
        else
        {
            //playerData.SetData(PlayerData.PP.POSITION, (Player.Position)UnityEngine.Random.Range(0, 9));

            //Sets batter stat data.
            for (int year = Values.date.Year - UnityEngine.Random.Range(1, 3); year <= Values.date.Year; ++year)
            {
                int gameTotal = UnityEngine.Random.Range(20, 33);
                for (int game = 0; game < gameTotal; ++game)
                {
                    DateTime date = new DateTime(year, game / 28 + 1, game % 28 + 1);
                    stats.SetStat(1, PlayerStatistics.PS.G, date);
                    foreach (PlayerStatistics.PS stat in PlayerStatistics.batterPS)
                    {
                        stats.SetStat(UnityEngine.Random.Range(1, 3), stat, date);
                    }
                }
            }

            Player.AddPlayerCreated();
            return(new Batter(Player.GetPlayerCreated(), playerData, stats, train, playerData.GetData(PlayerData.PP.STRENGTH), playerData.GetData(PlayerData.PP.CONTROL), playerData.GetData(PlayerData.PP.CONSISTENCY), playerData.GetData(PlayerData.PP.INTELLECT)));
        }
    }