Como as animações de interação personagem / objeto funcionam em jogos isométricos?

Estou planejando um jogo isométrico de simulação de negócios, onde o jogador vê um escritório com os móveis usuais, como mesas, quadros brancos etc.

Personagens (Staff / NPC's) dentro do jogo devem interagir com esses objetos executando algumas tarefas predefinidas, como digitar no teclado na mesa ou escrever no quadro branco etc.

O que me interessa, especificamente, é o seguinte cenário:

O personagem se move pelo escritório (1) até sua mesa (2) e se senta e começa a digitar (3).

Pelo que entendi, eu teria uma folha de sprite para o movimento do personagem (1) e um sprite estático para a mesa (2), mas não entendo direito como o terceiro passo seria tratado?

Existe um sprite combinado que contenha mesa e personagem? Suponho que não, caso contrário, eu precisaria ter uma folha de sprite para cada mesa e combinação de caracteres.

Como isso é normalmente tratado?

EDITAR:

Aqui está um exemplo de animação específica do jogo Theme Hospital. Você pode ver o vídeo aqui .

Tanto quanto posso ver, a animação é dividida em várias etapas.

Passo 1 - O personagem se move entre a mesa e a cadeira.

Isso sugere que cadeira e mesa são, de fato, sprites separados.

Etapa 2 - O personagem senta a animação

Observe como, no último quadro, a cadeira está mais próxima da mesa.

Etapa 3 - Animações de mesa

Etapa 4 - Animação em pé

É o mesmo que sentar, mas jogado ao contrário.

Etapa 5 - Afaste-se

Use animação de movimento normal para se afastar.

As perguntas que tenho são: como essas animações são melhor separadas e como um artista gráfico geralmente as fornece?

O personagem sentado e digitando na mesa é realmente três sprites diferentes (mesa, personagem e cadeira)? Alguém conhece algum exemplo de sprites de animações semelhantes?

EDIT 2:

Acho que minha maior preocupação é que tenho as expectativas corretas sobre como os sprites realmente se parecerão. Eu não posso desenhá-los, então terei que pagar alguém para fazê-lo e presumo que exista algum tipo de prática recomendada para fazer esse tipo de animação?

Resposta curta? Não combine sprites.
Ou seja, se você combinar, terá que ter a animação para cada combinação. Parece estranho se você só quer uma cadeira. Mas vamos fingir que seu escritório poderia ser expandido no meio do jogo, onde as cadeiras agora têm um sprite melhor. Você adicionaria um sprite de cadeira ou recombinaria e acrescentaria novamente toda a animação de cada empregador?

Vamos fazer alguns cálculos.

Finja que você tem 6 sprites em um empregador sentado digitando animação, você tem 5 cadeiras diferentes e 10 tipos diferentes de empregadores.

Se você apenas desenhar o empregador em cima da cadeira, isso levaria 10 * 6 + 5 sprites, 65 sprites.
Se você combinar e fizer todas as combinações, serão necessários 10 * 6 * 5 sprites, ou seja, 300 sprites. Será uma dor para você fazer uma planilha deste tamanho apenas para uma animação simples!

EDITAR:

Bem, se você não souber, seria melhor definir sua cadeira como pano de fundo e a equipe como sprites ativos. Mais fácil para você.

Background.draw();
Foreach(employer i in staff)
    I.draw();

Isso deve manter sua equipe separada do seu chais (plano de fundo) Além disso, atualize os quadros da animação da equipe independentemente.

EDIT2:

Eu vi sua edição e suas amostras. Eu manteria a mesma abordagem. Todos os sprites diferentes. A cadeira ficaria na frente do personagem de qualquer maneira!

Para aproximar a cadeira, atualize sua posição para alguns pixels para cima e para a esquerda ou faça isso no próprio sprite.

Você entende sobre o Z align? que deve jogar muitas coisas ...

Você pode ver que algumas partes da cadeira ficam atrás do personagem, outras aparecem na frente. Então, como isso é possível se for apenas um sprite? Z alinhar!

Duas maneiras de conseguir o efeito. Mantenha uma máscara (não é tão fácil) ou divida seu sprite em dois.

Vou apenas mencionar o segundo método, como não tenho muito tempo agora. Você deve cortar o sprite da cadeira, nas partes que estariam na frente e no que estará por trás. Em seguida, coloque-os na mesma posição. fácil! O que é jogado é o Z Align aqui. As partes atrás devem ser colocadas atrás, o personagem no meio e as partes da frente na frente.

Não sei qual lib / api / sdk / toolset você está usando. Mas o mais faz assim: use um fator de Alinhamento que determina o que está por trás ou o que está à frente ou O que é chamado primeiro, fica atrás, o que é chamado último, fica na frente. Portanto, você deve manter isso em mente.

Uma idéia alternativa seria incluir uma imagem de Profundidade / Z Buffer com seus sprites, semelhante a como as APIs 3D (OpenGL) garantem que os polígonos não se sobreponham. Para um jogo de sprite básico, pode ser apenas um monte de 0/1 bits (bitmap em preto e branco) (embora você possa usar mais níveis de profundidade, se quiser).

Se você tem um sprite combinado de 'cadeira de mesa' e deseja que a cadeira apareça na frente de quaisquer outros sprites (ou seja, pessoas) naquele quadrado, você faria a versão Z-Buffer do char 'preta' enquanto a mesa seria 'branca' .

Quando você renderiza o sprite dinâmico (uma pessoa) nesse bloco, ele verifica se a cor está no buffer de profundidade. Para pixels 0 (preto), você pula o desenho da pessoa que sprites pixels e apenas deixa os da cadeira lá.

Em vez de verificar cada pixel 1 de cada vez, uma maneira mais simples de fazer a verificação seria multiplicar os pixels do sprite pelo valor do buffer de profundidade, pois a profundidade mais próxima seria 0 e cancelaria o. Então é claro que você precisa digitar a cor (a menos que tenha um canal de cores alfa).

É claro que isso aumenta a sobrecarga (embora você possa pular para qualquer coisa que não precise de vários níveis de profundidade, como uma cadeira de mesa). Você também precisa sincronizar suas animações (ou seja, a pessoa precisaria combinar com o anim da cadeira). Não oferece a mesma flexibilidade de ter apenas um monte de sprites separados.