예제 #1
0
        static void Prefix(int index, TownInterfaceController __instance)
        {
            if (storedData.getSortData() == index)
            {
                storedData.saveAscendingData(!storedData.getAscendingData());
            }
            else
            {
                storedData.saveAscendingData(false);
            }

            storedData.saveSortData(index);
        }
예제 #2
0
        static void Prefix(TownInterfaceController __instance)
        {
            __instance.GetType().GetField("currentSort", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(__instance, storedData.getSortData());
            __instance.GetType().GetField("sortAscending", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(__instance, storedData.getAscendingData());

            int  currentSort      = Traverse.Create(__instance).Field("currentSort").GetValue <int>();
            int  characterSelPage = Traverse.Create(__instance).Field("characterSelPage").GetValue <int>();
            bool sortAscending    = Traverse.Create(__instance).Field("sortAscending").GetValue <bool>();

            int index = currentSort;

            //__instance.characterSelPage = 0;
            __instance.GetType().GetField("characterSelPage", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(__instance, 0);

            if (!sortAscending)
            {
                switch (index)
                {
                case 0:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.CharacterMarker == b.CharacterMarker)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-((int)a.CharacterMarker).CompareTo((int)b.CharacterMarker));
                    });
                    return;

                case 1:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.Level == b.Level)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-a.Level.CompareTo(b.Level));
                    });
                    return;

                case 2:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.Stamina == b.Stamina)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-a.Stamina.CompareTo(b.Stamina));
                    });
                    return;

                case 3:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.CurrMorale == b.CurrMorale)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-a.CurrMorale.CompareTo(b.CurrMorale));
                    });
                    return;

                case 4:
                    TownManager.instance.home.Sort((Stats a, Stats b) => - a.getStrengthEval().CompareTo(b.getStrengthEval()));
                    return;

                case 5:
                    TownManager.instance.home.Sort((Stats a, Stats b) => - a.getBrothelScore(true).CompareTo(b.getBrothelScore(true)));
                    return;

                case 6:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.species == b.species)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-a.species.CompareTo(b.species));
                    });
                    return;

                case 7:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.battleRank == b.battleRank)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-a.battleRank.CompareTo(b.battleRank));
                    });
                    return;

                case 8:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.size == b.size)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-a.size.CompareTo(b.size));
                    });
                    return;

                case 9:
                    TownManager.instance.home.Sort((Stats a, Stats b) => - a.getTotalGeneticValue().CompareTo(b.getTotalGeneticValue()));
                    return;

                case 10:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.CurrentEnergy == b.CurrentEnergy)
                        {
                            return(-a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(-a.CurrentEnergy.CompareTo(b.CurrentEnergy));
                    });
                    return;

                default:
                    return;
                }
            }
            else
            {
                switch (index)
                {
                case 0:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.CharacterMarker == b.CharacterMarker)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(((int)a.CharacterMarker).CompareTo((int)b.CharacterMarker));
                    });
                    return;

                case 1:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.Level == b.Level)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(a.Level.CompareTo(b.Level));
                    });
                    return;

                case 2:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.Stamina == b.Stamina)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(a.Stamina.CompareTo(b.Stamina));
                    });
                    return;

                case 3:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.CurrMorale == b.CurrMorale)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(a.CurrMorale.CompareTo(b.CurrMorale));
                    });
                    return;

                case 4:
                    TownManager.instance.home.Sort((Stats a, Stats b) => a.getStrengthEval().CompareTo(b.getStrengthEval()));
                    return;

                case 5:
                    TownManager.instance.home.Sort((Stats a, Stats b) => a.getBrothelScore(true).CompareTo(b.getBrothelScore(true)));
                    return;

                case 6:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.species == b.species)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(a.species.CompareTo(b.species));
                    });
                    return;

                case 7:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.battleRank == b.battleRank)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(a.battleRank.CompareTo(b.battleRank));
                    });
                    return;

                case 8:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.size == b.size)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(a.size.CompareTo(b.size));
                    });
                    return;

                case 9:
                    TownManager.instance.home.Sort((Stats a, Stats b) => a.getTotalGeneticValue().CompareTo(b.getTotalGeneticValue()));
                    return;

                case 10:
                    TownManager.instance.home.Sort(delegate(Stats a, Stats b)
                    {
                        if (a.CurrentEnergy == b.CurrentEnergy)
                        {
                            return(a.genetics.id.CompareTo(b.genetics.id));
                        }
                        return(a.CurrentEnergy.CompareTo(b.CurrentEnergy));
                    });
                    return;

                default:
                    return;
                }
            }
        }
예제 #3
0
 static void Prefix(TownInterfaceController __instance)
 {
     storedData.saveSortData(Traverse.Create(__instance).Field("currentSort").GetValue <int>());
     storedData.saveAscendingData(Traverse.Create(__instance).Field("sortAscending").GetValue <bool>());
 }