experience/level/benodigd berekening uit totaal xp

Een formule met afrond-functies kan niet exact teruggerekend worden.

voorbeeldje:
<?php
$x = 5;
$a = floor($x/2); // $a is nu 2 in plaats van 2.5
?>
2.5*2 = 5 maar 2*2=4.

Verder kun je de formule het beste uit elkaar rafelen:
<?php
$multiplier = 100;
$totaal_xp = 1200;

$a = $multiplier^2;
$b = $multiplier*2;
$c = $multiplier/2;

$t = $b * $totaal_xp;
$t = sqrt($a + $t);
$t = floor($c + $t);
$level = floor($t / $multiplier);

echo $level;
?>
En daarna stap voor stap terug rekenen en tussentijdse uitkomsten met elkaar vergelijken.

Een formule met afrond-functies kan niet exact teruggerekend worden

Oke hier kwam ik ook al achter toen ik mijn eigen formulie maakte, is het dan niet verstandiger om Float te gebruiken en dan geen afrond functies meer?

//edit

ik heb nu een som gemaakt dat mij de level, xp_nodig en xp_totaal geeft.
Maar hoe krijg ik dit vanaf de xp totaal berekent?

<?php
$xp_weergeven_tot_level = 10;

$plier = 30;
$i=0;

while($i < $xp_weergeven_tot_level) {

$xp_berekenen = (( $i + $plier / 3.14) * 3.14) * $i;
$xp_totaal = $xp_totaal + $xp_berekenen;

$a = $i+1;
echo 'naar level '.$a.' kost '.$xp_berekenen.' xp<br>';

$i++;
}

echo '<br>totaal xp nodig tot '.$i.' = '.$xp_totaal.'<br><br>' ;
?>

bovenstaande script output:

naar level 1 kost 0 xp
naar level 2 kost 33.14 xp
naar level 3 kost 72.56 xp
naar level 4 kost 118.26 xp
naar level 5 kost 170.24 xp
naar level 6 kost 228.5 xp
naar level 7 kost 293.04 xp
naar level 8 kost 363.86 xp
naar level 9 kost 440.96 xp
naar level 10 kost 524.34 xp

totaal xp nodig tot 10 = 2244.9

Ben nu de gehele dag aan het proberen om het voor elkaar te krijgen, maar dit is boven mijn kunnen.

Afronden inderdaad weglaten lijkt me beter. Ik vind het overigens maar een vreemde formule maar goed dat ter zijde. Je kunt wel het afronden alsnog doen in de echo regel:
<?php
echo floor($level)
?>
Op deze manier overschrijf je $level niet.

Mijn uitgerafelde formule zonder floor functies komt er dan zo uit te zien:
<?php
$multiplier = 100;
$totaal_xp = 1200;

$a = $multiplier^2;
$b = $multiplier*2;
$c = $multiplier/2;

$t = $b * $totaal_xp;
$t = sqrt($a + $t);
$t = $c + $t;
$level = $t / $multiplier;

echo $level;
?>

Nu willen we gaan terugrekenen waarbij de totaal_xp berekend moet worden en de multiplier wel bekend is (toch?) eerste stukje is simpel:
<?php
$multiplier = 100;
$level = 5;

$a = $multiplier^2;
$b = $multiplier*2;
$c = $multiplier/2;

?>
dan moeten we hier beginnen:
<?php
$level = $t / $multiplier;
?>
Vul in wat we al weten:
5 = $t / 100
dus $t = 500. Maar hoe berekenen we dat?
<?php
$t = $level * $multiplier;
?>

Dan de tweede stap:
<?php
500 = 50 + $t;
?>
dus $t wordt hier 450.
Dat berekenen we zo:
<?php
$t = $t - $c; // 450 = 500 - 50
?>

Het eerste stuk van de reverse berekening ziet er nu zo uit:
<?php
$multiplier = 100;
$level = 5;

$a = $multiplier^2;
$b = $multiplier*2;
$c = $multiplier/2;

$t = $level * $multiplier;
$t = $t - $c;
?>

Nu de wortel en de kwadraat nog. Probeer het eens?

Dit heb ik er van kunnen maken, en is niet goed, want het resultaat komt op 1523.52 ipv 1200, zols ik al zei ik heb hier de ballen verstand van.

<?php
$multiplier = 100;
$level = 5;

$a = $multiplier^2;
$b = $multiplier*2;
$c = $multiplier/2;

$t = $level * $multiplier;
$t = $t - $c;
$t = ($t + $a) * ($t + $a);
$xp = $t / $b;

echo '<br>2de som '.$xp;
?>

//edit

Kon niet slapen dus toch maar weer even aan het puzzelen geweest.
Ben opnieuw begonnen, en bij toeval kwam het zo uit dat het werkt beide kanten op.

dit is het scriptje wat ik nu heb gemaakt dat beide kanten op rekent, zowel level naar xp als xp naar level. enigste nadeel is hij rekent nu 75 exp per level dat is wel jammer want hoe je daar nu weer variatie in krijgt is me weer te lastig.

