Como posso calcular o nível atual do XP total, quando cada nível requer proporcionalmente mais XP?

No meu jogo, o XP necessário para alcançar o próximo nível é Nível Atual × Limiar de Nível . Dado isso, como posso obter meu nível atual do total de XP já ganho?

---

Por exemplo:

Level Threshold = 50
Current Level = 1

Começando no nível 1, eu precisaria (1 × 50) = 50 XP para chegar ao nível 2, e assim por diante.

Level 1: 50 XP needed to reach level 2
Level 2: 100 more XP needed to reach level 3
Level 3: 150 more XP needed to reach level 4

Em outras palavras, a tabela de progressão é a seguinte:

Level 1: 0 XP to 49 XP
Level 2: 50 XP to 149 XP 
Level 3: 150 XP to 299 XP
Level 4: 300 XP to 499 XP

Se eu tiver 300 XP, chegarei ao nível 4. Como posso calcular isso geralmente?

Ao elaborar as matemáticas e resolver as Levelcondições condicionadas à experiência XP, obtemos:

$$Level = \frac{1 + \sqrt{1 + 8 \times XP \div 50}}{2}$$

Por exemplo, qual é o nível do jogador para ?$XP = 300$

$$\frac{1 + \sqrt{1 + 8 \times 300 \div 50}}{2} = 4$$

Como pedido.

Ou, qual é o nível XP = 100000?

$$\frac{1 + \sqrt{1 + 8 \times 100000 \div 50}}{2} = 63$$

Mais geralmente expresso, para um limite inicial arbitrário no nível 1:

$$Level = \frac{1 + \sqrt{1 + 8 \times threshold \div 50}}{2}$$

Você também pode fazer o inverso e calcular o XPnecessário para qualquer nível, resolvendo a fórmula acima para XP.

$$XP = \frac{(Level^2-Level) \times threshold}{2}$$

Observe que a fórmula acima funciona com frações, mas você precisa arredondar para o próximo valor inteiro. Por exemplo, em C ++ / C #, você poderia usar o nível (int).

Para obter a fórmula de forma fechada acima, usei equações de diferença, soma de Gauss e uma fórmula quadrática.

Se você está interessado na solução desta fórmula passo a passo ...

Nós fazemos um algoritmo recursivo, iniciando nossas considerações Experience(next_level) = Experience(current_level) + current_level*50.

Por exemplo, para obter , temos:$XP_{Level3}$

$$XP_{Level3} = XP_{Level2} + 2 \times 50$$

De onde 2*50vem a solicitação do OP de que a experiência necessária para alcançar o próximo nível é o nível atual * 50.

Agora, substituímos pela mesma lógica na fórmula. Isso é:$Xp_{Level2}$

Substitua na fórmula acima:$XP_{Level2} = XP_{Level1} + 2 \times 50$

$$Xp_{Level3} = Xp_{Level1} + 1 \times 50 + 2 \times 50$$

e são apenas 50, que é o nosso ponto de partida. Conseqüentemente$Xp_{Level1}$

$$Xp_{Level3} = 50 + 2 \times 50 = 150$$

Podemos reconhecer um padrão para calcular recursivamente níveis mais altos e uma cadeia finita de somatórios.

$$Xp_{LevelN} = 50 + 2 \times 50 + 3 \times 50 + ... + (N-1) \times 50 = \sum_{i=0}^{n-1} i \times 50$$

Onde N é o nível a ser alcançado. Para obter o XP para o nível N, precisamos resolver para N.

$$Xp_{LevelN} \div 50 = \sum_{i=0}^{n-1} i$$

Agora, o lado direito é simplesmente um somatório de 1 a N-1, que pode ser expresso pela soma de Gauss famoso . Conseqüentemente$N \times (N+1)\div2-N$

$$Xp_{LevelN} \div 50 = N(N+1) \div 2-N$$

ou apenas

$$2*(Xp_{LevelN} - 50) \div 50 = N(N+1)-2N$$

Por fim, colocando tudo de um lado:

$$0 = N^2-N-2 \times Xp_{LevelN} \div 50$$

Esta é agora uma fórmula quadrática que produz uma solução negativa e positiva, da qual apenas o positivo é relevante, pois não há níveis negativos. Agora obtemos:

$$N = \frac{1 + \sqrt{\frac{1+4 \times 2 \times Xp_{LevelN}}{50}}}{2}$$

O nível atual condicional no XP e no limite linear é, portanto:

$$Level = \frac{1 + \sqrt{1+8\times XP \div threshold}}{2}$$

$Level = \frac{\sqrt{XP}}{5.0}$XPLevel 100

Editar : esta fórmula está funcionando como deveria e gera corretamente a levelcondição atual XP com uma progressão de limite linear, conforme solicitado pelo OP. (A fórmula anterior produziu "nível + 1" assumindo que o jogador partiu do nível 0, que foi o meu erro - eu havia resolvido isso no meu horário de almoço escrevendo em um pequeno lenço de papel! :)

