I'm started with Unity development and my artist asked me what size she should make the sprites for the game.
They are all pixel art and she didn't know if she should make them on Photoshop on a small resolution, do them already on the iOS resolution 1920x1080 or even if she should use a vector program and then rasterize them.
How is this normally done?
Pixel art generally responds extremely bad to any scaling. Just a small size adjustment will make pixel art appear either blurry or distorted, depending on what scaling algorithm your engine uses. For that reason it is important to make sure that the graphics are designed in exactly the resolution in which they appear in the finished game.
Here is a pixel-art sprite from one of my projects, interpolated with linear interpolation and nearest neighbor interpolation. As you can see only the original size looks well:
When stepless scalability of graphics is important for your game concept, you should consider to use vector-based graphics instead of pixel-art. Just keep in mind that the hardware requirements can become a lot higher when the vector graphics are not specifically designed to be fast to render. When your artist comes from a general visual design background with not much game development experience they might not know what they need to do and avoid to ensure this (it also depends on the platform and technology you use. Different vector graphic rasterizers have different strengths and weaknesses).
Another option when you want scaling is to go for a retro-look, design very low resolution sprites and upscale them with nearest neighbor. Nearest neighbor preserves the "blockyness" which is usually undesirable, but preserves the aesthetics of 90s style pixel art on high-DPI screens. This usually only works when you upscale by a large amount. When you downscale, most other algorithms are preferable to nearest neighbor, even on pixel art. Here is a very small sprite from the first Final Fantasy game upscaled a lot with nearest neighbor interpolation:
As you can see the retro aesthetics are preserved, and the image quality doesn't suffer even with a very uneven zoom factor. But this only works because the original sprite is so tiny and the zoom level is so high. Also, this look is not appropriate for every game.
Make them the size they would normally be. Don't try to make them big and scale them down later. That way there will be less time loading the images (Not that it's all that long.) Less data stored as well. Make sure that when you are scaling them up to draw them to the screen, you don't use a any sort of filter. Anotherwords... Use no mipmapping. Ie point sampling. (It looks bad in 3d but not with 2d pixel art.)
Graphics API's usually have a flag to set mipmapping. For Unity: http://answers.unity3d.com/questions/22491/how-do-i-turn-off-mip-mapping.html
Vector images are useful since they would work with any resolution, and you can even use them directly in the game, letting OpenGL/DirectX rasterize it only when they are rendered to the frame buffer.
But since you specifically mentioned pixel art it doesn't sound like you would get the right look with vector graphics, in that case you want to be careful about resizing them (as the other answers have mentioned).
In pixel art a lot of the style comes from each pixel having importance, so shrinking the image would rarely give good results. Increasing their size also has pitfalls, although there are some algorithms that have been made specifically for pixel art (they are often used with emulators of older systems).
If the art looks good as vector graphics then that is a good choice, specifically because it lets you postpone the decision about precise size of things until a later date, thus making it easy to resize things if you realize that a certain character should be taller or shorter. If not then your artist will have to make the sprites in the proper size to begin with for the best results.
If you can only afford to have one set of sprites drawn (i.e. your artist time/effort is limited) then get them to do the largest resolution. It's far easier to make hi-res sprites look okay when scaled down than it is to make low-res sprites look okay when scaling up.
Neither approach is better than having sets of sprites tailored for your target resolution, but that can be expensive to have developed. If you have a wide range of target resolutions you may still want to have two or more sets of sprites made up, so that if you do have to do scaling that you don't have to go too far. 50% is probably a reasonable limit, any more than that and they'll look very muddy once scaled. But if you have small and large versions then you can scale whichever one is nearest to the target resolution.
In all cases, do your scaling offline using the best filters you can, even if those filters are too expensive to do at runtime. Storage for your assets is generally cheap, and you don't want to be burning performance on scaling and filtering at runtime. You'd have to have a very, very large sprite-set to be worrying about the storage footprint of your app more than how it performs. You want to keep your sprite sets separate as well, so that you're only ever loading the data the game needs, not loading a larger version and scaling down, or loading multiple sets and then picking one of them.
Depends on what look you're going for. Usually you'd design for your target platform and then scale/rework art assets for secondary platforms. Make it look nice for the largest chunk of your players, essentially.