<?php
//level vanuit xp berekenen en van level naar de xp
$multiplier = 75;
$totaal_xp = 7500;

echo 'Xp staat op: <b>'.$totaal_xp.'</b><br><br>';

$som = $multiplier / 3.14;

$level = ($totaal_xp / $som) / 3.14;
$xp = ($level * $som) * 3.14;

echo 'Van xp naar level: <b>'.$level.'</b><br>Van level naar xp: <b>'.$xp.'</b>';
?>

Aangezien mij het niet lukt om zo'n berekening te maken heb ik een berekening gemaakt die gebruik maakt van een array met vooraf ingevoerde level up xp's.

Is dit een toelaatbare manier?
Mijn bedoeling is dat ik een sommetje maak om alle xp uitterekenen en die vervolgens vast in de array zet, en deze dan gebruikt word om alles mee uit te rekenen.

dit heb ik ervan gemaakt:
<?php
//de xp van de speler (uit database halen)
$huidig_xp = rand(0,1200);

//xp nodig per level (van level 0->1 = 30, 0->2=100, 0->3=250)
$xp_array = array(30, 100, 250, 430, 673, 1000);

$max_level = count($xp_array);
$max_level_xp = $xp_array[$max_level-1];
$i = 0;

if ($huidig_xp < $max_level_xp){

foreach($xp_array as $xp_deze_level) {

if ($huidig_xp < $xp_deze_level){

$xp_nodig_deze_level = $xp_deze_level - $huidig_xp;
$xp_volgende_level = $xp_array[$i];

echo 'Ben level '.$i;
echo '<br>Volgende level is '.($i+1);
echo '<br>Xp nog nodig deze level '.$xp_nodig_deze_level;
echo '<br>Totaal xp nodig deze level '.$xp_volgende_level;
echo '<br><br>Level '.$i.' | Xp '.$huidig_xp.'/'.$xp_volgende_level;

break;

}

$i++;
}

} else {
echo'Max level('.$max_level.') bereikt, huidig xp '.$huidig_xp;
}
?>

en de output van het script:

- algemene informatie:
Ben level 3
Volgende level is 4
Xp nog nodig deze level 25
Totaal xp nodig deze level 430

Level 3 | Xp 405/430

- max bereikt:
Max level(6) bereikt, huidig xp 1172

Zou het niet makkelijker zijn als je opslaat wat iemand zijn huidige level is, en hoeveel XP er nog nodig is voor het volgende level? Dan wordt e.e.a. volgens mij (een stuk) eenvoudiger. Ook zou je dan penalties op level kunnen baseren, hoe hoger het level hoe zwaarder de penalty (met een bepaalde bovengrens natuurlijk).

Ook zou je rekening moeten houden met een level-uitbreiding, als je max level wordt opgehoogd, kun je dan alle berekeningen in een ongeveerd rechte lijn doortrekken? Als deze kwadratisch of logaritmisch verlopen ontploffen de nummers op een gegeven moment en heb je een schaalbaarheidsprobleem wat op den duur genormaliseerd zou moeten worden.

Zou het niet makkelijker zijn als je opslaat wat iemand zijn huidige level is, en hoeveel XP er nog nodig is voor het volgende level? Dan wordt e.e.a. volgens mij (een stuk) eenvoudiger. Ook zou je dan penalties op level kunnen baseren, hoe hoger het level hoe zwaarder de penalty (met een bepaalde bovengrens natuurlijk).

Ook zou je rekening moeten houden met een level-uitbreiding, als je max level wordt opgehoogd, kun je dan alle berekeningen in een ongeveerd rechte lijn doortrekken? Als deze kwadratisch of logaritmisch verlopen ontploffen de nummers op een gegeven moment en heb je een schaalbaarheidsprobleem wat op den duur genormaliseerd zou moeten worden.

Hier zat ik eerst ook aan te denken, maar als ik de level opsla moet ik ook de xp opslaan anders valt er nog niks te berekenen. Op mijn manier zet ik alle level up xp's in de array (vooraf) dus ik maak een extern scriptje dat mijn xp variable verhoogt en deze plaats ik handmatig in de array. zodoende heb ik alle xp bij de hand voor elke level up. Aangezien ik de totaal_xp van de speler opsla in de database, kan ik vanaf daaruit alles berekenen. De level word immers al berekent dus de level variable kan ik overal weer gebruiken en restricties voor opleggen net zoals xp restricties. En ik wil ook een de-level systeem, zodat ik xp van de speler xp af kan halen en dat hij dus de-leveld.

En een level uitbreiding op deze manier, is alleen voor de extra levels, de xp in de array toevoegen. Hier zie ik dan ook geen probleem in.

Maar wat ik me wel afvraag is, hoeveel "levels" kan een array verwerken voordat het te traag wordt?