Пример #1
0
        /// <summary>
        /// Create a copy of the <see cref="GameInformation"/> instance.
        /// </summary>
        /// <returns>A copy of the <see cref="GameInformation"/> instance.</returns>
        public object Clone()
        {
            GameInformation g = new GameInformation(this.GameType, null, ( GameParameters )this.Parameters.Clone(), null, null, this.UniqueID);

            g.HostPath = this.HostPath;
            return(g);
        }
Пример #2
0
        public SubmitGame( GameInformation game )
            : this()
        {
            Debug.Assert( game != null );
            if( game == null )
                throw new ArgumentNullException( "game" );
            _game = game;

            this.Icon = IconUtilities.ConvertToIcon( Properties.Resources.ReportIcon );
            _googleIcon = Properties.Resources.Google;

            _service = new Service();
            _service.ListGamesCompleted += new ListGamesCompletedEventHandler( ServiceListGamesCompleted );
            _service.AddGameCompleted += new AddGameCompletedEventHandler( ServiceAddGameCompleted );
            _service.AddReleaseCompleted += new AddReleaseCompletedEventHandler( ServiceAddReleaseCompleted );

            if( _gameList == null )
            {
                _service.ListGamesAsync();
                _outstandingRefresh = true;
            }
            else
            {
                this.ServiceListGamesCompleted( null, null );
            }

            this.titleLabel.Text = _game.Parameters.Title;
            this.discIdLabel.Text = _game.Parameters.DiscID;
            this.firmwareLabel.Text = _game.Parameters.SystemVersion.ToString();
            this.regionLabel.Text = _game.Parameters.Region.ToString();
            this.versionLabel.Text = _game.Parameters.GameVersion.ToString();

            Image gameImage;
            if( _game.Icon != null )
            {
                _game.Icon.Position = 0;
                gameImage = Image.FromStream( _game.Icon );
            }
            else
                gameImage = Image.FromStream( new MemoryStream( Resources.InvalidIcon, false ) );
            this.iconPictureBox.Image = gameImage;

            _release = new GameRelease();
            _release.Title = _game.Parameters.Title;
            _release.DiscID = _game.Parameters.DiscID;
            _release.Region = _game.Parameters.Region;
            _release.SystemVersion = VersionToSingle( _game.Parameters.SystemVersion );
            _release.GameVersion = VersionToSingle( _game.Parameters.GameVersion );
            if( _game.Icon != null )
            {
                _game.Icon.Position = 0;
                using( BinaryReader reader = new BinaryReader( _game.Icon ) )
                    _iconBytes = reader.ReadBytes( ( int )_game.Icon.Length );
            }
        }
Пример #3
0
        /// <summary>
        /// Find the game on the given UMD device.
        /// </summary>
        /// <param name="device">The UMD to search.</param>
        /// <returns>The game found on the device, or <c>null</c> if none was found.</returns>
        public static GameInformation FindGame(IUmdDevice device)
        {
            Debug.Assert(device != null);
            if (device == null)
            {
                return(null);
            }

            GameInformation info = GameLoader.GetUmdGameInformation(device);

            Debug.Assert(info != null);

            return(info);
        }
Пример #4
0
        public static Bitmap BuildGameImage( GameInformation game )
        {
            Bitmap gameImage;
            if( game.Icon != null )
                gameImage = ( Bitmap )Bitmap.FromStream( game.Icon );
            else
                gameImage = ( Bitmap )Bitmap.FromStream( new MemoryStream( Resources.InvalidIcon, false ) );

            //Image mediaImage;
            //switch( game.GameType )
            //{
            //    default:
            //    case GameType.Eboot:
            //        mediaImage = Resources.SmallMemoryStickIcon;
            //        break;
            //    case GameType.UmdGame:
            //        mediaImage = Resources.SmallUmdIcon;
            //        break;
            //}

            Bitmap regionImage = null;
            if( game.GameType == GameType.UmdGame )
            {
                string regionChar = game.Parameters.DiscID.Substring( 2, 1 );
                if( _regionImages.ContainsKey( regionChar ) == true )
                    regionImage = _regionImages[ regionChar ];
                else
                    regionImage = _regionImages[ "?" ];
            }

            Bitmap combined = new Bitmap( IconWidth, IconHeight );
            using( Graphics g = Graphics.FromImage( combined ) )
            {
                g.DrawImage( gameImage, 0, 0, combined.Width, combined.Height );
                //g.DrawImage( mediaImage, combined.Width - mediaImage.Width, combined.Height - mediaImage.Height );
                if( regionImage != null )
                    g.DrawImageUnscaled( regionImage, combined.Width - regionImage.Width - 2, combined.Height - regionImage.Height - 2 );
            }

            gameImage.Dispose();

            return combined;
        }
