Who can program?

Am I allowed to ask for requests?  I have a file-saving routine for sprite files in a game all written down and needs to be automated.  Basically something that can generate the format using custom sprites.

Could you describe what you want in a bit more detail?

I need a program with a specific interface that can generate the format.

The interface needs to have the following:

-A list box with selections that group "animations"
-A frame box that shows all the frames.  Clicking on them should bring up the detail.
-Boxes to fill in telling which sprite and palette will be used.  Also radio buttons for choosing the type of animation.  It also needs a box to specify milliseconds.
-A window to show all the uploaded sprites and their palettes.

The following buttons are also needed:
-Add animation
-Add frame
-Add sprites

Right now, only 64x64 sprites are supported but that's good enough for a start.  The file is constructed in this order:

[animation pointers]
[animation data]
[sprite data]
[palette data]
[OAM data]

Any more detail?

What platform is the game for?

On a random topic, you might get results more in line with what you want by getting your hands on Microsoft Visual Basic Express and learning the language yourself. (I recommend Visual Basic simply because it's easier to get into. ^_^ Don't worry, the software's free, straight from the source.)

It's for GBA.  I don't know any coding language myself and I was expecting someone else to work on it, but they quit on me.  At this moment, I need someone skilled.

...Oooor you can take the time to attempt to learn a programming language.  I'd suggest one of the .NET languages for easy GUI building.  If you continue in software or trying to design software, you're going to need to learn how to program or at least script.  And on the brighter side, having software development experience can make you stand out as it's very valuable in multidiscipline engineering fields if you don't plan on doing CS.

Any more detail?

Lots.

I have a file-saving routine for sprite files in a game all written down and needs to be automated.  Basically something that can generate the format using custom sprites.

What input formats? I'm guessing BMP would be ok, but what about the palettes? If you have only something primitive like Paint then the program also needs a palette editing function.

radio buttons for choosing the type of animation

What types?

The file is constructed in this order:

[animation pointers]
[animation data]
[sprite data]
[palette data]
[OAM data]

Is this "interface program" supposed to generate data that is ready to be inserted into a ROM, or do you have an additional program for that?

Also, each of these items have to be defined down to the bit level.

Here are the instructions I typed up a while back.

Spoiler: (View)
1. Determine "head block" size by:
   # of animations x 4  = animation pointer size
   # of frames for animation x 5 x 4  = anim data size

2. Compile and convert uploaded images and palettes

3. Add OAM data after the last palette.

4. Fill in values for animation pointers by:
   making the pointer block size the first pointer
   then use the # of frames in an animation x5 x4 and add to the previous pointer to get the next pointer
   repeat adding to the previous answer for all animations

5. Fill in values for frame for anim data by:
   finding the start of the data using the size of the pointers
         start filling in after anim pointers
   using user-input to fill in data:
      graphics, palette, OAM1/2, animation type
   to get graphics pointer, use:
      headblock + 804h bytes for every sprite away from #1.
   to get palette pointer, use:
      headblock + spriteblock -4 (+20h for every palette not #1)
   OAM is always in the sample place
      oam 1= filesize - 1Ch
      oam 2= filesize - 13h
   animation type comes in 4 sets and is in the user's input
   repeat process for very frame

6. Make .BIN/.DMP file.

1. Determine "head block" size by:
   # of animations x 4  = animation pointer size
   # of frames for animation x 5 x 4  = anim data size

2. Compile and convert uploaded images and palettes

3. Add OAM data after the last palette.

4. Fill in values for animation pointers by:
   making the pointer block size the first pointer
   then use the # of frames in an animation x5 x4 and add to the previous pointer to get the next pointer
   repeat adding to the previous answer for all animations

5. Fill in values for frame for anim data by:
   finding the start of the data using the size of the pointers
         start filling in after anim pointers
   using user-input to fill in data:
      graphics, palette, OAM1/2, animation type
   to get graphics pointer, use:
      headblock + 804h bytes for every sprite away from #1.
   to get palette pointer, use:
      headblock + spriteblock -4 (+20h for every palette not #1)
   OAM is always in the sample place
      oam 1= filesize - 1Ch
      oam 2= filesize - 13h
   animation type comes in 4 sets and is in the user's input
   repeat process for very frame

6. Make .BIN/.DMP file.

You're missing the point entirely. You need to specify binary formats for all data you want processed. "2. Compile and convert uploaded images and palettes" ORLY?? Never would have guessed. Now, how should these be compiled and converted??
Should they be converted from a native NDS 4bpp format to a native NDS LZ77 headered data stream? Or are these pictures in 2bpp data in reversed bit order that need to be compressed with a proprietary compression algorithm of a particular game?
Use regular NDS pointers, or special offset pointers? What size in bytes do they have? 4? 16? 2?
What are correct values for animation type? What do these values mean? Are they bit combinations of certain atomic attributes?

Gosh, you basically say "Yeah, I need to have a program that can do something with pictures and it is supposed to work, now!"

cYa,

Tauwasser

I sort of missed all the detail, I know.  The steps had more info implied.

Basically, it uses a lot of 4-byte pointers.  The first part points to where animation data starts, which comes after it.   The animation data consists of 5 sets of 4-byte datas editing the frames.  The first part of it is a pointer to the start of the graphics data for the first sprite specified.  The second is a pointer to the palette that will be used in that frame.  The third and fourth pointer point to OAM data that can be the same data.  They're always this:

Code: [Select]

OAM 1
04 00 00 00 00 01 80 FF FF

OAM2
FF 00 00 04 00 00 00 00 E0 D4 03 00 FF FF 5F
FF FF 00 00
Then the animation type is written.  They are 4 bytes.  XXs values set the milliseconds for the animation type.

The first type is standard delay.
XX000000

end animation
XX008000

loop animation
XX00C000

idle animation
01008000

These inputs repeat for all the frames. 

After that part of the file, the sprites are converted to 4bpp with a 16-color palette to choose from after the sprite block. Sprites have a 4-byte size specification before the 64x64 area.  The size is 800 in hex.   After the palette block, the oam data is placed.