SoloCodigo

1- Cuando trabajamos con tiles animados. Qué es mas rápido y eficaz?
Mantener en memoria un solo bitmap con todos los frames dentro para
recortar cada uno de ellos durante cada ciclo del bucle que pinta el
fondo?
O separar cada uno de los frames en un bitmap por separado y hacer
lo mismo?

Lo más eficiente para ahorrar memoria es tener todo ( en la medida de lo posible) en un solo BMP, desde que este no supere dos megas, una recomendacion es que si tus tiles son muchos los hagas en bmps agrupados..
ejemplo un bmp con cosas de agua otro con cosas de fuego otras de metal etc.

2 - Cuando se necesita pintar varios tiles animados, por ejemplo para
el agua. Se utiliza una sola variable general para verificar qué frame
específico van a compartir todos esos tiles? Esta variable general también
es utilizada como referencia para saber en que frame están iclusive otros
tiles animados?

Podria ser , todo depende de como tu lo hagas, no existe una regla que te diga como debes usar los tiles, cada cual es libre de hacer su propia implementacion.

3 - Qué utilizan ustedes para realizar las pausas durante cada ciclo del
bucle general? Utilizan rest?

Podria funcionar, sin embargo lo mejor seria aprender a usar las funciones del temporizador avanzadas que trae allegro.

He programado una estructura llamara TileSet, cada una contiene un array con tiles separados (en respuesta a lo que preguntabas acerca de mantenerlos juntos y recortar o tenerlos ya por separado, aunque no se si será más eficiente, pero a mi me resulta más cómodo).

Una alternativa muy eficiente , que yo uso,
es colocar todo dentro de un solo BMP, agrupando como lo dije enteriormente,
luego para poder acceder a las diferentes secciones del BMP creo un arreglo, pero no un arreglo de imagenes sino un arreglo de rectangulos, donde cada rectangulo me indica cual es la posicion y tamaño del cuadro que voy a dibujar del bmp.
Un ejemplo seria mas o menos asi:

Respecto a lo de los colores.. que les puedo decir....

Si yo fuera un genio del arte grafico o al menos tuviera talento.... usaria imagenes de 256 colores nada más...

Pero...
como no lo soy uso imagenes de 24 bit o en su defecto de 16 aunque lo malo de las de 16 es que los desvanecimientos o mejor los difuminados.. o como le llamen no se ven muy bien, salvo que seas un artista o que tengas talento....

en este libro:

Lenguace C para expertos
Helbert Schild

Te enseñan a hacer un panit para DOS usando las interrupciones, puede no serte util si programas bajo windows, pero si usas compiladores como el DJFGPP te servira de mucho.

Hola,
si quieres ver un paint
entra por:

-Barra de inicio
-ejecutar
-en el recuadro blanco escribes mspaint
-presionas aceptar

Listo ahi puedes ver un paint hecho en C++ y funcionando      

si asi es.

Umm bueno me suena mucho..
pero la verdad prefiriria que fueras un poco mas claro porque no mejor sintetisas lo mas imporatnte de lo que necesitas a ver si te entiendo mejor.  

Podrias ser un poco más eswpecifico...
entiendo la idea , pero entre más datos nos des mejor.

ummmm,
demsiado complicado... taradaras un buen tiempo...
puedes hacerlo usando el DDK o la API.

Pero en tu lugar usaria algo como DirectX.DirectInput

Lo ideal sera que enmascararas las dll...
es decir haces unas clases que invoquen cada una lo que se necesite de cada dll en un momento de terminado pero las clases que creas pueden ser:

Eso lo puedes lograr invocando rutinas de la API de windows, en el ejemplo que te he colocado puedes ver como usar la API desde C# (aunque algunas cosas obviamente no estan alli... tendras que preguntar sino lo logras hacer)  con estos ajemplos ya puedes hacerte una idea y utilizar la api para lo que quieres realizar...

<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->
using System;
using System.Runtime.InteropServices;

namespace Engine_Estados
{
    public class Entrada_class
    {
        #region Llamado a funciones de la API

            [DllImport("kernel32", SetLastError=true)]
            static extern IntPtr GetStdHandle(IntPtr whichHandle);
            [DllImport("kernel32", SetLastError=true)]
            static extern bool GetConsoleMode(IntPtr handle, out uint mode);
            [DllImport("kernel32", SetLastError=true)]
            static extern bool SetConsoleMode(IntPtr handle, uint mode);

        #endregion

        #region Variables para manejo de la API

            static readonly IntPtr STD_INPUT_HANDLE = new IntPtr(-10);
            private IntPtr hConsoleHandle;
            const uint ENABLE_LINE_INPUT = 2;
            const uint ENABLE_ECHO_INPUT = 4;
            uint modo, nmodo;
        #endregion


        public Entrada_class()
        {
            hConsoleHandle = GetStdHandle(STD_INPUT_HANDLE);
            GetConsoleMode(hConsoleHandle, out modo);
            nmodo = modo & ~(ENABLE_LINE_INPUT |ENABLE_ECHO_INPUT);
            SetConsoleMode(hConsoleHandle, nmodo);
        }

        ~Entrada_class()
        {
            SetConsoleMode(hConsoleHandle, modo);
        }
        
        public int Leer()
        {
            return Console.Read();
        }
    
        public void Leer(char  car)
        {
            while(Console.Read() != car);
        }

        public int Leer(bool modoNormal)
        {
            int ret;
            if(modoNormal)
            {
                SetConsoleMode(hConsoleHandle, modo);
                ret = Console.Read();
                SetConsoleMode(hConsoleHandle, nmodo);
            }
            else
                ret = Console.Read();
            return ret;
        }
    }
}
<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->
Ahora si yo fuera tu usaria mejor alguna libreia como DirectX, especificamente DirectInput para poder hacerlo más facilmente y porque ademas incorporan muchas otras funcionalidades que te pueden ser de utilidad.

claro
1- has tu proia libreria accediendo a la api de windows
2- Usa un emulador  ( como el djgpp) y crealas usando assembler
3- Usa directX
4- Usa allegro
5- Usa cualquiera

con fopen
fread
fwrite

Pero hay cosas que no se pueden quitar aunque quieras como por ejemplo los flags que usa el sistema operativo para saber si es nu archivo o un directorio-

Lo que tu dices no tiene porblema pero tampoco tiene sentido..


Por ejemplo para que le qutarias los headers a nu bmp file....
simplemente el archivo no se podria leer de ninguna manera.

ejemplo 1:

strcat(cadena,"S");

ejemplo2

cadena[ultimo_car+1]='S';

Por supuesto en el segundo caso debes estar seguro de que tienes memoria reservada para alvergar el siguiente caracter.

http://www.wotsit.org

Busca por vesa, svga, super vga