Esempio n. 1
0
        static void Main(string[] args)
        {
            GameManager manager = new GameManager();

            GameInfo borderlands2 = manager.Games["720CE71B-FCBF-46C8-AC9D-C4B2BF3169E3"];
            UserGameInfo borderInfo = manager.AddGame(borderlands2, @"C:\Program Files (x86)\Steam\steamapps\common\Borderlands 2\Binaries\Win32\Borderlands2.exe");

            GameProfile profile = new GameProfile();
            profile.InitializeDefault(borderlands2);

            PlayerInfo p1 = new PlayerInfo();
            p1.monitorBounds = new Rectangle(0, 0, 960, 540);
            p1.screenIndex = 0;
            profile.PlayerData.Add(p1);

            PlayerInfo p2 = new PlayerInfo();
            p2.monitorBounds = new Rectangle(0, 540, 960, 540);
            p2.screenIndex = 0;
            profile.PlayerData.Add(p2);

            borderInfo.Profiles.Add(profile);

            manager.WaitSave();

            // try to play game with custom profile
            handler = manager.MakeHandler(borderlands2);

            handler.Initialize(borderInfo, profile);

            ThreadPool.QueueUserWorkItem(Play);
            //handler.Play();

            for (; ; )
            {
                Thread.Sleep(16);
                handler.Update(16);

                if (handler.HasEnded)
                {
                    break;
                }
            }
        }
Esempio n. 2
0
        private void num_Players_ValueChanged(object sender, EventArgs e)
        {
            for (int i = 0; i < Panels.Count; i++)
            {
                Panels[i].Dispose();
            }

            for (int i = 0; i < Players.Count; i++)
            {
                PlayerInfo p = Players[i];
                if (p.Control != null)
                {
                    p.Control.Dispose();
                }
            }
            Players.Clear();
            int players = (int) this.num_Players.Value;
            for (int i = 0; i < players; i++)
            {
                PlayerInfo p = new PlayerInfo();
                Players.Add(p);
            }

            for (int z = 0; z < Screens.Count; z++)
            {
                ScreenControl scr = Screens[z];

                ContextMenu context = new System.Windows.Forms.ContextMenu();
                for (int i = 0; i < players; i++)
                {
                    MenuItem player1 = new MenuItem("Set Player " + (i + 1).ToString(CultureInfo.InvariantCulture));
                    context.MenuItems.Add(player1);

                    for (int x = 0; x < 5; x++)
                    {
                        ScreenType screen = (ScreenType)x;

                        MenuItem SetPlayer = new MenuItem("To " + screen.ToString());
                        Holder holder = new Holder();
                        holder.Player = i;
                        holder.Control = scr;
                        holder.Screen = screen;
                        holder.ScreenIndex = z;
                        SetPlayer.Tag = holder;

                        SetPlayer.Click += new EventHandler(SetPlayer_Click);
                        player1.MenuItems.Add(SetPlayer);
                    }
                }

                if (scr.ContextMenu != null)
                {
                    scr.ContextMenu.Dispose();
                }

                scr.ContextMenu = context;
            }
        }
        protected void ScreenClick(object sender, EventArgs e)
        {
            if (hover == null)
            {
                return;
            }
            ToolStripDropDownItem item = (ToolStripDropDownItem)sender;
            ScreenHolder holda = (ScreenHolder)item.Tag;

            for (int i = 0; i < loaded_screens.Count; i++)
            {
                var mscreen = loaded_screens[i];
                for (int j = 0; j < mscreen.Controls.Count; j++)
                {
                    Control con = mscreen.Controls[j];

                    if (con is PlayerControl)
                    {
                        PlayerControl player = (PlayerControl)con;
                        if (player.Player.Player == holda.Player)
                        {
                            player.Dispose();
                            hover.Controls.Remove(player);
                            players.Remove(player.Player);
                        }
                    }
                }
            }

            for (int i = 0; i < hover.Controls.Count; i++)
            {
                Control con = hover.Controls[i];

                if (con is PlayerControl)
                {
                    PlayerControl player = (PlayerControl)con;
                    PlayerInfo otha = player.Player;

                    // if one coincides with the other, remove the other one
                    if (otha.ScreenType == ScreenType.Fullscreen ||
                        otha.ScreenType == holda.Position ||
                        holda.Position == ScreenType.HorizontalTop &&
                        (otha.ScreenType == ScreenType.TopLeft || otha.ScreenType == ScreenType.TopRight || otha.ScreenType == ScreenType.VerticalLeft || otha.ScreenType == ScreenType.VerticalRight) ||
                        holda.Position == ScreenType.HorizontalBottom &&
                        (otha.ScreenType == ScreenType.BottomLeft || otha.ScreenType == ScreenType.BottomRight || otha.ScreenType == ScreenType.VerticalLeft || otha.ScreenType == ScreenType.VerticalRight) ||
                        holda.Position == ScreenType.VerticalLeft &&
                        (otha.ScreenType == ScreenType.TopLeft || otha.ScreenType == ScreenType.BottomLeft || otha.ScreenType == ScreenType.HorizontalTop || otha.ScreenType == ScreenType.HorizontalBottom) ||
                        holda.Position == ScreenType.VerticalRight &&
                        (otha.ScreenType == ScreenType.TopRight || otha.ScreenType == ScreenType.BottomRight || otha.ScreenType == ScreenType.HorizontalTop || otha.ScreenType == ScreenType.HorizontalBottom))
                    {
                        // Love boolean Math XD
                        player.Dispose();
                        hover.Controls.Remove(player);
                        players.Remove(otha);
                    }
                }
            }

            PlayerInfo playa = new PlayerInfo();
            playa.ScreenIndex = this.loaded_screens.IndexOf(hover);
            playa.ScreenType = holda.Position;
            playa.Player = holda.Player;

            PlayerControl theplayer = new PlayerControl(playa);
            theplayer.MouseEnter += scr_MouseEnter;
            theplayer.ChangeName("Player " + holda.Player);
            hover.Controls.Add(theplayer);
            theplayer.BringToFront();
            theplayer.Accomodate();
            players.Add(playa);
        }
