Matemática para tower defense

Não sei se esse é mesmo um assunto avançado. A princípio, parece bem simples, mas à medida que vou pensando nele, vou percebendo que não tenho base pra garantir uma solução adequada. Vamos lá!

Adoro jogos de tower defense. Já iniciei vários projetos e abandonei todos eles, sempre prometendo voltar a mexer naquilo, num futuro próximo. Agora estou mesclando dois projetos abandonados e recomeçando do zero.
Só que, dessa vez, de cara já percebi um problema que VAI me fazer abandonar o projeto numa fase avançada. Talvez tenha sido o mesmo problema que me fez abandonar os outros projetos. E não é um problema de programação, mas de game design.

Eu não sei quanto dinheiro dar ao jogador.

Essa é, basicamente falando, a diferença entre um TD bom e um ruim. O equilíbrio entre as ondas de inimigos e a grana do jogador. Por "grana", entenda "o recurso básico que o será usado para construir e melhorar as torres".
É meio óbvio falar isso, mas se eu der grana demais, o jogador vai construir torres em excesso, o jogo fica muito fácil e perde a graça. Se eu der pouca grana, as torres não serão suficientes, o jogo fica impossível e perde a graça.
Pra complicar, como na maioria dos TDs, eu não vou dar toda a grana de cara. Vou alimentando o jogador à medida que cada fase transcorre. Aí, temos as ondas de inimigos cada vez mais poderosos e numerosos e as torres, também cada vez mais numerosas e poderosas.
Mas como equilibrar as coisas? Cada inimigo tem uma quantidade de "vida", um "dano básico", uma velocidade de deslocamento... Me PARECE possível calcular o raio de alcance, dano básico e cadência das torres que seriam necessárias pra dar cabo dele. Parece, mas não sei como fazer.
Nunca li nenhuma literatura a respeito, talvez não EXISTA nenhuma literatura a respeito, mas me parece que eu devo reduzir tudo a uma unidade básica e distribuir duas curvas - a de ataques e a de defesa - e deixar que os acúmulos dessas duas curvas (a área debaixo delas) sejam próximos uns dos outros. Quanto maior a diferença entre as áreas sob as curvas, menos equilibrado estará o jogo.

Mas ainda que isso seja correto, ainda restam muitas de dúvidas.
Que unidade básica é essa? Uma torre que mata dois inimigos gastou só uma unidade básica ou deve contar como duas? A estratégia entra nessa matemática?
Cada resposta ainda sucita novas dúvidas...
Então venho recorrer à comunidade. Alguém já leu alguma coisa a respeito do desenvolvimento de tower defenses?

PS: Depois que escrevi esse texto acima, vi esse artigo, que parece que vai chegar em alguma solução. Por outro lado, ele ainda está iniciando o assunto, pode ser que não resolva minha dúvida. Seja como for, a leitura é interessante.

Eu certamente não imagino como balancear algo deste tipo, sem testar. São muitas variáveis, depende de estratégia de jogador, caso seu jogo tenha chance de acertar um ataque, entra essas probabilidades, valores de atributos, enfim.
A grande incógnita é o dinheiro?
Pode demonstrar esse gráfico idealizado?

Nunca tive paixão por jogar ou estudar jogos deste tipo, mais acho que a forma certa de dar o dinheiro é pela quantidade e nível de(os) inimigos.
para dar o dinheiro, eu definiria um nível para cada tipo de inimigo, assim, definindo a dificuldade que o jogador teria para derrota-lo, e adicionaria alguns "Bônus" por exemplo:
se o player matar este inimigo sem tomar dano, ganha um Bônus de 10g, ou algo do tipo, levando em conta claro, o nível do inimigo.

para somar a quantidade de dinheiro que o inimigo dá, eu faria uma conta com suas abilidades.

algo do tipo:

Código:

gold = ((Ataque*10)+(defesa*8)+(Velocidade*5))*Nivel_do_inimigo

