wfolsom/cs8803p4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Update the ProfileMatcher mapping.

Browse Source
This commit is contained in:
Marshall
2012-03-18 19:01:08 -04:00
parent a6f467d724
commit 952ccdc23b
1 changed files with 251 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

300
src/dk/itu/mario/level/matcher/ProfileMatcher.java
View File

@@ -1,20 +1,25 @@
package dk.itu.mario.level.matcher;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import dk.itu.mario.MarioInterface.GamePlay;
import dk.itu.mario.engine.DataRecorder;
import dk.itu.mario.level.PlayerProfile;
import dk.itu.mario.level.PlayerProfile.SKILL_LEVEL;
import dk.itu.mario.level.PlayerProfile.TYPE;
public class ProfileMatcher {
public enum SKILL { BUMP, COLLECT, JUMP, RUN, SHOOT, STOMP }
public enum SKILL {
BUMP, COLLECT, JUMP, RUN, SHOOT, STOMP
}
private static Map<PlayerProfile.TYPE, Map<SKILL,Integer>> referenceMetrics = new HashMap<PlayerProfile.TYPE, Map<SKILL,Integer>>();
private static Map<PlayerProfile.TYPE, Map<SKILL, Integer>> referenceMetrics = new HashMap<PlayerProfile.TYPE, Map<SKILL, Integer>>();
static {
Map<SKILL,Integer> canonicalVector = new HashMap<SKILL,Integer>();
Map<SKILL, Integer> canonicalVector = new HashMap<SKILL, Integer>();
canonicalVector.put(SKILL.BUMP, 100);
canonicalVector.put(SKILL.COLLECT, 50);
canonicalVector.put(SKILL.JUMP, 50);
@@ -23,7 +28,7 @@ public class ProfileMatcher {
canonicalVector.put(SKILL.STOMP, 0);
referenceMetrics.put(PlayerProfile.TYPE.BUMPER, canonicalVector);
canonicalVector = new HashMap<SKILL,Integer>();
canonicalVector = new HashMap<SKILL, Integer>();
canonicalVector.put(SKILL.BUMP, 50);
canonicalVector.put(SKILL.COLLECT, 100);
canonicalVector.put(SKILL.JUMP, 50);
@@ -32,7 +37,7 @@ public class ProfileMatcher {
canonicalVector.put(SKILL.STOMP, 0);
referenceMetrics.put(PlayerProfile.TYPE.COLLECTOR, canonicalVector);
canonicalVector = new HashMap<SKILL,Integer>();
canonicalVector = new HashMap<SKILL, Integer>();
canonicalVector.put(SKILL.BUMP, 50);
canonicalVector.put(SKILL.COLLECT, 0);
canonicalVector.put(SKILL.JUMP, 100);
@@ -41,7 +46,7 @@ public class ProfileMatcher {
canonicalVector.put(SKILL.STOMP, 0);
referenceMetrics.put(PlayerProfile.TYPE.JUMPER, canonicalVector);
canonicalVector = new HashMap<SKILL,Integer>();
canonicalVector = new HashMap<SKILL, Integer>();
canonicalVector.put(SKILL.BUMP, 0);
canonicalVector.put(SKILL.COLLECT, 0);
canonicalVector.put(SKILL.JUMP, 25);
@@ -50,7 +55,7 @@ public class ProfileMatcher {
canonicalVector.put(SKILL.STOMP, 0);
referenceMetrics.put(PlayerProfile.TYPE.RUNNER, canonicalVector);
canonicalVector = new HashMap<SKILL,Integer>();
canonicalVector = new HashMap<SKILL, Integer>();
canonicalVector.put(SKILL.BUMP, 0);
canonicalVector.put(SKILL.COLLECT, 0);
canonicalVector.put(SKILL.JUMP, 25);
@@ -60,102 +65,245 @@ public class ProfileMatcher {
referenceMetrics.put(PlayerProfile.TYPE.SHOOTER, canonicalVector);
}
public static PlayerProfile getMatchingProfile(GamePlay playerMetrics, DataRecorder detailedInfo) {
System.out.println("Selecting PlayerProfile based on GamePlay metrics, DataRecorder logs.");
public static PlayerProfile getMatchingProfile(GamePlay playerMetrics,
DataRecorder detailedInfo) {
System.out
.println("Selecting PlayerProfile based on GamePlay metrics, DataRecorder logs.");
int bumperScore = 0;
int collectorScore = 0;
int jumperScore = 0;
int runnerScore = 0;
int shooterScore = 0;
int stomperScore = 0;
// GAP comes from jump skill and jumper type.
// ENEMY comes from run skill and runner type and stomp skill.
// HARDER_ENEMY comes from shooting skill and shooting type.
// JUMP comes from jump skill and jumper type.
// BLOCK comes from bump skill and bumper type.
// COIN comes from collect skill and collector type.
// POWERUP comes from rote skill level.
bumperScore += playerMetrics.percentageBlocksDestroyed * 20;
bumperScore += playerMetrics.percentageCoinBlocksDestroyed * 20;
bumperScore += playerMetrics.percentageEmptyBlockesDestroyed * 20;
bumperScore += playerMetrics.percentagePowerBlockDestroyed * 20;
bumperScore += 4 * Math.min(5, playerMetrics.kickedShells);
SKILL_LEVEL skillLevel = null;
TYPE type = null;
HashMap<SKILL, Integer> skillVector = new HashMap<SKILL, Integer>();
collectorScore += playerMetrics.coinsCollected / 35.0;
int skillHolder;
jumperScore = Math.min(100, playerMetrics.jumpsNumber);
// Get bump skills.
// Relevant to: BLOCK.
skillHolder = (int) (100 * playerMetrics.percentageBlocksDestroyed);
skillVector.put(SKILL.BUMP, new Integer(skillHolder));
runnerScore = playerMetrics.timeRunningRight / playerMetrics.totalTime;
// Get collect skills.
// Relevant to: COIN.
skillHolder = (int) (100 * (((((double) playerMetrics.coinsCollected) / playerMetrics.totalCoins) + playerMetrics.percentageCoinBlocksDestroyed) / 2));
skillVector.put(SKILL.COLLECT, new Integer(skillHolder));
shooterScore += 10 * Math.min(10, playerMetrics.enemyKillByFire / 10.0);
// Get jump skills.
// Relevant to: GAP, JUMP.
// A high percentage of your kills were by stomping and a low percentage
// of your deaths were by plummeting...
stomperScore += Math.min(100, 2 * (playerMetrics.GoombasKilled + playerMetrics.GreenTurtlesKilled + playerMetrics.RedTurtlesKilled));
int deaths = playerMetrics.timesOfDeathByArmoredTurtle
+ playerMetrics.timesOfDeathByCannonBall
+ playerMetrics.timesOfDeathByChompFlower
+ (int) playerMetrics.timesOfDeathByFallingIntoGap
+ playerMetrics.timesOfDeathByGoomba
+ playerMetrics.timesOfDeathByGreenTurtle
+ playerMetrics.timesOfDeathByJumpFlower
+ playerMetrics.timesOfDeathByArmoredTurtle;
int kills = playerMetrics.ArmoredTurtlesKilled
+ playerMetrics.CannonBallKilled
+ playerMetrics.ChompFlowersKilled
+ playerMetrics.GoombasKilled
+ playerMetrics.GreenTurtlesKilled
+ playerMetrics.JumpFlowersKilled
+ playerMetrics.RedTurtlesKilled;
skillHolder = (int) (100 * (1
- ((playerMetrics.aimlessJumps / playerMetrics.jumpsNumber))
+ ((kills - playerMetrics.enemyKillByFire - playerMetrics.enemyKillByKickingShell) / (double) kills) + (1 - (playerMetrics.timesOfDeathByFallingIntoGap / deaths))) / 3);
skillVector.put(SKILL.JUMP, new Integer(skillHolder));
clampToPercentRange(bumperScore);
clampToPercentRange(collectorScore);
clampToPercentRange(jumperScore);
clampToPercentRange(runnerScore);
clampToPercentRange(shooterScore);
clampToPercentRange(stomperScore);
// Get run skills.
// Relevant to: ENEMY.
skillHolder = (int) (100 * ((((double) playerMetrics.timeSpentRunning)
/ playerMetrics.totalTime + (playerMetrics.timesPressedRun / 75 > 1 ? 0
: 1 - (playerMetrics.timesPressedRun / 75.0))) / 2));
skillVector.put(SKILL.RUN, new Integer(skillHolder));
System.out.println("bumperScore: " + bumperScore);
System.out.println("collectorScore: " + collectorScore);
System.out.println("jumperScore: " + jumperScore);
System.out.println("shooterScore: " + shooterScore);
System.out.println("stomperScore: " + stomperScore);
// Get shoot skills.
skillHolder = (int) (100 * (((((double) playerMetrics.totalTimeFireMode) / playerMetrics.totalTime) + (((double) playerMetrics.enemyKillByFire) / kills)) / 2));
skillVector.put(SKILL.SHOOT, new Integer(skillHolder));
Map<SKILL,Integer> playerProfileVector = new HashMap<SKILL,Integer>();
playerProfileVector.put(SKILL.BUMP, bumperScore);
playerProfileVector.put(SKILL.COLLECT, collectorScore);
playerProfileVector.put(SKILL.JUMP, jumperScore);
playerProfileVector.put(SKILL.RUN, runnerScore);
playerProfileVector.put(SKILL.SHOOT, shooterScore);
playerProfileVector.put(SKILL.STOMP, stomperScore);
// Get stomp skills.
// ((kills - playerMetrics.enemyKillByFire -
// playerMetrics.enemyKillByKickingShell) / (double) kills)
// playerMetrics.aimlessJumps.
skillHolder = (int) (100 * ((kills - playerMetrics.enemyKillByFire - playerMetrics.enemyKillByKickingShell) / (double) kills));
skillVector.put(SKILL.STOMP, new Integer(skillHolder));
double minDist = Double.MAX_VALUE;
PlayerProfile.TYPE closestMatch = PlayerProfile.TYPE.RUNNER;
// Determine type.
skillHolder = skillVector.get(SKILL.BUMP).intValue();
type = TYPE.BUMPER;
for (PlayerProfile.TYPE type : PlayerProfile.TYPE.values()) {
Map<SKILL,Integer> canonicalVector = ProfileMatcher.referenceMetrics.get(type);
double distance = 0.0;
for (SKILL skill : SKILL.values()) {
distance += Math.pow(canonicalVector.get(skill) - playerProfileVector.get(skill), 2);
}
if (distance < minDist) {
minDist = distance;
closestMatch = type;
}
if (skillHolder < skillVector.get(SKILL.COLLECT).intValue()) {
skillHolder = skillVector.get(SKILL.COLLECT).intValue();
type = TYPE.COLLECTOR;
}
SKILL_LEVEL skillLevel;
if (skillHolder < skillVector.get(SKILL.JUMP).intValue()) {
skillHolder = skillVector.get(SKILL.JUMP).intValue();
type = TYPE.JUMPER;
}
int keyScore = getKeyScore(playerProfileVector, closestMatch);
if (skillHolder < skillVector.get(SKILL.RUN).intValue()) {
skillHolder = skillVector.get(SKILL.RUN).intValue();
type = TYPE.RUNNER;
}
if (keyScore <= 20) {
skillLevel = SKILL_LEVEL.NOVICE;
} else if (keyScore <= 40) {
skillLevel = SKILL_LEVEL.BEGINNER;
} else if (keyScore <= 60) {
skillLevel = SKILL_LEVEL.COMPETENT;
} else if (keyScore <= 80) {
skillLevel = SKILL_LEVEL.PROFICIENT;
} else {
if (skillHolder < skillVector.get(SKILL.SHOOT).intValue()) {
skillHolder = skillVector.get(SKILL.SHOOT).intValue();
type = TYPE.SHOOTER;
}
if (skillHolder < skillVector.get(SKILL.STOMP).intValue()) {
type = TYPE.JUMPER;
}
// Determine rote level.
skillHolder = 0;
for (Iterator<Entry<SKILL, Integer>> i = skillVector.entrySet()
.iterator(); i.hasNext();) {
skillHolder += i.next().getValue().intValue();
}
skillHolder /= skillVector.size();
if (skillHolder >= 80) {
skillLevel = SKILL_LEVEL.EXPERT;
}
System.out.println("Skill level for this " + closestMatch + " is " + skillLevel + " (based on a score of " + keyScore + " out of 100.)");
return new PlayerProfile(skillLevel, closestMatch, playerProfileVector);
else if (skillHolder >= 60) {
skillLevel = SKILL_LEVEL.PROFICIENT;
}
private static int getKeyScore(Map<SKILL, Integer> playerProfileVector, PlayerProfile.TYPE playerProfileType) {
else if (skillHolder >= 40) {
skillLevel = SKILL_LEVEL.COMPETENT;
}
else if (skillHolder >= 20) {
skillLevel = SKILL_LEVEL.BEGINNER;
}
else {
skillLevel = SKILL_LEVEL.NOVICE;
}
return new PlayerProfile(skillLevel, type, skillVector);
// None of this is wrong necessarily. I just want to try some other
// stuff.
// int bumperScore = 0;
// int collectorScore = 0;
// int jumperScore = 0;
// int runnerScore = 0;
// int shooterScore = 0;
// int stomperScore = 0;
//
// bumperScore += playerMetrics.percentageBlocksDestroyed * 20;
// bumperScore += playerMetrics.percentageCoinBlocksDestroyed * 20;
// bumperScore += playerMetrics.percentageEmptyBlockesDestroyed * 20;
// bumperScore += playerMetrics.percentagePowerBlockDestroyed * 20;
// bumperScore += 4 * Math.min(5, playerMetrics.kickedShells);
//
// collectorScore += playerMetrics.coinsCollected / 35.0;
//
// jumperScore = Math.min(100, playerMetrics.jumpsNumber);
//
// runnerScore = playerMetrics.timeRunningRight /
// playerMetrics.totalTime;
//
// shooterScore += 10 * Math.min(10, playerMetrics.enemyKillByFire /
// 10.0);
//
// stomperScore += Math
// .min(100,
// 2 * (playerMetrics.GoombasKilled
// + playerMetrics.GreenTurtlesKilled +
// playerMetrics.RedTurtlesKilled));
//
// clampToPercentRange(bumperScore);
// clampToPercentRange(collectorScore);
// clampToPercentRange(jumperScore);
// clampToPercentRange(runnerScore);
// clampToPercentRange(shooterScore);
// clampToPercentRange(stomperScore);
//
// System.out.println("bumperScore: " + bumperScore);
// System.out.println("collectorScore: " + collectorScore);
// System.out.println("jumperScore: " + jumperScore);
// System.out.println("shooterScore: " + shooterScore);
// System.out.println("stomperScore: " + stomperScore);
//
// Map<SKILL, Integer> playerProfileVector = new HashMap<SKILL,
// Integer>();
// playerProfileVector.put(SKILL.BUMP, bumperScore);
// playerProfileVector.put(SKILL.COLLECT, collectorScore);
// playerProfileVector.put(SKILL.JUMP, jumperScore);
// playerProfileVector.put(SKILL.RUN, runnerScore);
// playerProfileVector.put(SKILL.SHOOT, shooterScore);
// playerProfileVector.put(SKILL.STOMP, stomperScore);
//
// double minDist = Double.MAX_VALUE;
// PlayerProfile.TYPE closestMatch = PlayerProfile.TYPE.RUNNER;
//
// for (PlayerProfile.TYPE type : PlayerProfile.TYPE.values()) {
// Map<SKILL, Integer> canonicalVector = ProfileMatcher.referenceMetrics
// .get(type);
// double distance = 0.0;
// for (SKILL skill : SKILL.values()) {
// distance += Math.pow(canonicalVector.get(skill)
// - playerProfileVector.get(skill), 2);
// }
// if (distance < minDist) {
// minDist = distance;
// closestMatch = type;
// }
// }
//
// SKILL_LEVEL skillLevel;
//
// int keyScore = getKeyScore(playerProfileVector, closestMatch);
//
// if (keyScore <= 20) {
// skillLevel = SKILL_LEVEL.NOVICE;
// } else if (keyScore <= 40) {
// skillLevel = SKILL_LEVEL.BEGINNER;
// } else if (keyScore <= 60) {
// skillLevel = SKILL_LEVEL.COMPETENT;
// } else if (keyScore <= 80) {
// skillLevel = SKILL_LEVEL.PROFICIENT;
// } else {
// skillLevel = SKILL_LEVEL.EXPERT;
// }
//
// System.out.println("Skill level for this " + closestMatch + " is "
// + skillLevel + " (based on a score of " + keyScore
// + " out of 100.)");
//
// return new PlayerProfile(skillLevel, closestMatch,
// playerProfileVector);
}
private static int getKeyScore(Map<SKILL, Integer> playerProfileVector,
PlayerProfile.TYPE playerProfileType) {
switch (playerProfileType) {
case BUMPER :
case BUMPER:
return playerProfileVector.get(SKILL.BUMP);
case COLLECTOR :
case COLLECTOR:
return playerProfileVector.get(SKILL.COLLECT);
case JUMPER :
case JUMPER:
return playerProfileVector.get(SKILL.JUMP);
case RUNNER :
case RUNNER:
return playerProfileVector.get(SKILL.RUN);
case SHOOTER :
case SHOOTER:
return playerProfileVector.get(SKILL.SHOOT);
default :
default:
return 0;
}
}