public static bool Prefix(ProfilesCore __instance, ref bool __result, ref Profile p)
            {
                for (int index = 0; index < 8; index++)
                {
                    if (__instance._profiles[index] == p)
                    {
                        __result = true;
                    }
                    return(false);
                }
                __result = false;

                return(false);
            }
            public static bool Prefix(ProfilesCore __instance)
            {
                if (__instance == null)
                {
                    throw new Exception("Instance was null, PANIC");
                }

                List <DuckPersona> personas = Persona.all as List <DuckPersona>;

                if (personas == null)
                {
                    throw new Exception("personas is null");
                }

                __instance._profiles = new List <Profile>()
                {
                    new Profile("Player1", InputProfile.Get("MPPlayer1"), Teams.Player1, Persona.Duck1, false, "PLAYER1"),
                    new Profile("Player2", InputProfile.Get("MPPlayer2"), Teams.Player2, Persona.Duck2, false, "PLAYER2"),
                    new Profile("Player3", InputProfile.Get("MPPlayer3"), Teams.Player3, Persona.Duck3, false, "PLAYER3"),
                    new Profile("Player4", InputProfile.Get("MPPlayer4"), Teams.Player4, Persona.Duck4, false, "PLAYER4"),
                    new Profile("Player5", InputProfile.Get("MPPlayer5"), Teams.core.teams[4], personas[4], false, "PLAYER5"),
                    new Profile("Player6", InputProfile.Get("MPPlayer6"), Teams.core.teams[5], personas[5], false, "PLAYER6"),
                    new Profile("Player7", InputProfile.Get("MPPlayer7"), Teams.core.teams[6], personas[6], false, "PLAYER7"),
                    new Profile("Player8", InputProfile.Get("MPPlayer8"), Teams.core.teams[7], personas[7], false, "PLAYER8")
                };

                Profile.loading = true;
                string[]       files        = DuckFile.GetFiles(DuckFile.profileDirectory, "*.*");
                List <Profile> profileList1 = new List <Profile>();

                foreach (string path in files)
                {
                    XDocument xdocument = DuckFile.LoadXDocument(path);
                    if (xdocument != null)
                    {
                        string  name = xdocument.Element((XName)"Profile").Element((XName)"Name").Value;
                        bool    flag = false;
                        Profile p    = __instance._profiles.FirstOrDefault <Profile>((Func <Profile, bool>)(pro => pro.name == name));
                        if (p == null || !Profiles.IsDefault(p))
                        {
                            p          = new Profile("", (InputProfile)null, (Team)null, (DuckPersona)null, false, (string)null);
                            p.fileName = path;
                            flag       = true;
                        }
                        IEnumerable <XElement> source = xdocument.Elements((XName)"Profile");
                        if (source != null)
                        {
                            foreach (XElement element1 in source.Elements <XElement>())
                            {
                                if (element1.Name.LocalName == "ID" && !Profiles.IsDefault(p))
                                {
                                    p.SetID(element1.Value);
                                }
                                else if (element1.Name.LocalName == "Name")
                                {
                                    p.name = element1.Value;
                                }
                                else if (element1.Name.LocalName == "Mood")
                                {
                                    p.funslider = Change.ToSingle((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "NS")
                                {
                                    p.numSandwiches = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "MF")
                                {
                                    p.milkFill = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "LML")
                                {
                                    p.littleManLevel = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "NLM")
                                {
                                    p.numLittleMen = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "LMB")
                                {
                                    p.littleManBucks = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "RSXP")
                                {
                                    p.roundsSinceXP = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "TimesMet")
                                {
                                    p.timesMetVincent = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "TimesMet2")
                                {
                                    p.timesMetVincentSale = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "TimesMet3")
                                {
                                    p.timesMetVincentSell = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "TimesMet4")
                                {
                                    p.timesMetVincentImport = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "TimeOfDay")
                                {
                                    p.timeOfDay = Change.ToSingle((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "CD")
                                {
                                    p.currentDay = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "XtraPoints")
                                {
                                    p.xp = Change.ToInt32((object)element1.Value);
                                }
                                else if (element1.Name.LocalName == "FurniPositions")
                                {
                                    p.furniturePositionData = BitBuffer.FromString(element1.Value);
                                }
                                else if (element1.Name.LocalName == "Fowner")
                                {
                                    p.furnitureOwnershipData = BitBuffer.FromString(element1.Value);
                                }
                                else if (element1.Name.LocalName == "SteamID")
                                {
                                    p.steamID = Change.ToUInt64((object)element1.Value);
                                    if ((long)p.steamID != 0L)
                                    {
                                        profileList1.Add(p);
                                    }
                                }
                                else if (element1.Name.LocalName == "LastKnownName")
                                {
                                    p.lastKnownName = element1.Value;
                                }
                                else if (element1.Name.LocalName == "Stats")
                                {
                                    p.stats.Deserialize(element1);
                                }
                                else if (element1.Name.LocalName == "Unlocks")
                                {
                                    string[] strArray = element1.Value.Split('|');
                                    p.unlocks = new List <string>((IEnumerable <string>)strArray);
                                }
                                else if (element1.Name.LocalName == "Tickets")
                                {
                                    p.ticketCount = Convert.ToInt32(element1.Value);
                                }
                                else if (element1.Name.LocalName == "Mappings" && !MonoMain.defaultControls)
                                {
                                    p.inputMappingOverrides.Clear();
                                    foreach (XElement element2 in element1.Elements())
                                    {
                                        if (element2.Name.LocalName == "InputMapping")
                                        {
                                            DeviceInputMapping deviceInputMapping = new DeviceInputMapping();
                                            deviceInputMapping.Deserialize(element2);
                                            p.inputMappingOverrides.Add(deviceInputMapping);
                                        }
                                    }
                                }
                            }
                        }
                        if (flag)
                        {
                            __instance._profiles.Add(p);
                        }
                    }
                }
                byte    localFlippers = Profile.CalculateLocalFlippers();
                Profile p1            = (Profile)null;

                if (Profiles.allCustomProfiles == null)
                {
                    throw new Exception("Custom Profiles null.");
                }

                if (Steam.user != null && (long)Steam.user.id != 0L)
                {
                    string str = Steam.user.id.ToString();
                    foreach (Profile allCustomProfile in Profiles.allCustomProfiles)
                    {
                        if ((long)allCustomProfile.steamID == (long)Steam.user.id && allCustomProfile.id == str && allCustomProfile.rawName == str)
                        {
                            p1 = allCustomProfile;
                            break;
                        }
                    }
                    if (p1 == null)
                    {
                        p1 = new Profile(Steam.user.id.ToString(), (InputProfile)null, (Team)null, (DuckPersona)null, false, Steam.user.id.ToString())
                        {
                            steamID = Steam.user.id
                        };
                        Profiles.Add(p1);
                        __instance.Save(p1);
                    }
                }
                if (p1 != null)
                {
                    __instance._profiles.Remove(p1);
                    __instance._profiles.Insert(8, p1);
                    List <Profile> source       = new List <Profile>();
                    List <Profile> profileList2 = new List <Profile>();
                    foreach (Profile allCustomProfile in Profiles.allCustomProfiles)
                    {
                        string str = allCustomProfile.steamID.ToString();
                        if ((long)allCustomProfile.steamID != 0L)
                        {
                            if (allCustomProfile.id == str && allCustomProfile.rawName == str)
                            {
                                source.Add(allCustomProfile);
                            }
                            else
                            {
                                profileList2.Add(allCustomProfile);
                            }
                        }
                    }
                    using (List <Profile> .Enumerator enumerator = profileList2.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            Profile pro = enumerator.Current;
                            Profile p2  = source.FirstOrDefault <Profile>((Func <Profile, bool>)(x => (long)x.steamID == (long)pro.steamID));
                            if (p2 == null)
                            {
                                p2         = new Profile(pro.steamID.ToString(), (InputProfile)null, (Team)null, (DuckPersona)null, false, pro.steamID.ToString());
                                p2.steamID = pro.steamID;
                                Profiles.Add(p2);
                            }
                            p2.stats = (ProfileStats)((DataClass)p2.stats + (DataClass)pro.stats);
                            foreach (KeyValuePair <string, List <ChallengeSaveData> > keyValuePair in (MultiMap <string, ChallengeSaveData, List <ChallengeSaveData> >)Challenges.saveData)
                            {
                                ChallengeSaveData        challengeSaveData1    = (ChallengeSaveData)null;
                                List <ChallengeSaveData> challengeSaveDataList = new List <ChallengeSaveData>();
                                foreach (ChallengeSaveData challengeSaveData2 in keyValuePair.Value)
                                {
                                    if (challengeSaveData2.profileID == pro.id || challengeSaveData2.profileID == p2.id)
                                    {
                                        challengeSaveData2.profileID = p2.id;
                                        if (challengeSaveData1 == null)
                                        {
                                            challengeSaveData1 = challengeSaveData2;
                                        }
                                        else if (challengeSaveData2.trophy > challengeSaveData1.trophy)
                                        {
                                            challengeSaveDataList.Add(challengeSaveData1);
                                            challengeSaveData1 = challengeSaveData2;
                                        }
                                        else
                                        {
                                            challengeSaveDataList.Add(challengeSaveData2);
                                        }
                                    }
                                }
                                foreach (ChallengeSaveData challengeSaveData2 in challengeSaveDataList)
                                {
                                    string str = challengeSaveData2.profileID + "OBSOLETE";
                                    challengeSaveData2.profileID = str;
                                }
                                if (challengeSaveData1 != null)
                                {
                                    Challenges.Save(keyValuePair.Key);
                                }
                            }
                            __instance._profiles.Remove(pro);
                            DuckFile.Delete(pro.fileName);
                            __instance.Save(p2);
                        }
                    }
                }
                foreach (Profile profile in __instance._profiles)
                {
                    profile.flippers    = localFlippers;
                    profile.ticketCount = Challenges.GetTicketCount(profile);
                    if (profile.ticketCount < 0)
                    {
                        profile.ticketCount = 0;
                    }
                }
                Profile.loading = false;

                return(false);
            }
Ejemplo n.º 3
0
        // This function is run before all mods are finished loading.
        protected override void OnPreInitialize()
        {
            // The order of these is important for some things, others not. I'll document what each one does eventually.

            // Load the embedded DLL which has unsafe code. Allows duck game to compile this source and still use unsafe code.
            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);

            // Get the profile core. Its not supposed to be accessed outside the main thread but I won't tell if you won't.
            ProfilesCore profilecore = typeof(Profiles).GetField("_core", BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public).GetValue(null) as ProfilesCore;

            // Normally generates 4 MPPlayer profiles, now does 8
            Injection.install(2, "InitDefaultProfiles", "InitDefaultProfiles");

            // Add our extra personas to the table
            PersonaEdits._personas();

            // Replace the get_defaultProfiles() with one that handles the extra 4 player teams
            InputProfileCoreEdits.defaultProfiles();

            // Duck Game would just check which profiles were past the first 4 and decide they were custom, changed to skip the first 8
            ProfilesCoreEdits.allCustomProfiles();

            // Generates the default Player1-Player8 Profiles now
            Injection.install(5, "Initialize", "Initialize");

            // Returns the first 8 profiles as defaults
            Injection.install(5, "IsDefault", "IsDefault");

            // Generates the extra 4 GenericControllers for the added players
            InputEdits.Initialize();

            // Invokes the new InitDefaultProfiles(). This may not be needed as it may get injected before it gets run the first time. I'll check
            InputEdits.InitDefaultProfiles();

            // Generates 8 Netduck profiles instead of the default 4
            Injection.install(1, "RecreateProfiles", "RecreateProfiles");

            // Allows the host to select between 2 and 8 players maximum for their lobby
            TeamSelect2Edits.OnlineSettings();

            // Add the extra 4 default teams that will be used for the extra players
            TeamsCoreEdits.Initialize();

            // Generate new profile boxes for the lobby level. Also tweaks the camera for it. Will make it not stretched at some point
            Injection.install(4, "UpdateModifierStatus", "UpdateModifierStatus");

            // DoInvite would call Host(4, LobbyType.FriendsOnly) so we change it to 8 max players
            Injection.install(4, "DoInvite", "DoInvite");

            // Would only purge the first 4 boxes by default. Now purges all 8
            Injection.install(4, "FillMatchmakingProfiles", "FillMatchmakingProfiles");

            // ClearTeam() would return if the index was >=4. We need it to be >=8 for the extra teams
            Injection.install(4, "ClearTeam", "ClearTeam");

            // Return the extra inputprofiles for the extra teams
            Injection.install(6, "ControllerNumber", "ControllerNumber");

            // Trying to detour ConfirmTeamSelection was proving a nightmare so I did this garbage solution.
            // A check at the bottom of ConfirmTeamSelection was returning incorrectly due to the extra teams and crashing
            // When I tried injecting my new method, it was never called for some reason. Not sure why, probably due to instancing
            // To deal with this I edited FilterTeam which gets called at the start of ConfirmTeamSelection and did a check where
            // if the _desiredteamselection was <= 7 then set it to 0. This meant the check that was crashing returned correctly
            // and as far as I can tell there aren't any noticeable side effects. Will find better method eventually.
            Injection.install(6, "FilterTeam", "FilterTeam");

            // Because inline removes TeamSelect2.OnNetworkConnecting, I have to inject the methods that called it to change them
            Injection.install(3, "JoinLocalDuck", "JoinLocalDuck");
            Injection.install(3, "OnMessageFromNewClient", "OnMessageFromNewClient");
            Injection.install(3, "OnMessage", "OnMessage");

            // New NMChangeSlot net message as the old one only handled 4 parameters and we need 8.
            Injection.install(3, "ChangeSlotSettings", "ChangeSlotSettings");

            // DuckNetwork.Update calls Host( 4, LobbyType.FriendsOnly ) on inviting someone. Since performance would be garbage reflecting all
            // the private variables, we detour host instead.
            Injection.install(3, "Host", "Host");

            // Only would clear custom data for the first 4 profiles so now it clears all 8
            Injection.install(3, "Join", "Join");

            // Adds our new netmessage to the list of netmessage types so that the game doesn't crash when it encounters it
            DuckNetworkEdits.UpdateNetmessageTypes();

            // netProfileIndex determines how many bits are used to store it. Since we need to store up to the value of seven, we need 3 bits
            // rather than the default 2. Best way I thought would be change it when the ducks get added but idk.
            Injection.install(8, "Add", "AddReplace");

            // Method to inject a call into LevelUpdateChange so that it calls our varient which then checks for rock scoreboard
            // then calls our patched Initialize.
            LevelEdits.UpdateLevelChange();

            // NMVoteToSkip checks whether the player index is greater than 3 and discards it if it is. We want it to be discarded when greater
            // than 7.
            NMVoteToSkipEdits.Activate();

            // Change the get method for determining if a room if on the right or left to Value % 2. Will return 1 if on the right.
            // We inject pure assembly so THIS WILL BREAK EVENTUALLY.
            ProfileBox2Edits.rightRoomCorrection();

            // Injection.install(0, "UpdateQuack", "injectionMethod1"); // Disables quack to check everything loaded right

            // Base
            base.OnPreInitialize();
        }