With me going it alone in development I only have limited resources at my disposal i.e one pc with which I develop and test the game. so I only know for certain my game works with that setup.
What options have I got in testing the game on the many different hardware/operating system combinations? Its a windows desktop game.
Off the top of my head I'd suggest trying to run the game on a few other PCs from friends or relatives. After that you might want to consider some form of beta test, i.e. publishing a demo or something so you can get community feedback.
One of my favorite ways to find this info is by using virtual machines.
Seeing as how you can configure the hardware and memory that the VM is allowed you can test a wide range of setups on your own PC. This also allows you to test across multiple operating systems.
You should have some rough idea of the minspec just by developing your game -- for example if you made an explicit choice to use D3D10+, you obviously are culling out XP machines. So that's a place to start.
Find a way to test on as many machines as possible, ideally after implementing some way to gather performance metrics automatically (as users can be unreliable) as well as non-identifiable information about the machine the game is running on (processor(s), core count, GPU type, RAM, OS, et cetera -- take a look at the kind of data the Steam Hardware & Software Survey collects). One of the best ways to do this is to give your game to friends and family, as has been suggested many times already. Another way might be to approach a community of hobby game developers and see if they are interested in testing your game. I'm not sure such a thing would be an appropriate question here on GDSE, but you could probably find a few people in the 'chat' area and you could also look around/post on websites like:
All of those websites have forums or sub-forums dedicated in some way to showing off games, and so you might be able to get a reasonably good response out of them. I would make sure to disclose up front whatever statistics your game collects and/or sends you though, and why you are collecting them. People can get annoyed by that if they discover it after the fact.
N.B. that the Steam survey is also a useful tool in itself for gauges what a minspec should be -- it can help you see what the cost/benefit ratio of supporting a particular feature or class of hardware might be for you.
Check:
- How much RAM it uses
- How much texture + GPGPU memory it uses
- Minimum frame rate / Current frame rate * CPU speed * SpeedUpFactorOf(minimal number of cores you can use)
- Similar equation for GPU calculation units
- what level of opengl/directx/cuda your game engine requires from the graphics adaptor
- how much disk space the installation + user info takes...
Also test on various hardware configurations.
Basically you want to test on as many other machines as you can - from your friend's hard-core gaming rig to your gran's email-and-internet-only machine. Especially your gran's email-and-internet-only machine, because it's probably loaded with cruftware and other stuff that will interfere and slow your game to a crawl.
PC compatibility testing is a big nasty can of worms, and there's a reason why professional testing is expensive. So you want as many different odd scenarios tested as you can.
Beta testing is the way to go I think, both with friends and family and a wider circle in your fan community. Key thing - don't rely on anecdotal reports. Your friends might be relied on to actually reply, but the wider community will not, unless you make it easy for them.
Build logging into your app to give you hard facts on FPS, startup time, etc. Give the user an easy questionnaire, ideally built into the game, where they can report whether or not they though it played okay. And have those statistics and logging easily emailable / transmittable back to you, for you to pore over later. The more stats you get back, the better a sense you can have of whether your title is a) working at all on other systems, and b) working well on other systems.
Test on as many PCs as you can (that will also help you to catch all specific bugs). As developer you should know your main bottlenecks - focus on stressing them. You may ask your friends, colleagues at work, girlfriend, parents, lots of people in forums.
P.S. Just for reference:
For requirements, I would assume minimum things required to run you game. It will depend on what technologies you use to develop your games.
For example, if you use specific APIs, such as D3D9 or OpenGL 3.0, you will need to specific that, because certain APIs are not downward compatible.
If you build with windows with .net framework, you will also need to specific that as well.
For performance requirements, trying on different machines are pretty much the best way to go, though you may be able to measure the related performance by calculation.
for example, if your current video card runs at 60 fps, and another computer with the similar configuration, except the video card is half speed of yours, should run about the half speed of your machine. Again, this is just an estimate, many others properties will hit the performance differently, but you can use that base info to test your game on targeted devices.
Hope that helps, and anyone is welcome to correct me for any reasons.
Depending on your target market (I assume it isn't cutting edge 3d ie. expensive graphics cards needed), I'd look at picking up a selection of older graphics cards from somewhere like EBay so that you can test on both NVidia and ATi cards.
It is always perfect get comunity feedback as mentioned. But where to get community and people who will try to test it? Posting it on some indie games forums will help, but problem will be to get actual feedback.
Only few percent of people who will test a game it will write you their exact configuration and problems that ocured. People just dont do that. Much better way is enable some kind of benchmark with reading users system configuration. Ask user to run some one button benchmark. Offer some numbers and times(yeah people like it :-)) and let him compare with other users (with sending data) ... It will help.
And then you have database full of configurations, screen resolutionn, render times and failed features...
If you are on windows calling DXdiag will help you read the users configuration. But there are some programs you can use on other systems.
As mentioned by others, the best way is to get the a beta out there and gather community feedback to get reliable results.
I'd also like to suggest the use of ESXi. It's a Virtual Machine solution from VMWare. Don't be put off because it's a VM solution. ESX is a lot more low level.
This would probably be ideal to you since you have one machine. You can test different operating systems, hardware setups (bar the graphics hardware, ESXi would use whatever you have installed on your machine).
It's basically its own very slimmed down operating system that you can install other operating systems on top of. We use it at work for compatibility among a great deal of OS's. It's very fast and reliable, almost as responsive as a vanilla machine.
I know hardware requirements is what you're looking for and ESXi has a very nice feature where you can limit the amount of RAM, CPU or disk space usage by the operating system and could potentially emulate how your game would run on anything from a low end CPU or low memory, to top-end CPU or memory use (limited by your actual hardware).
So if you had quite a high spec PC you could install ESXi on it, install whatever operating systems you wanted to and play around with the CPU and Memory usage (I believe you can even modify the number of cores the OS uses as well!)
Here's a link to it: http://www.vmware.com/products/vsphere-hypervisor/index.html
Best thing about it? It's 100% free!
Running some kind of profiling tool would be one way. For Java programs you could use VisualVM (https://visualvm.github.io/). Wikipedia lists some other ones. See: https://en.wikipedia.org/wiki/List_of_performance_analysis_tools. The same goes for debugging memory. See: https://en.wikipedia.org/wiki/Memory_debugger
Basically this amounts to checking your memory and CPU usage at some regular interval while running the program/playing the game. Then you calculate some average range and that's what it needs most of the time. Ideally this would be automated (for consistency and accuracy) and you'd want to exclude the amounts of those resources consumed, shared, or used by other processes. There might be some priority issues hiding the fact that your program might use more memory if it was available. I.e. if the OS was super busy your program might founder a bit from having not quite enough memory.
Ultimately you have to test/benchmark/profile and then analyse those tests. It's good to have a pre-defined performance metric to compare to. E.g. in an FPS you might want 30+ FPS for playable/enjoyable gaming. Based on that you would set the minimum bar at/above the hardware specs needed to meet that 30+ FPS some percentage of the time (it's always possible for the user to run too much at once and cause crashes and hangs).
As others have said, you really need other people to test it on a range of different hardware. In an ideal world you'd have a bunch of groups with similar hardware within a group and conduct some kind of control vs. experiment testing to see if more/less memory, cpu, gpu mattered when the other factors were held constant.