não sei se é isso que você quer mesmo, se não for, me desculpe, mais, isso que eu faria.
Sorte!

Pense da mesma forma que programação/matemática funciona.
Pegue uma variável/input, transforme em uma função e use o resultado.

Vamos pensar na dificuldade como o resultado dessa função.
Ela será uma escala usada para multiplicar com os valores base do jogo.
Digamos que a formula para essa dificuldade é (x^2) (digite isso no Google para visualizar) onde x é a entrada/argumento para todo o sistema e representa, por exemplo, em qual fase ele esta divido pelo número máxima de fases.

Código:

escala = power(fase / maxFase, 2);

Por conveniência, vamos pegar também o inverso da escala:

Código:

invEscala = 1/(escala);

Se o jogo tem 10 fases e ele esta na primeira, escala é 0.01 e invEscala é 10.

Exemplos de uso:
O jogador estar na fase 3/12.

Código:

escala = power(3 / 12, 2);

Se a ultima fase vai ter 30 ondas de inimigos, a terceira deve ter pelo menos 2 pois:

Código:

numeroDeInimigos = 30 * escala; // é igual a 1,875

Se você precisa derrotar 5 soldados para poder comprar o terceiro modelo de torre do jogo, o ultimo modelo precisaria de pelo menos 80 pois:

Código:

numeroDeInimigos = 5 * invEscala; // é igual a 80...

Se na terceira fase uma onde de inimigos demorava 5 minutos para começar, na ultima deve demorar 0.3125 minutos.
E assim por diante...

Você pode usar funções diferentes para coisas diferentes e/ou mais elaboradas tipo:
https://www.desmos.com/calculator/bqvhb4ydpl

É importante que o input seja a proporção entre o começo e o final do jogo, por isso, 0 <= x <= 1.
Já o resultado, não.

Show de bola, era interessante até um tutorial cm exemplos.

Me PARECE possível calcular o raio de alcance, dano básico e cadência das torres que seriam necessárias pra dar cabo dele. Parece, mas não sei como fazer.

Suponha que você tenha 2 tipos de inimigos:

Tipo 1
vida = 100
vel_deslocamento = 5*fps (pixels/segundo)
vel_ataque = 4 (dano/segundo)

Tipo 2
vida = 120
vel_deslocamento = 6*fps (pixels/segundo)
vel_ataque = 3 (dano/segundo)

Além disso, suponha que sua Torre tenha os atributos:
vida = 200
raio_alcance = 300 (pixels)
dano = 10 (por ataque)
latencia = 1*fps (1 segundo)

e que você tenha duas dessas torres.

A partir do momento que um inimigo entra no raio de alcance de uma torre, ela demorará:

t = (torre.latencia/torre.dano)*inimigo.vida

Se as torres estiverem próximas, uma estimativa razoável seria a metade do tempo.

Além disso, se vários inimigos atacarem juntos e estiverem próximos, você soma a vida deles.

Algo assim:

t = (torre.latencia/(torre.dano*total_torres))*(inimigo1.vida+inimigo2.vida+...+inimigoN.vida)

Sabendo o tempo que será gasto para destruir os inimigos, você pode criar uma variável em função do tempo:

dinheiro_que_sera_adicionado = 10*t

Se você tiver torres que não estão próximas, a fórmula fica um pouco mais complicada. Vou tentar fazer uma aproximação quando chegar em casa.

Genial, moçada!
Acho que, com isso, já dá pra ter uma ideia do que fazer com cada torre. Já dá pra começar a ditribuir alguns atributos.
Ainda tem as mudanças de atributos, como uma torre que melhore as outras nas imediações ou uma que não cause danos, mas afete os atributos do inimigo. Talvez, testando isso que já temos, eu consiga bolar alguma coisa.
Posso vir a pedir para reabrir o tópico, mas por enquanto, pelo menos, estou satisfeito.

Muito obrigado!