Como compactar um mínimo de animação quadro a quadro no jogo no disco

Estou desenvolvendo um jogo como o Age of Empire (edifícios no mapa) e para cada prédio tenho uma planilha de sprites para sua animação. Estou usando a animação quadro a quadro para animar o edifício (sem conhecer nenhum outro método). Percebo que minha pasta de recursos está indo extremamente grande devido às imagens que estou colocando nela.

Como jogos como CoC e Age of Empires mantêm seu tamanho de apk abaixo de 50 Mg? Estou perdendo alguma coisa aqui quando se trata de desenvolvimento de jogos

Obrigado

EDIT: Mais informações sobre o problema que estou enfrentando

Eu tenho muitos objetos desenháveis ​​de animações. Eu escolhi esse caminho porque era o mais rápido e estava produzindo os resultados que eu queria. Basicamente, todo edifício é um desenho de animação no qual seu arquivo xml se refere a 8 desenhos (8 imagens = 8 arquivos). Todos eles são PNG devido à transparência. Como tenho mais de 200 imagens, o tamanho do apk é 120 MB (e ainda não terminei de copiar metade dos arquivos). É isso que pronto, tem que haver uma maneira de resolvê-lo. Por favor, ajude um colega desenvolvedor

Não está claro por sua pergunta se você realmente deseja conhecer técnicas que permitem que os jogos economizem espaço em disco, mesmo com grandes quantidades de arquivos de imagem / recursos pesados ​​(é o que está no corpo da pergunta), ou se você só quer saber se há menos formas de fazer animação para os seus edifícios com menos espaço em disco (é isso que está implícito no título da sua pergunta).

Então, vou colocar essa resposta aqui, tentando ajudar em relação à economia de espaço quando você tiver muitas imagens. Se você estiver interessado apenas em conhecer técnicas de animação que possam permitir economizar espaço em disco, entre em contato para que eu possa excluir a resposta.

Dito isto, em uma situação semelhante, duas soluções que eu vi (e usei uma vez) em termos de economia de espaço no disco foram:

1) concatenar imagens individuais dentro de uma mesma imagem. Às vezes, pode ser útil. Portanto, em vez de salvar 4 arquivos separados para cada um dos quadrados coloridos a seguir, salvei todos lado a lado na mesma imagem (e os dividirei apenas pelo código do jogo):

Neste exemplo, salvar cada um em quatro arquivos PNG diferentes equivale a 1255 bytes, enquanto o arquivo único com todos os concatenados é 451 bytes. Obviamente, o quanto isso pode ajudar depende de cada caso e você deve testar para ver se isso pode ser útil para você, dependendo de suas imagens.

2) para compactar a pasta de recursos. Isso geralmente pode ser muito útil para economizar espaço em disco. Então, quando o jogo está em execução, você descompacta ou extrai a imagem desejada do arquivo compactado - dependendo do formato de compactação usado. Veja esta resposta anterior que se tornou um wiki deste site: /gamedev//a/37649/72423

Mas lembre-se de que cada tipo de compactação pode ser mais ou menos vantajoso, dependendo do tipo de arquivo de imagem usado : Evite a compactação dupla de recursos

Para mais detalhes sobre compactação: estado da arte em compactação de imagem?

Por fim, você também pode estar interessado em pensar quais tipos de imagem usar para cada situação: Qual formato de imagem é mais eficiente em memória: PNG, JPEG ou GIF?

Eu proporia que você tente o TexturePacker

• você pode simplesmente arrastar e soltar todas as suas imagens e empacotá-las
• você pode aplicar compactação diferente - por exemplo, usar PNGs indexados que consomem muito menos memória - até 70% menos em comparação com um arquivo PNG padrão
• você pode criar um arquivo de dados que contém o nome + a posição de cada um de seus edifícios
• a versão gratuita já pode ser suficiente para criar as folhas de sprite para você

Você usa uma estrutura de desenvolvimento de jogos como AndEngine, Cocos2d-x ou LibGdx? => Nenhum

Você precisa de todas as suas imagens carregadas ao mesmo tempo? Parece que você terá grandes problemas de RAM nos dispositivos de destino.

Atualização: Snake me enviou algumas imagens. Como prometido, não os tornará públicos aqui, então eu mesmo criei algumas artes para demonstrar como reduzir o uso de memória.

Na imagem original, apenas uma parte da imagem estava em movimento. Coloquei um pássaro em uma casa para demonstrar isso:

Basicamente, empacotar a animação completa em uma folha é um grande desperdício de memória. Você deve dividir as partes estáticas e móveis:

Estático:

Anim01:

Anim02:

