No replies to this topic

[SjurWarEagle]

Hi,

the current calculation for the matchscore in the end-of-match-screen is the following:

(Kills * 1) + (Assists * 1) + (ComponentDestructions * 1) + (Spotting * 1) + (Damage / 10 rounded up) + (10 if won)

Why do I know this:

Spoiler

I took several screenshots and compared them with the matchscore after this, I calculated every possibility for the values I saw and this was the result.
After I got the values I checked about 20 more screenshots and everything matched.
And before someone speculates about hacking or looking into the secret game-files here is the miniscript (ugly, but works ) ) :

import java.util.Vector;
 
public class MWOMatchscore {
 
private Vector<PossibleResult> calc(int matchscore, int assists, int kills, int damage, int components, int spotting,
boolean won) {
Vector<PossibleResult> rc = new Vector<>();
 
for (int assistCnt = 0; assistCnt < 12; assistCnt++) {
for (int killsCnt = 0; killsCnt < 12; killsCnt++) {
for (int damageCnt = 1; damageCnt < 50; damageCnt++) {
for (int componentsCnt = 0; componentsCnt < 12; componentsCnt++) {
for (int spottingCnt = 0; spottingCnt < 12; spottingCnt++) {
for (int wonCnt = 0; wonCnt < 15; wonCnt++) {
int tmp = assists * assistCnt + kills * killsCnt + damage / damageCnt + components
* componentsCnt + spotting * spottingCnt;
if ((damage % 10)>0){
tmp++;
}
if (won) {
tmp += wonCnt;
}
int diff = (matchscore - tmp);
if (Math.abs(diff) < 1) {
PossibleResult result = new PossibleResult(assistCnt, killsCnt, damageCnt,
componentsCnt, spottingCnt, wonCnt);
rc.add(result);
}
}
}
}
}
}
}
return rc;
}
 
public MWOMatchscore() {
// TODO Auto-generated constructor stub
}
 
public static void main(String[] args) {
MWOMatchscore mwo = new MWOMatchscore();
Vector<PossibleResult> a = mwo.calc(133, 4, 5, 911, 8, 14, true);
Vector<PossibleResult> b = mwo.calc(51,3,0,461,0,1,false);
Vector<PossibleResult> c = mwo.calc(104, 9, 1, 786, 5, 0, true);
Vector<PossibleResult> d = mwo.calc(58, 8, 1, 353, 2, 1, true);
Vector<PossibleResult> e = mwo.calc(111, 6, 0, 901, 1, 13, false);
Vector<PossibleResult> f = mwo.calc(59,0,1,521,3,2,false);
 
for (PossibleResult possibleResult : a) {
if ((b.contains(possibleResult)) && (c.contains(possibleResult)) && (d.contains(possibleResult))
&& (e.contains(possibleResult)) && (f.contains(possibleResult))) {
System.out.println(possibleResult);
}
}
}
 
class PossibleResult {
int assists;
int kills;
int damage;
int components;
int spottingCnt;
int wonCnt;
 
public PossibleResult(int assists, int kills, int damage, int components, int spottingCnt, int wonCnt) {
this.assists = assists;
this.kills = kills;
this.damage = damage;
this.components = components;
this.spottingCnt = spottingCnt;
this.wonCnt = wonCnt;
}
 
@Override
public String toString() {
StringBuilder rc = new StringBuilder();
rc.append("assistCnt=" + String.format("%3d", assists));
rc.append(",");
rc.append("killsCnt=" + String.format("%3d", kills));
rc.append(",");
rc.append("damageCnt=" + String.format("%3d", damage));
rc.append(",");
rc.append("componentsCnt=" + String.format("%3d", components));
rc.append(",");
rc.append("spottingCnt=" + String.format("%3d", spottingCnt));
rc.append(",");
rc.append("wonCnt=" + String.format("%3d", wonCnt));
return rc.toString();
}
 
@Override
public boolean equals(Object obj) {
if (obj instanceof PossibleResult) {
PossibleResult tmp = (PossibleResult) obj;
boolean rc = false;
rc = (tmp.assists == assists) //
&& (tmp.kills == kills) //
&& (tmp.damage == damage) //
&& (tmp.components == components) //
&& (tmp.wonCnt == wonCnt) //
&& (tmp.spottingCnt == spottingCnt);
return rc;
} else {
return false;
}
}
}
}

I'm really unsatisfied with this solution, because there are things like defensive kill, ECM removal and many more.
The current value is mostly focused on damage, not on how good the role in the team was.

But how to change this? Well, first of all, we need a new formula, this is the reason for this post.



Fiddle around with the values in https://docs.google....VVE&usp=sharing the google document is an idea to fiddle around with the values and find working new values.

What do you say?