A solução simples e genérica , se você não precisar repetir esse cálculo milhões de vezes por segundo (e se o fizer, provavelmente está fazendo algo errado), é apenas usar um loop:

expLeft = playerExp
level = 1
while level < levelCap and expLeft >= 0:
    expLeft = expLeft - expToAdvanceFrom(level)
    level = level + 1

if expLeft < 0: level = level - 1     # correct overshoot

A grande vantagem desse método, além de não exigir matemática complicada, é que ele funciona para qualquer função arbitrária de exp por nível. Se desejar, você pode até criar valores de exp arbitrários por nível e armazená-los em uma tabela.

Se você (por algum motivo estranho) precisar de uma solução ainda mais rápida, também poderá pré- calcular a quantidade total de exp necessária para atingir cada nível, armazenar isso em uma tabela e usar uma pesquisa binária para encontrar o nível do jogador. O pré-cálculo ainda leva tempo proporcional ao número total de níveis, mas a pesquisa requer apenas tempo proporcional ao logaritmo do número de níveis.

A pergunta foi respondida com código, mas acho que deveria ser respondida com matemática. Alguém pode querer entender em vez de apenas copiar e colar.

$$\text{XP}_{\text{Level}+1} = \text{XP}_{\text{Level}} + \text{Level} \cdot \text{Threshold}$$

$\text{XP}$

$$\text{XP}_{\text{Level}} = \frac{(\text{Level}-1) \cdot \text{Level} \cdot \text{Threshold}}{2}$$

$\text{Level}$

$$\text{Level} = \left\lfloor \frac{\sqrt{\text{Threshold}^2 + 8 \cdot \text{XP} \cdot \text{Threshold}}}{2 \cdot \text{Threshold}}+\frac{1}{2} \right\rfloor$$

(truncar para inteiro, porque o jogador precisa de todo o XP necessário para obter algum bônus de nível)

Aqui está uma abordagem para resolver o problema usando álgebra básica. Se você não se importa com as etapas, pule para o final.

Uma coisa fácil de apresentar é, dado um nível n, a experiência total enecessária para obter esse nível:

e = sum from k=1 to n of (t(k-1))

O ttermo significa o aumento de XP necessário por nível - 50, no exemplo.

Podemos resolver o acima usando a fórmula para sequências aritméticas ( identidade da soma ):

e = t/2 * n(n-1)

No entanto, queremos a fórmula oposta - o nível do jogador, dada a sua experiência total. O que realmente queremos fazer é resolver o nível n,. Primeiro, vamos agrupar os termos:

n^2 - n - 2e/t = 0

Agora podemos usar a fórmula quadrática:

n = (1 + sqrt(1+8e/t))/2

---

Equação final:

level = 0.5 + sqrt(1 + 8*(total experience)/(threshold)) / 2

Toda a matemática envolvida aqui é muito importante para saber por todos os tipos de razões, algumas delas aplicáveis ​​ao desenvolvimento de jogos.

MAS

Este é um site de desenvolvimento de jogos, não um site de matemática. Então, vamos discutir como essas coisas funcionam não como séries algorítmicas, mas como conjuntos , porque esse é o tipo de matemática que se aplica ao nivelamento de jogos que você pode desenvolver para vender, e esse é o sistema que sustenta a maioria (mas não todos) do nivelamento sistemas (pelo menos historicamente).

Os jogadores tendem a preferir números agradáveis ​​e redondos que são fáceis de lembrar e visualizar, e em nenhum lugar isso é mais importante do que em um sistema de jogo baseado em níveis em que o jogador precisa de X quantidades de xp para avançar para o nível Y.

Há duas boas razões para escolher números redondos:

• A experiência de nível em si é um número redondo e agradável "100; 200; 1.000.000; etc."
• O delta entre níveis tende a ser outro número agradável e redondo que o jogador pode olhar e calcular em sua cabeça.

Números redondos são agradáveis. O objetivo dos jogos é ser agradável. Agradabilidade é importante, principalmente porque os dilemas do jogo geralmente são agradáveis ​​em termos de design.

Por que isso é importante ter em mente?

A maioria dos algoritmos de séries compostas não produz números agradáveis ​​e redondos

A maioria das séries não para em um ponto bonito (todas as respostas que eu vi aqui até agora só perduram para sempre). Então, o que fazemos? Aproximamos e depois determinamos que conjunto de níveis deve ser aplicado ao sistema de jogo .

Como sabemos quais aproximações são apropriadas? Consideramos qual é o ponto de nivelamento no sistema de jogo.

A maioria dos jogos tem limites de nível que começam em algum momento. Existem algumas maneiras de isso acontecer:

• O limite é encontrado relativamente cedo, onde o sistema de níveis existe apenas para ajudar os jogadores a passarem pela primeira fase do jogo de maneira focada para forçá-los a aprender o sistema de jogo completo. Uma vez que eles estão "totalmente crescidos", o longo jogo começa.
• XP ganha VS o nível de dificuldade tem uma certa economia onde sim, existe um limite de nível, mas é tão distante que esperamos que os jogadores completem o jogo na metade do gráfico de nivelamento. Nos RPGs no estilo DQ / FF, com vários caracteres / classes, é mais comum melhorar o nível de caracteres / classes diferentes, ganhando experiência em taxas diferentes do que alterar o XP necessário para cada nível por classe de personagem . Dessa forma, os jogadores podem se lembrar facilmente dos pequenos números redondos como objetivos universais e saber que cada personagem progride em direção a eles a uma taxa arbitrária estabelecida pelo sistema de jogo ( XP + (XP * Modifier)ou o que seja).
• Os limites de nível são baseados na categoria de caracteres externos. Ou seja, algum fator fora do sistema de jogo determina como é o sistema de níveis. Isso está se tornando mais comum, pois muitos jogos são pagos, mas são gratuitos. Um jogador grátis pode ter um limite no nível 70, um assinante pode ter um limite no nível 80, uma compra única pode aumentar o nível de alguém além do limite universal, etc.
• Os limites de nível são universais e vinculados ao mundo do jogo de alguma forma. Este sistema foi popularizado pelo WoW.
• Qualquer outro sistema de limite de nível que você possa imaginar que aprimore a jogabilidade de uma maneira mais inteligente do que simplesmente recompensar os jogadores por desperdiçarem mais minutos da vida no mundo inventado do que os outros jogadores.

Não são alguns sistemas de jogo onde não há limite de nível eo sistema é através de algoritmos determinados. Normalmente, sistemas como esse usam algum sistema X-powers-Y para fazer os números explodirem rapidamente. Isso torna muito fácil chegar ao nível L-1, razoavelmente esperado que a maioria dos jogadores chegue ao nível L, extremamente difícil chegar ao nível L + 1, e os jogadores envelhecem e morrem antes de atingir L + 2. Nesse caso, "L" é um nível que você decidiu ser o nível-alvo apropriado para o jogo e no qual normalmente limitaria o sistema, mas deixaria a opção aberta para que as pessoas se iludissem a pensar que é uma boa idéia para o XP para sempre. (Sinistro!) Nesse tipo de sistema, a matemática encontrada aqui faz todo sentido. Mas é um caso muito estreito e raramente encontrado em jogos reais.

Então, o que fazemos?

Calcular os níveis e XP? Não. Determine os níveis e XP? Sim.

Você determina o que os níveis significam e decide o que o conjunto de níveis disponível deve estar disponível. Essa decisão se resume a uma granularidade dentro do sistema de jogo (existe uma enorme diferença de poder entre os níveis? Cada nível confere uma nova habilidade? Etc.) e se os níveis são ou não usados ​​como um sistema de bloqueio ("Não é possível vá para a próxima cidade até completar o nível 10, garoto. ", ou um sistema competitivo de escadas imponha níveis baseados em níveis, etc.).

O código para isso é bastante direto e é apenas uma determinação de intervalo:

level(XP) when XP < 100  -> 1;
level(XP) when XP < 200  -> 2;
level(XP) when XP < 500  -> 3;
level(XP) when XP < 1000 -> 4;
% ...more levels...
level(XP) when XP > 1000000 -> 70. % level cap

Ou com uma declaração if, ou um caso, ou uma cadeia de if / elif, ou qualquer que seja o idioma que você esteja usando (Esta parte é o elemento menos interessante de qualquer sistema de jogo, eu apenas forneço duas maneiras, porque eu esteja no modo Erlang agora e a sintaxe acima pode não ser óbvia para todos.):

level(XP) ->
    if
        XP < 100  -> 1;
        XP < 200  -> 2;
        XP < 500  -> 3;
        XP < 1000 -> 4;
        % ...more levels...
        XP > 1000000 -> 70 % level cap
    end.

É matemática incrível? Não. Não mesmo. É implementação manual da determinação do elemento de ajuste? Sim. Isso é tudo o que é, e isso é muito bonito a maneira que eu vi isso realmente feito na maioria dos jogos ao longo dos anos.

Como nota lateral, isso não deve ser feito toda vez que o jogador ganha experiência. Normalmente, você monitora "XP para ir" como um valor e, uma vez que o jogador esgota ou ultrapassa o valor "para ir" (seja lá como você estiver fazendo), você calcula isso uma vez para descobrir onde o jogador está realmente em, armazene isso, calcule o próximo "ir" menos as sobras (se o transporte de XP for permitido) e repita.