Esempio n. 4
0
        public void Update(int delayMS)
        {
            if (profile == null)
            {
                return;
            }

            exited = 0;
            List <PlayerInfo> players = profile.PlayerData;

            timer += delayMS;

            for (int i = 0; i < players.Count; i++)
            {
                PlayerInfo p = players[i];
                if (p.screenData == null || p.Process == null)
                {
                    continue;
                }

                if (p.SteamEmu)
                {
                    List <int> children = ProcessUtil.GetChildrenProcesses(p.Process);
                    if (children.Count > 0)
                    {
                        for (int j = 0; j < children.Count; j++)
                        {
                            int     id    = children[j];
                            Process child = Process.GetProcessById(id);
                            try
                            {
                                if (child.ProcessName.Contains("conhost"))
                                {
                                    continue;
                                }
                            }
                            catch
                            {
                                continue;
                            }

                            p.Process  = child;
                            p.SteamEmu = child.ProcessName.Contains("SmartSteamLoader") || child.ProcessName.Contains("cmd");
                        }
                    }
                }
                else
                {
                    ScreenData data = p.screenData;

                    if (data.Set)
                    {
                        if (p.Process.HasExited)
                        {
                            exited++;
                            continue;
                        }

                        if (!p.screenData.KilledMutexes && gen.KillMutex.Length > 0)
                        {
                            StartGameUtil.KillMutex(p.Process, gen.KillMutex);
                            p.screenData.KilledMutexes = true;
                        }

                        uint lStyle = User32Interop.GetWindowLong(data.HWND.Hwnd, User32_WS.GWL_STYLE);
                        if (lStyle != data.RegLong)
                        {
                            uint toRemove = User32_WS.WS_CAPTION;
                            lStyle = lStyle & (~toRemove);

                            User32Interop.SetWindowLong(data.HWND.Hwnd, User32_WS.GWL_STYLE, lStyle);
                            data.RegLong       = lStyle;
                            data.HWND.Location = data.Position;
                        }
                    }
                    else
                    {
                        p.Process.Refresh();

                        if (p.Process.HasExited)
                        {
                            if (p.GotLauncher)
                            {
                                if (p.GotGame)
                                {
                                    exited++;
                                }
                                else
                                {
                                    List <int> children = ProcessUtil.GetChildrenProcesses(p.Process);
                                    if (children.Count > 0)
                                    {
                                        for (int j = 0; j < children.Count; j++)
                                        {
                                            int     id  = children[j];
                                            Process pro = Process.GetProcessById(id);

                                            if (!attached.Contains(pro))
                                            {
                                                attached.Add(pro);
                                                data.HWND = null;
                                                p.GotGame = true;
                                                p.Process = pro;
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                // Steam showing a launcher, need to find our game process
                                string launcher = gen.LauncherExe;
                                if (launcher.ToLower().EndsWith(".exe"))
                                {
                                    launcher = launcher.Remove(launcher.Length - 4, 4);
                                }

                                Process[] procs = Process.GetProcessesByName(launcher);
                                for (int j = 0; j < procs.Length; j++)
                                {
                                    Process pro = procs[j];
                                    if (!attached.Contains(pro))
                                    {
                                        attached.Add(pro);
                                        p.Process     = pro;
                                        p.GotLauncher = true;
                                    }
                                }
                            }
                        }
                        else
                        {
                            if (data.HWNDRetry || data.HWND == null || data.HWND.Hwnd != p.Process.MainWindowHandle)
                            {
                                data.HWND = new HwndObject(p.Process.MainWindowHandle);
                                Point pos = data.HWND.Location;

                                if (String.IsNullOrEmpty(data.HWND.Title) || pos.X == -32000 || data.HWND.Title.ToLower() == gen.LauncherTitle.ToLower())
                                {
                                    data.HWNDRetry = true;
                                }
                                else
                                {
                                    Size s = data.Size;
                                    data.Set           = true;
                                    data.HWND.TopMost  = true;
                                    data.HWND.Size     = data.Size;
                                    data.HWND.Location = data.Position;
                                }
                            }
                        }
                    }
                }

                if (exited == players.Count)
                {
                    if (!hasEnded)
                    {
                        hasEnded = true;
                        GameManager.Instance.ExecuteBackup(this.userGame.Game);

                        if (Ended != null)
                        {
                            Ended();
                        }
                    }
                }
            }
        }
Esempio n. 5
0
        public string Play()
        {
            List <PlayerInfo> players = profile.PlayerData;

            Screen[] all = Screen.AllScreens;

            string backupDir  = GameManager.Instance.GetBackupFolder(this.userGame.Game);
            string binFolder  = Path.GetDirectoryName(userGame.ExePath);
            string rootFolder = ReplaceCaseInsensitive(binFolder, gen.BinariesFolder, "");

            int gamePadId = 0;

            for (int i = 0; i < players.Count; i++)
            {
                PlayerInfo player = players[i];
                if (i > 0 && gen.KillMutex.Length > 0)
                {
                    PlayerInfo before = players[i - 1];
                    for (;;)
                    {
                        if (exited > 0)
                        {
                            return("");
                        }
                        Thread.Sleep(100);
                        if (before.screenData.KilledMutexes)
                        {
                            break;
                        }
                    }
                }

                Rectangle playerBounds = player.monitorBounds;

                // find the monitor that has this screen
                Screen owner = null;
                for (int j = 0; j < all.Length; j++)
                {
                    Screen s = all[j];
                    if (s.Bounds.Contains(playerBounds))
                    {
                        owner = s;
                        break;
                    }
                }

                int  width        = playerBounds.Width;
                int  height       = playerBounds.Height;
                bool isFullscreen = false;

                if (owner != null)
                {
                    Rectangle ob = owner.Bounds;
                    if (playerBounds.X == ob.X &&
                        playerBounds.Y == ob.Y &&
                        playerBounds.Width == ob.Width &&
                        playerBounds.Height == ob.Height)
                    {
                        isFullscreen = true;
                    }
                }

                engine.SetValue("Id", i.ToString(CultureInfo.InvariantCulture));
                engine.SetValue("Width", width.ToString(CultureInfo.InvariantCulture));
                engine.SetValue("Height", height.ToString(CultureInfo.InvariantCulture));
                engine.SetValue("IsFullscreen", isFullscreen);

                // symlink the game folder
                // find out the folder that contains the game executable
                string root = GetRootFolder(gen.BinariesFolder);

                string linkFolder = Path.Combine(backupDir, "Instance" + i);
                Directory.CreateDirectory(linkFolder);
                int exitCode;
                CmdUtil.LinkDirectories(rootFolder, linkFolder, out exitCode, root.ToLower());

                string linkBin = Path.Combine(linkFolder, gen.BinariesFolder);

                if (!string.IsNullOrEmpty(gen.BinariesFolder))
                {
                    // this needs fixing, if there are several folder to the exe and they have important files inside, this won't work! TODO
                    Directory.CreateDirectory(linkBin);
                    CmdUtil.LinkDirectories(binFolder, linkBin, out exitCode);
                }

                string exePath = Path.Combine(linkBin, this.userGame.Game.ExecutableName);

                if (gen.SymlinkExe)
                {
                    CmdUtil.LinkFiles(binFolder, linkBin, out exitCode, "xinput");
                }
                else
                {
                    CmdUtil.LinkFiles(binFolder, linkBin, out exitCode, "xinput", Path.GetFileNameWithoutExtension(gen.ExecutableName.ToLower()));
                    File.Copy(userGame.ExePath, exePath, true);
                }


                // some games have save files inside their game folder, so we need to access them inside the loop
                this.data[NucleusFolderEnum.GameFolder.ToString()] = linkFolder;

                string  saveFile = ProcessPath(gen.SavePath);
                IniFile file     = new IniFile(saveFile);

                switch (gen.SaveType)
                {
                case GenericGameSaveType.INI:
                    foreach (var modPair in gen.ModifySave)
                    {
                        string   key  = modPair.Key;
                        string[] keys = key.Split('/');

                        engine.Execute(modPair.Value);
                        string val = engine.GetCompletionValue().ToString();

                        file.IniWriteValue(keys[0], keys[1], val);
                    }
                    break;
                }

                string startArgs = gen.StartArguments;

                byte[] xdata = null;

                if (gen.SupportsKeyboard && i == (int)profile.Options["KeyboardPlayer"])
                {
                    engine.SetValue("Keyboard", true);

                    // need to make an xinput that answers to no gamepad?
                    xdata = Properties.Resources.xinput4;
                }
                else
                {
                    engine.SetValue("Keyboard", false);

                    switch (gamePadId)
                    {
                    case 0:
                        xdata = Properties.Resources.xinput1;
                        break;

                    case 1:
                        xdata = Properties.Resources.xinput2;
                        break;

                    case 2:
                        xdata = Properties.Resources.xinput3;
                        break;

                    case 3:
                        xdata = Properties.Resources.xinput4;
                        break;

                    default:
                        xdata = Properties.Resources.xinput4;
                        break;
                    }
                    gamePadId++;
                }

                using (Stream str = File.OpenWrite(Path.Combine(linkBin, "xinput1_3.dll")))
                {
                    str.Write(xdata, 0, xdata.Length);
                }

                if (!string.IsNullOrEmpty(startArgs))
                {
                    startArgs = engine.Execute(startArgs).GetCompletionValue().AsString();
                }

                if (gen.NeedsSteamEmulation)
                {
                    string steamEmu = GameManager.Instance.ExtractSteamEmu();
                    string emuExe   = Path.Combine(steamEmu, "SmartSteamLoader.exe");

                    string  emuIni = Path.Combine(steamEmu, "SmartSteamEmu.ini");
                    IniFile emu    = new IniFile(emuIni);

                    emu.IniWriteValue("Launcher", "Target", exePath);
                    emu.IniWriteValue("Launcher", "StartIn", Path.GetDirectoryName(exePath));
                    emu.IniWriteValue("Launcher", "CommandLine", startArgs);
                    emu.IniWriteValue("Launcher", "SteamClientPath", Path.Combine(steamEmu, "SmartSteamEmu.dll"));
                    emu.IniWriteValue("Launcher", "SteamClientPath64", Path.Combine(steamEmu, "SmartSteamEmu64.dll"));
                    emu.IniWriteValue("Launcher", "InjectDll", "0");
                    emu.IniWriteValue("SmartSteamEmu", "AppId", gen.SteamID);

                    Process proc;
                    if (gen.KillMutex.Length > 0)
                    {
                        // to kill the mutexes we need to orphanize the process
                        proc = ProcessUtil.RunOrphanProcess(emuExe);
                    }
                    else
                    {
                        ProcessStartInfo startInfo = new ProcessStartInfo();
                        startInfo.FileName = emuExe;
                        proc = Process.Start(startInfo);
                    }

                    player.Process  = proc;
                    player.SteamEmu = true;
                }
                else
                {
                    Process proc;
                    if (gen.KillMutex.Length > 0)
                    {
                        proc = Process.GetProcessById(StartGameUtil.StartGame(exePath, startArgs));
                    }
                    else
                    {
                        ProcessStartInfo startInfo = new ProcessStartInfo();
                        startInfo.FileName         = exePath;
                        startInfo.WindowStyle      = ProcessWindowStyle.Hidden;
                        startInfo.Arguments        = startArgs;
                        startInfo.UseShellExecute  = true;
                        startInfo.WorkingDirectory = Path.GetDirectoryName(exePath);
                        proc = Process.Start(startInfo);
                    }
                    if (proc == null)
                    {
                        for (int times = 0; times < 200; times++)
                        {
                            Thread.Sleep(50);

                            Process[] procs        = Process.GetProcesses();
                            string    proceName    = Path.GetFileNameWithoutExtension(gen.ExecutableName).ToLower();
                            string    launcherName = Path.GetFileNameWithoutExtension(gen.LauncherExe).ToLower();

                            for (int j = 0; j < procs.Length; j++)
                            {
                                Process p      = procs[j];
                                string  lowerP = p.ProcessName.ToLower();
                                if (((lowerP == proceName) || lowerP == launcherName) &&
                                    !attached.Contains(p))
                                {
                                    attached.Add(p);
                                    proc = p;
                                    break;
                                }
                            }

                            if (proc != null)
                            {
                                break;
                            }
                        }
                    }
                    else
                    {
                        attached.Add(proc);
                    }
                    player.Process = proc;
                }

                ScreenData data = new ScreenData();
                data.Position      = new Point(playerBounds.X, playerBounds.Y);
                data.Size          = new Size(playerBounds.Width, playerBounds.Height);
                data.KilledMutexes = gen.KillMutex.Length == 0;
                player.screenData  = data;
            }

            return(string.Empty);
        }
 public PlayerControl(PlayerInfo player)
 {
     this.player = player;
     InitializeComponent();
 }
        public void Initialize(UserGameInfo game, GameProfile profile)
        {
            this.profile = profile;
            profile.PlayerData.Clear();// reset profile

            playerFont = new Font("Segoe UI", 40);
            playerTextFont = new Font("Segoe UI", 18);

            RemoveFlicker();

            float playersWidth = this.Width * 0.5f;

            int playerCount = profile.PlayerCount;
            float playerWidth = (playersWidth * 0.9f) / (float)playerCount;
            float playerHeight = playerWidth * 0.5625f;
            float offset = (playersWidth * 0.1f) / (float)playerCount;
            playersArea = new RectangleF(50, 100, playersWidth, playerHeight);

            for (int i = 0; i < playerCount; i++)
            {
                Rectangle r = new Rectangle((int)(50 + ((playerWidth + offset) * i)), 100, (int)playerWidth, (int)playerHeight);
                PlayerInfo playa = new PlayerInfo();
                playa.editBounds = r;
                profile.PlayerData.Add(playa);
            }

            screens = ScreensUtil.AllScreens();
            Rectangle totalBounds = RectangleUtil.Union(ScreensUtil.AllScreensRec());

            // see if most screens are either vertical or horizontal
            int vertical = 0;
            int horizontal = 0;
            for (int i = 0; i < screens.Length; i++)
            {
                UserScreen s = screens[i];
                if (s.bounds.Width > s.bounds.Height)
                {
                    horizontal++;
                }
                else
                {
                    vertical++;
                }
            }


            if (horizontal > vertical)
            {
                // horizontal setup
                scale = (this.Width * 0.9f) / (float)totalBounds.Width;
            }
            else
            {
                // vertical setup
                scale = (this.Height * 0.6f) / (float)totalBounds.Height;
                //scale = (this.Width * 0.9f) / (float)totalBounds.Width;
            }

            totalBounds = new Rectangle(
                (int)(totalBounds.X * scale),
                (int)(totalBounds.Y * scale),
                (int)(totalBounds.Width * scale),
                (int)(totalBounds.Height * scale));
            int offsetViewsX = totalBounds.X;
            int offsetViewsY = totalBounds.Y;
            totalBounds = RectangleUtil.Center(totalBounds, new Rectangle(0, (int)(this.Height * 0.25f), this.Width, (int)(this.Height * 0.7f)));

            for (int i = 0; i < screens.Length; i++)
            {
                UserScreen screen = screens[i];

                Rectangle s = screen.bounds;
                int width = (int)(s.Width * scale);
                int height = (int)(s.Height * scale);
                int x = (int)(s.X * scale);
                int y = (int)(s.Y * scale);
                screen.bounds = new Rectangle(x + totalBounds.X - offsetViewsX, y + totalBounds.Y - offsetViewsY, width, height);
                screen.swapTypeRect = new Rectangle(screen.bounds.X, screen.bounds.Y, (int)(screen.bounds.Width * 0.1f), (int)(screen.bounds.Width * 0.1f));
            }
        }