Пример #5
0
        /// <summary>
        /// Find all games on the current Memory Stick.
        /// </summary>
        /// <param name="device">The Memory Stick to search.</param>
        /// <returns>A list of games found.</returns>
        public static GameInformation[] FindGames(IMemoryStickDevice device)
        {
            List <GameInformation> infos = new List <GameInformation>();

            Debug.Assert(device != null);
            if ((device != null) &&
                (device.State == MediaState.Present))
            {
                // Eboots in PSP\GAME\*
                IMediaFolder rootFolder = device.Root.FindFolder(@"PSP\GAME\");
                foreach (IMediaFolder folder in rootFolder)
                {
                    // kxploit check
                    IMediaFolder realFolder   = folder;
                    bool         wasExploited = false;
                    if (folder.Name.StartsWith("__SCE__") == true)
                    {
                        // Find the %__SCE__... folder
                        realFolder = folder.Parent["%" + folder.Name] as IMediaFolder;
                        Debug.Assert(realFolder != null);
                        wasExploited = true;
                    }
                    else if (folder.Name[0] == '%')
                    {
                        continue;
                    }
                    GameInformation info = GameLoader.GetEbootGameInformation(realFolder);
                    if (wasExploited == true)
                    {
                        info.Folder = folder;
                    }
                    if (info != null)
                    {
                        infos.Add(info);
                    }
                }
            }

            return(infos.ToArray());
        }
Пример #6
0
        /// <summary>
        /// Generate a load report XML file and write it to the disk.
        /// </summary>
        /// <param name="instance">The current emulation instance.</param>
        /// <param name="game">The game being loaded.</param>
        /// <param name="results">The results of the load.</param>
        /// <param name="outputPath">The path to write the result data to.</param>
        public static void GenerateReport( IEmulationInstance instance, GameInformation game, LoadResults results, string outputPath )
        {
            Debug.Assert( game != null );
            if( game == null )
                return;
            Debug.Assert( results != null );
            if( results == null )
                return;

            XmlDocument doc = new XmlDocument();
            doc.AppendChild( doc.CreateXmlDeclaration( "1.0", null, "yes" ) );
            XmlElement root = doc.CreateElement( "loadResults" );
            root.SetAttribute( "successful", results.Successful.ToString() );

            XmlElement gameRoot = doc.CreateElement( "game" );
            gameRoot.SetAttribute( "type", game.GameType.ToString() );
            //gameRoot.SetAttribute( "path", EscapeFilePath( game.Folder.AbsolutePath ) );
            {
                XmlElement sfoRoot = doc.CreateElement( "parameters" );
                if( game.Parameters.Title != null )
                    sfoRoot.SetAttribute( "title", game.Parameters.Title );
                if( game.Parameters.SystemVersion != new Version() )
                    sfoRoot.SetAttribute( "systemVersion", game.Parameters.SystemVersion.ToString() );
                if( game.Parameters.GameVersion != new Version() )
                    sfoRoot.SetAttribute( "gameVersion", game.Parameters.GameVersion.ToString() );
                if( game.Parameters.DiscID != null )
                    sfoRoot.SetAttribute( "discId", game.Parameters.DiscID );
                if( game.Parameters.Region >= 0 )
                    sfoRoot.SetAttribute( "region", game.Parameters.Region.ToString( "X" ) );
                if( game.Parameters.Language != null )
                    sfoRoot.SetAttribute( "language", game.Parameters.Language );
                sfoRoot.SetAttribute( "category", game.Parameters.Category.ToString() );
                gameRoot.AppendChild( sfoRoot );
            }
            root.AppendChild( gameRoot );

            XmlElement biosRoot = doc.CreateElement( "bios" );
            {
                IComponent factory = Activator.CreateInstance( instance.Bios.Factory ) as IComponent;
                if( factory != null )
                {
                    biosRoot.SetAttribute( "name", factory.Name );
                    biosRoot.SetAttribute( "version", factory.Version.ToString() );
                    biosRoot.SetAttribute( "build", factory.Build.ToString() );
                    if( factory.Author != null )
                        biosRoot.SetAttribute( "author", factory.Author );
                    if( factory.Website != null )
                        biosRoot.SetAttribute( "website", factory.Website );
                }
            }
            root.AppendChild( biosRoot );

            XmlElement importsRoot = doc.CreateElement( "imports" );
            foreach( StubImport import in results.Imports )
            {
                XmlElement importRoot = doc.CreateElement( "import" );
                importRoot.SetAttribute( "result", import.Result.ToString() );
                importRoot.SetAttribute( "module", import.ModuleName );
                importRoot.SetAttribute( "nid", string.Format( "{0:X8}", import.NID ) );

                if( import.Function != null )
                {
                    XmlElement functionRoot = doc.CreateElement( "function" );
                    functionRoot.SetAttribute( "name", import.Function.Name );
                    functionRoot.SetAttribute( "isImplemented", import.Function.IsImplemented.ToString() );
                    //functionRoot.SetAttribute( "hasNative", ( import.Function.NativeMethod != IntPtr.Zero ) ? true.ToString() : false.ToString() );
                    importRoot.AppendChild( functionRoot );
                }

                importsRoot.AppendChild( importRoot );
            }
            root.AppendChild( importsRoot );

            doc.AppendChild( root );

            string fileName;
            if( game.GameType == GameType.Eboot )
            {
                string title = game.Parameters.Title;
                title = title.Replace( "\n", "" ); // All it takes is one moron
                fileName = string.Format( "LoadResult-Eboot-{0}.xml", title );
            }
            else
                fileName = string.Format( "LoadResult-{0}.xml", game.Parameters.DiscID );
            using( FileStream stream = File.Open( Path.Combine( outputPath, fileName ), FileMode.Create ) )
                doc.Save( stream );
        }
Пример #7
0
        private void AddGame( GameInformation game, bool batch )
        {
            _games.Add( game );

            ListViewItem item = new ListViewItem();
            item.Tag = game;

            Image gameImage;
            if( _cache != null )
                gameImage = _cache.GetImage( game );
            else
                gameImage = GameCache.BuildGameImage( game );
            gamesImageList.Images.Add( gameImage );
            item.ImageIndex = gamesImageList.Images.Count - 1;
            _imageLookup.Add( game, item.ImageIndex );

            string regionName = string.Empty;
            if( game.GameType == GameType.UmdGame )
            {
                string regionChar = game.Parameters.DiscID.Substring( 2, 1 );
                switch( regionChar )
                {
                    case "U":
                        regionName = "US";
                        break;
                    case "E":
                        regionName = "UK";
                        break;
                    case "J":
                        regionName = "JP";
                        break;
                    case "K":
                        regionName = "KR";
                        break;
                    case "A":
                        regionName = "CN";
                        break;
                    default:
                        regionName = "??";
                        break;
                }
            }

            item.SubItems.AddRange( new ListViewItem.ListViewSubItem[]{
                new ListViewItem.ListViewSubItem( item, game.Parameters.Title ),
                new ListViewItem.ListViewSubItem( item, regionName ),
            } );
            item.ToolTipText = Path.GetFileName( game.HostPath );

            _items.Add( game, item );
        }
Пример #8
0
        public void RemoveGame( GameInformation game )
        {
            ListViewItem item = _items[ game ];
            int imageIndex = _imageLookup[ game ];

            _games.Remove( game );
            _imageLookup.Remove( game );
            _items.Remove( game );

            listView.BeginUpdate();
            if( listView.Items.Contains( item ) == true )
                listView.Items.Remove( item );
            listView.EndUpdate();

            //gamesImageList.Images.RemoveAt( imageIndex );
        }
Пример #9
0
        public void AddGame( GameInformation game )
        {
            Debug.Assert( game != null );

            this.AddGame( game, true );

            this.PostChange();
        }
Пример #10
0
        public void SetupGame( GameInformation game, Stream bootStream )
        {
            // Attempt to load symbols from game information
            bool debugInfoLoaded = false;
            if( bootStream != null )
                debugInfoLoaded = this.LoadDebugData( DebugDataType.Symbols, bootStream );

            // If nothing loaded, give the user a choice
            bool skipLoadInfo = debugInfoLoaded;
            DebugSetup setup = null;
            if( debugInfoLoaded == false )
            {
                setup = new DebugSetup();
                if( setup.ShowDialog() == System.Windows.Forms.DialogResult.Cancel )
                    skipLoadInfo = true;
            }

            if( skipLoadInfo == false )
            {
                bool result = false;
                if( setup.UseElfDebug == true )
                {
                    IMediaFolder folder = game.Folder;
                    IMediaFile file = folder.FindFile( "BOOT.BIN" );
                    using( Stream stream = file.OpenRead() )
                        result = this.LoadDebugData( DebugDataType.Elf, stream );
                }
                else
                {
                    Debug.Assert( false );
                }
                Debug.Assert( result == true );
                if( result == false )
                    throw new InvalidOperationException( "Could not load debugging data - cannot continue." );
            }
        }
Пример #11
0
        public void OnStarted( GameInformation game, Stream bootStream )
        {
            // Need to marshal all UI calls to the proper thread
            DummyDelegate del = delegate
            {
                this.Log.OnStarted();
                this.Statistics.OnStarted();

                this.View.SetStatusText( Verbosity.Normal, "Connection to emulator {0} established.", this.Host.HostString );

                this.State = DebuggerState.Running;
                this.OnStateChanged();
            };
            this.View.Invoke( del );

            // TEST
            Breakpoint bp = new Breakpoint( this.AllocateID(), BreakpointType.CodeExecute, 0x08900334 );
            //this.Breakpoints.Add( bp );
        }
Пример #12
0
        public void LaunchGame( GameInformation game )
        {
            game.IgnoreDispose = true;
            if( game.HostPath != null )
            {
                // Need to have the UMD instance reload to the game
                string gamePath = game.HostPath;
                Debug.Assert( gamePath != null );

                _emulator.Umd.Eject();
                if( _emulator.Umd.Load( gamePath, false ) == false )
                {
                    // Failed to load
                }

                // Regrab game info
                game = GameLoader.FindGame( _emulator.Umd );

                Properties.Settings.Default.LastPlayedGame = gamePath;
                Properties.Settings.Default.Save();
            }

            _emulator.SwitchToGame( game );
            this.DialogResult = DialogResult.OK;
            this.Close();
        }
Пример #13
0
        /// <summary>
        /// Find and retrieve the boot stream for the given game.
        /// </summary>
        /// <param name="game">Game to look for.</param>
        /// <param name="filePath">The path of the boot file.</param>
        /// <returns>The games boot stream (from BOOT.BIN, etc) or <c>null</c> if it could not be found.</returns>
        public static Stream FindBootStream( GameInformation game, out string filePath )
        {
            filePath = null;
            Debug.Assert( game != null );
            if( game == null )
                return null;

            Stream bootStream = null;

            string kernelLocation = Path.GetDirectoryName( System.Reflection.Assembly.GetExecutingAssembly().Location );
            string prxLocation = Path.Combine( kernelLocation, "BOOT" );
            // DiscID might be more appropriate than Title
            string lookasideBoot = Path.Combine( Path.Combine( prxLocation, game.Parameters.Title ), "BOOT.BIN" );
            if( File.Exists( lookasideBoot ) == true )
            {
                // Load ours instead
                Log.WriteLine( Verbosity.Normal, Feature.Bios, "Lookaside boot found at {0}", lookasideBoot );
                bootStream = File.OpenRead( lookasideBoot );
                filePath = lookasideBoot;
            }
            else
            {
                IMediaFolder folder = game.Folder;
                if( folder[ "PSP_GAME" ] != null )
                    folder = folder[ "PSP_GAME" ] as IMediaFolder;
                if( folder[ "SYSDIR" ] != null )
                    folder = folder[ "SYSDIR" ] as IMediaFolder;
                IMediaFile bootBin = null;
                bootBin = folder[ "BOOT.BIN" ] as IMediaFile;
                if( bootBin == null )
                    bootBin = folder[ "EBOOT.BIN" ] as IMediaFile;
                if( bootBin == null )
                    bootBin = folder[ "BOOT.ELF" ] as IMediaFile;
                if( bootBin == null )
                    bootBin = folder[ "EBOOT.ELF" ] as IMediaFile;

                if( bootBin == null )
                {
                    // Probably in PBP - unless exploited!
                    if( folder.Name.Contains( "__SCE__" ) == true )
                    {
                        // If this is exploited, the eboot.pbp IS the elf!
                        IMediaFile pbp = folder[ "EBOOT.PBP" ] as IMediaFile;
                        filePath = pbp.AbsolutePath;
                        bootStream = pbp.OpenRead();
                    }
                    else
                    {
                        IMediaFile pbp = folder[ "EBOOT.PBP" ] as IMediaFile;
                        using( Stream stream = pbp.OpenRead() )
                        {
                            PbpReader reader = new PbpReader( stream );
                            if( reader.ContainsEntry( PbpReader.PbpEntryType.DataPsp ) == true )
                            {
                                filePath = pbp.AbsolutePath;
                                bootStream = reader.Read( stream, PbpReader.PbpEntryType.DataPsp );
                            }
                        }
                    }
                }
                else
                {
                    filePath = bootBin.AbsolutePath;
                    bootStream = bootBin.OpenRead();
                }
            }

            return bootStream;
        }
Пример #14
0
        /// <summary>
        /// Generate a load report XML file and write it to the disk.
        /// </summary>
        /// <param name="instance">The current emulation instance.</param>
        /// <param name="game">The game being loaded.</param>
        /// <param name="results">The results of the load.</param>
        /// <param name="outputPath">The path to write the result data to.</param>
        public static void GenerateReport(IEmulationInstance instance, GameInformation game, LoadResults results, string outputPath)
        {
            Debug.Assert(game != null);
            if (game == null)
            {
                return;
            }
            Debug.Assert(results != null);
            if (results == null)
            {
                return;
            }

            XmlDocument doc = new XmlDocument();

            doc.AppendChild(doc.CreateXmlDeclaration("1.0", null, "yes"));
            XmlElement root = doc.CreateElement("loadResults");

            root.SetAttribute("successful", results.Successful.ToString());

            XmlElement gameRoot = doc.CreateElement("game");

            gameRoot.SetAttribute("type", game.GameType.ToString());
            //gameRoot.SetAttribute( "path", EscapeFilePath( game.Folder.AbsolutePath ) );
            {
                XmlElement sfoRoot = doc.CreateElement("parameters");
                if (game.Parameters.Title != null)
                {
                    sfoRoot.SetAttribute("title", game.Parameters.Title);
                }
                if (game.Parameters.SystemVersion != new Version())
                {
                    sfoRoot.SetAttribute("systemVersion", game.Parameters.SystemVersion.ToString());
                }
                if (game.Parameters.GameVersion != new Version())
                {
                    sfoRoot.SetAttribute("gameVersion", game.Parameters.GameVersion.ToString());
                }
                if (game.Parameters.DiscID != null)
                {
                    sfoRoot.SetAttribute("discId", game.Parameters.DiscID);
                }
                if (game.Parameters.Region >= 0)
                {
                    sfoRoot.SetAttribute("region", game.Parameters.Region.ToString("X"));
                }
                if (game.Parameters.Language != null)
                {
                    sfoRoot.SetAttribute("language", game.Parameters.Language);
                }
                sfoRoot.SetAttribute("category", game.Parameters.Category.ToString());
                gameRoot.AppendChild(sfoRoot);
            }
            root.AppendChild(gameRoot);

            XmlElement biosRoot = doc.CreateElement("bios");

            {
                IComponent factory = Activator.CreateInstance(instance.Bios.Factory) as IComponent;
                if (factory != null)
                {
                    biosRoot.SetAttribute("name", factory.Name);
                    biosRoot.SetAttribute("version", factory.Version.ToString());
                    biosRoot.SetAttribute("build", factory.Build.ToString());
                    if (factory.Author != null)
                    {
                        biosRoot.SetAttribute("author", factory.Author);
                    }
                    if (factory.Website != null)
                    {
                        biosRoot.SetAttribute("website", factory.Website);
                    }
                }
            }
            root.AppendChild(biosRoot);

            XmlElement importsRoot = doc.CreateElement("imports");

            foreach (StubImport import in results.Imports)
            {
                XmlElement importRoot = doc.CreateElement("import");
                importRoot.SetAttribute("result", import.Result.ToString());
                importRoot.SetAttribute("module", import.ModuleName);
                importRoot.SetAttribute("nid", string.Format("{0:X8}", import.NID));

                if (import.Function != null)
                {
                    XmlElement functionRoot = doc.CreateElement("function");
                    functionRoot.SetAttribute("name", import.Function.Name);
                    functionRoot.SetAttribute("isImplemented", import.Function.IsImplemented.ToString());
                    //functionRoot.SetAttribute( "hasNative", ( import.Function.NativeMethod != IntPtr.Zero ) ? true.ToString() : false.ToString() );
                    importRoot.AppendChild(functionRoot);
                }

                importsRoot.AppendChild(importRoot);
            }
            root.AppendChild(importsRoot);

            doc.AppendChild(root);

            string fileName;

            if (game.GameType == GameType.Eboot)
            {
                string title = game.Parameters.Title;
                title    = title.Replace("\n", "");                // All it takes is one moron
                fileName = string.Format("LoadResult-Eboot-{0}.xml", title);
            }
            else
            {
                fileName = string.Format("LoadResult-{0}.xml", game.Parameters.DiscID);
            }
            using (FileStream stream = File.Open(Path.Combine(outputPath, fileName), FileMode.Create))
                doc.Save(stream);
        }
Пример #15
0
 private string GetIconPath( GameInformation game )
 {
     string iconsPath = Path.Combine( _cachePath, "Icons" );
     try
     {
         if( Directory.Exists( iconsPath ) == false )
             Directory.CreateDirectory( iconsPath );
     }
     catch
     {
     }
     return Path.Combine( iconsPath, game.Parameters.DiscID ) + ".png";
 }
Пример #16
0
 public void Remove( GameInformation game )
 {
     Debug.Assert( game.HostPath != null );
     this.Remove( game.HostPath );
 }
Пример #17
0
 public Bitmap GetImage( GameInformation game )
 {
     if( game.GameType == GameType.Eboot )
         return BuildGameImage( game );
     else
     {
         string iconPath = GetIconPath( game );
         if( File.Exists( iconPath ) == true )
             return ( Bitmap )Bitmap.FromFile( iconPath );
         else
         {
             Bitmap b = BuildGameImage( game );
             b.Save( iconPath, ImageFormat.Png );
             return b;
         }
     }
 }
Пример #18
0
        public void Add( GameInformation game )
        {
            Debug.Assert( game.GameType != GameType.Eboot );
            GameInformation copy = ( GameInformation )game.Clone();
            _list.Add( copy );
            _lookup.Add( copy.HostPath, copy );

            // We build the image off the real game, which should have the icon stream
            using( Bitmap b = this.GetImage( game ) )
            {
            }
        }
Пример #19
0
        /// <summary>
        /// Find and retrieve the boot stream for the given game.
        /// </summary>
        /// <param name="game">Game to look for.</param>
        /// <param name="filePath">The path of the boot file.</param>
        /// <returns>The games boot stream (from BOOT.BIN, etc) or <c>null</c> if it could not be found.</returns>
        public static Stream FindBootStream(GameInformation game, out string filePath)
        {
            filePath = null;
            Debug.Assert(game != null);
            if (game == null)
            {
                return(null);
            }

            Stream bootStream = null;

            string kernelLocation = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            string prxLocation    = Path.Combine(kernelLocation, "BOOT");
            // DiscID might be more appropriate than Title
            string lookasideBoot = Path.Combine(Path.Combine(prxLocation, game.Parameters.Title), "BOOT.BIN");

            if (File.Exists(lookasideBoot) == true)
            {
                // Load ours instead
                Log.WriteLine(Verbosity.Normal, Feature.Bios, "Lookaside boot found at {0}", lookasideBoot);
                bootStream = File.OpenRead(lookasideBoot);
                filePath   = lookasideBoot;
            }
            else
            {
                IMediaFolder folder = game.Folder;
                if (folder["PSP_GAME"] != null)
                {
                    folder = folder["PSP_GAME"] as IMediaFolder;
                }
                if (folder["SYSDIR"] != null)
                {
                    folder = folder["SYSDIR"] as IMediaFolder;
                }
                IMediaFile bootBin = null;
                bootBin = folder["BOOT.BIN"] as IMediaFile;
                if (bootBin == null)
                {
                    bootBin = folder["EBOOT.BIN"] as IMediaFile;
                }
                if (bootBin == null)
                {
                    bootBin = folder["BOOT.ELF"] as IMediaFile;
                }
                if (bootBin == null)
                {
                    bootBin = folder["EBOOT.ELF"] as IMediaFile;
                }

                if (bootBin == null)
                {
                    // Probably in PBP - unless exploited!
                    if (folder.Name.Contains("__SCE__") == true)
                    {
                        // If this is exploited, the eboot.pbp IS the elf!
                        IMediaFile pbp = folder["EBOOT.PBP"] as IMediaFile;
                        filePath   = pbp.AbsolutePath;
                        bootStream = pbp.OpenRead();
                    }
                    else
                    {
                        IMediaFile pbp = folder["EBOOT.PBP"] as IMediaFile;
                        using (Stream stream = pbp.OpenRead())
                        {
                            PbpReader reader = new PbpReader(stream);
                            if (reader.ContainsEntry(PbpReader.PbpEntryType.DataPsp) == true)
                            {
                                filePath   = pbp.AbsolutePath;
                                bootStream = reader.Read(stream, PbpReader.PbpEntryType.DataPsp);
                            }
                        }
                    }
                }
                else
                {
                    filePath   = bootBin.AbsolutePath;
                    bootStream = bootBin.OpenRead();
                }
            }

            return(bootStream);
        }
Пример #20
0
 /// <summary>
 /// Create a copy of the <see cref="GameInformation"/> instance.
 /// </summary>
 /// <returns>A copy of the <see cref="GameInformation"/> instance.</returns>
 public object Clone()
 {
     GameInformation g = new GameInformation( this.GameType, null, ( GameParameters )this.Parameters.Clone(), null, null, this.UniqueID );
     g.HostPath = this.HostPath;
     return g;
 }
Пример #21
0
        public void OnStarted( GameInformation game, Stream bootStream )
        {
            // Need to marshal all UI calls to the proper thread
            DummyDelegate del = delegate
            {
                this.State = DebuggerState.Running;
                this.OnStateChanged();

                foreach( DebuggerTool tool in this.Tools )
                    tool.OnStarted();
            };
            this.Window.Invoke( del );
        }