{

// The path always ends in a three-letter extension, ".png" or ".jpg".

// In addition, 3 more characters may be taken up by an @2x label.

size_t end = path.length() - (ImageSet::Is2x(path) ? 7 : 4);

// This should never happen, but just in case:

if(!end)

return 0;

// Skip any numbers at the end of the name.

size_t pos = end;

while(--pos)

if(path[pos] < '0' || path[pos] > '9')

break;

// If there is not a blending mode specifier before the numbers, they

// are part of the sprite name, not a frame index.

return (IsBlend(path[pos]) ? pos : end);

{

if(path.length() < 4)

return false;

string ext = path.substr(path.length() - 4);

return (ext == ".png" || ext == ".jpg" || ext == ".PNG" || ext == ".JPG");

{

// Get the character index where the "name" portion of the path ends.

// A path's format is always: <name>(<blend><frame>)(@2x).(png|jpg)

size_t i = NameEnd(path);

// If the name contains a frame index, it must be separated from the name

// by a character indicating the additive blending mode.

if(!IsBlend(path[i]))

return 0;

int frame = 0;

// The path ends in an extension, so there's no need to check for going off

// the end of the string in this loop; we're guaranteed to hit a non-digit.

for(++i; path[i] >= '0' && path[i] <= '9'; ++i)

frame = (frame * 10) + (path[i] - '0');

return frame;

{

if(path.length() < 7)

return false;

size_t pos = path.length() - 7;

return (path[pos] == '@' && path[pos + 1] == '2' && path[pos + 2] == 'x');

{

if(path.length() >= 5 && !path.compare(0, 5, "land/"))

return true;

return false;

{

if(path.length() >= 5 && !path.compare(0, 5, "ship/"))

return true;

if(path.length() >= 9 && !path.compare(0, 9, "asteroid/"))

return true;

return false;

{

// Determine which frame of the sprite this image will be.

bool is2x = Is2x(path);

size_t frame = FrameIndex(path);

// Allocate the string to store the path in, if necessary.

if(paths[is2x].size() <= frame)

paths[is2x].resize(frame + 1);

// Store the path to this frame of the sprite.

paths[is2x][frame] = path;

{

string prefix = "Sprite \"" + name + "\": ";

if(paths[1].size() > paths[0].size())

Files::LogError(prefix + to_string(paths[1].size() - paths[0].size())

+ " extra frames for the @2x sprite will be ignored.");

for(size_t i = 0; i < paths[0].size(); ++i)

{

if(paths[0][i].empty())

Files::LogError(prefix + "missing frame " + to_string(i) + ".");

if(!paths[1].empty() && (i >= paths[1].size() || paths[1][i].empty()))

Files::LogError(prefix + "missing @2x frame " + to_string(i) + ".");

}

{

// Determine how many frames there will be, total. The image buffers will

// not actually be allocated until the first image is loaded (at which point

// the sprite's dimensions will be known).

size_t frames = paths[0].size();

buffer[0].Clear(frames);

buffer[1].Clear(frames);

// Check whether we need to generate collision masks.

bool makeMasks = IsMasked(name);

if(makeMasks)

masks.resize(frames);

// Load the 1x sprites first, then the 2x sprites, because they are likely

// to be in separate locations on the disk. Create masks if needed.

for(size_t i = 0; i < frames; ++i)

if(buffer[0].Read(paths[0][i], i) && makeMasks)

masks[i].Create(buffer[0], i);

// Now, load the 2x sprites, if they exist. Because the number of 1x frames

// is definitive, don't load any frames beyond the size of the 1x list.

for(size_t i = 0; i < frames && i < paths[1].size(); ++i)

buffer[1].Read(paths[1][i], i);

{

// Load the frames. This will clear the buffers and the mask vector.

sprite->AddFrames(buffer[0], false);

sprite->AddFrames(buffer[1], true);

sprite->AddMasks(masks);