Mantenha a posição original do pássaro nas imagens . É por isso que há tanto espaço vazio acima. Você precisa disso para alinhar a animação.

Agora arraste as imagens no TexturePacker e selecione os seguintes parâmetros

• Formato de dados: hash JSON (ou XML, se você preferir)
• TrimMode: Trim (isso cria retângulos)
• Formato de pixel: 8 bits INDEXADO - para criar PNGs de 8 bits (cerca de 70% menos memória)
• Permitir rotação: false
• Digite um nome de arquivo para os dados

O resultado é que agora você obtém 2 arquivos: a folha de sprite e um arquivo de descrição JSON.

"house_anim_01.png":
{
    "frame": {"x":351,"y":246,"w":110,"h":79},
    "rotated": false,
    "trimmed": true,
    "spriteSourceSize": {"x":67,"y":8,"w":110,"h":79},
    "sourceSize": {"w":400,"h":400},
    "pivot": {"x":0.5,"y":0.5}
},

As partes importantes são frame e spriteSourceSize .

O quadro fornece a localização do sprite original na folha de sprite.

spriteSourceSize fornece o deslocamento para desenhar a imagem - as partes da imagem que são deixadas de fora devido ao corte:

Uma rotina simples de desenho de pseudo-código se parece com isso:

drawImage(spritename, posX, posX)
{
    data    = sheetData[spritename]
    offsetX = data.spriteSourceSize.x
    offsetY = data.spriteSourceSize.y
    frameX  = data.frame.x
    frameY  = data.frame.y
    width   = data.frame.w
    height  = data.frame.h
    screen.draw(sheetImage, posX+offsetX, posY+offsetY, width, height)
}

Pode ser necessário ajustar o cálculo do deslocamento, dependendo do ponto / origem do pivô no seu sistema gráfico. A rotina acima pressupõe um sistema de coordenadas cuja origem é superior esquerda.

Em seguida, basta desenhar a casa em 2 passagens:

draw("background", 100, 100);
draw("anim_01", 100, 100);

Você não precisa se preocupar com as compensações - já que as imagens já estão alinhadas.

Aqui estão alguns ponteiros que você pode usar

1. Tente garantir que todas as imagens em segundo plano e não transparentes não estejam no formato PNG
2. Tente ter todas as animações ativadas por loop, ou seja, se a animação for 1,2,3,4,5,6, tente torná-la como 1,2,3,4,3,2,1, onde esses números são o número de quadros da animação, isso ajuda muito
3. se muitas imagens são iguais e apenas a cor difere (geralmente botões da interface do usuário, m animações de partículas, moedas de jogo), tente capturar uma imagem em branco e alterar sua cor dinamicamente
4. Tente criar seu .apk apenas com imagens extremamente importantes e carregue tudo de um servidor e mantenha a memória do telefone

Espero que esses indicadores ajudem

PS: Eu só dou uma idéia generalizada, pois não conheço o conteúdo exato do jogo e peço desculpas se esses indicadores não forem úteis

Muitos jogos não mantêm seus recursos gráficos no .apk; eles incluem apenas o "básico", como gráficos da interface do usuário e o código do jogo e baixam o restante dos recursos depois que o jogo é instalado. Isso é especialmente verdadeiro para jogos que usam recursos gráficos diferentes, dependendo da resolução da tela, para impedir que o .apk tenha que conter ativos de baixa resolução e alta resolução.

Você deve considerar as opções de otimização fornecidas pelos outros respondentes, bem como, finalmente, você terá que veicular os gráficos do seu jogo separadamente do próprio .apk.

Eu vim a este site procurando uma pergunta semelhante e existem alguns bons recursos apontados nas respostas à sua pergunta e em outras perguntas.

Você provavelmente deveria dar uma olhada na animação 2D: modelos 3D animados ou sprites com quadros de animação? para algum debate sobre diferentes tipos de animação. Isso me ajudou a otimizar meu jogo. Além disso, você não nos diz qual API você está usando ou qual mecanismo você usa. Só isso já pode fazer muita diferença: animação PNG quadro a quadro do Android

Além disso, lembre-se de que, se você seguir a rota de compactação, poderá haver diferenças importantes entre a forma como você compacta. Especificamente, existem algumas diferenças entre os tipos de compactação e há um debate especializado sobre qual é a rota mais apropriada para dispositivos móveis. Especialmente se você levar em conta que, para dispositivos móveis, o uso de RAM e o desperdício de CPU para carregamento também são fundamentais. Consulte: http://www.gamasutra.com/blogs/AlexandruVoica/20130419/190833/Why_efficiency_is_key_in_texture_compression_standards_for_mobile_graphics.php?print=1