320 lines
12 KiB
Java
320 lines
12 KiB
Java
package magic;
|
|
|
|
import java.io.File;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.Stream;
|
|
|
|
import magic.ai.MagicAIImpl;
|
|
import magic.data.DeckGenerators;
|
|
import magic.data.DuelConfig;
|
|
import magic.exception.handler.ConsoleExceptionHandler;
|
|
import magic.headless.HeadlessGameController;
|
|
import magic.model.DuelPlayerConfig;
|
|
import magic.model.MagicDeckProfile;
|
|
import magic.model.MagicDuel;
|
|
import magic.model.MagicGame;
|
|
import magic.model.MagicRandom;
|
|
import magic.model.player.AiProfile;
|
|
import magic.utility.DeckUtils;
|
|
import magic.utility.MagicSystem;
|
|
import magic.utility.ProgressReporter;
|
|
|
|
public class AiStrCal {
|
|
|
|
private static int games = 10;
|
|
private static int repeat = 1;
|
|
private static int life = 20;
|
|
private static int seed;
|
|
private static String profile = "**";
|
|
private static List<String> deckPool;
|
|
private static String[] deck = {"", ""};
|
|
private static MagicAIImpl[] ai = {MagicAIImpl.MMAB, MagicAIImpl.MMAB};
|
|
private static int[] str = {6, 6};
|
|
private static int winTotal = 0;
|
|
private static int gamesTotal = 0;
|
|
private static boolean verifyFlip = false;
|
|
|
|
// Command line parsing.
|
|
private static boolean parseArguments(final String[] args) {
|
|
boolean validArgs = true;
|
|
for (int i = 0; i < args.length; i += 2) {
|
|
final String curr = args[i];
|
|
final String next = args[i+1];
|
|
if ("--games".equals(curr)) {
|
|
try { //parse CLI option
|
|
games = Integer.parseInt(next);
|
|
} catch (final NumberFormatException ex) {
|
|
System.err.println("ERROR! number of games not an integer");
|
|
validArgs = false;
|
|
}
|
|
} else if ("--str1".equals(curr)) {
|
|
try { //parse CLI option
|
|
str[0] = Integer.parseInt(next);
|
|
} catch (final NumberFormatException ex) {
|
|
System.err.println("ERROR! AI strength not an integer");
|
|
validArgs = false;
|
|
}
|
|
} else if ("--str2".equals(curr)) {
|
|
try { //parse CLI option
|
|
str[1] = Integer.parseInt(next);
|
|
} catch (final NumberFormatException ex) {
|
|
System.err.println("ERROR! AI strength not an integer");
|
|
validArgs = false;
|
|
}
|
|
} else if ("--deck1".equals(curr)) {
|
|
deck[0] = next;
|
|
} else if ("--deck2".equals(curr)) {
|
|
deck[1] = next;
|
|
} else if ("--deckpool".equals(curr)) {
|
|
try (Stream<Path> paths = Files.walk(Paths.get(next))) {
|
|
deckPool = paths
|
|
.filter(Files::isRegularFile)
|
|
.map(Path::toString)
|
|
.collect(Collectors.toList());
|
|
}catch(Exception e){
|
|
System.err.println("Error reading from "+ next);
|
|
|
|
}
|
|
} else if ("--profile".equals(curr)) {
|
|
profile = next;
|
|
} else if ("--verify".equals(curr)) {
|
|
verifyFlip = true;
|
|
} else if ("--ai1".equals(curr)) {
|
|
try { //parse CLI option
|
|
ai[0] = MagicAIImpl.valueOf(next);
|
|
// ai[0].getAI().setMaxThreads(2);
|
|
} catch (final IllegalArgumentException ex) {
|
|
System.err.println("Error: " + next + " is not valid AI");
|
|
validArgs = false;
|
|
}
|
|
} else if ("--ai2".equals(curr)) {
|
|
try { //parse CLI option
|
|
ai[1] = MagicAIImpl.valueOf(next);
|
|
// ai[1].getAI().setMaxThreads(2);
|
|
} catch (final IllegalArgumentException ex) {
|
|
System.err.println("Error: " + next + " is not valid AI");
|
|
validArgs = false;
|
|
}
|
|
} else if ("--life".equals(curr)) {
|
|
try { //parse CLI option
|
|
life = Integer.parseInt(next);
|
|
} catch (final NumberFormatException ex) {
|
|
System.err.println("ERROR! starting life is not an integer");
|
|
validArgs = false;
|
|
}
|
|
} else if ("--repeat".equals(curr)) {
|
|
try { //parse CLI option
|
|
repeat = Integer.parseInt(next);
|
|
} catch (final NumberFormatException ex) {
|
|
System.err.println("ERROR! repeat is not an integer");
|
|
validArgs = false;
|
|
}
|
|
} else if ("--seed".equals(curr)) {
|
|
try { //parse CLI option
|
|
seed = Integer.parseInt(next);
|
|
} catch (final NumberFormatException ex) {
|
|
System.err.println("ERROR! seed is not an integer");
|
|
validArgs = false;
|
|
}
|
|
} else {
|
|
System.err.println("Error: unknown option " + curr);
|
|
validArgs = false;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
if(deckPool != null){
|
|
System.err.println("Using decklists from pool");
|
|
} else if (deck[i].length() == 0) {
|
|
System.err.println("Using profile " + profile + " to generate deck " + (i+1));
|
|
} else if (!(new File(deck[i])).exists()) {
|
|
System.err.println("Error: file " + deck[i] + " does not exist");
|
|
validArgs = false;
|
|
}
|
|
}
|
|
|
|
return validArgs;
|
|
}
|
|
|
|
private static MagicDuel setupDuel() {
|
|
// Set the random seed
|
|
if (seed != 0) {
|
|
MagicRandom.setRNGState(seed);
|
|
seed = MagicRandom.nextRNGInt() + 1;
|
|
}
|
|
|
|
// Set number of games.
|
|
final DuelConfig config=new DuelConfig();
|
|
config.setNrOfGames(games);
|
|
config.setStartLife(life);
|
|
|
|
// Set difficulty.
|
|
final MagicDuel testDuel=new MagicDuel(config);
|
|
testDuel.initialize();
|
|
|
|
// Create players
|
|
final DuelPlayerConfig[] players = new DuelPlayerConfig[2];
|
|
for (int i = 0; i < 2; i++) {
|
|
players[i] = new DuelPlayerConfig(
|
|
AiProfile.create(ai[i], str[i]),
|
|
MagicDeckProfile.getDeckProfile(profile)
|
|
);
|
|
}
|
|
testDuel.setPlayers(players);
|
|
|
|
// Set the deck.
|
|
for (int i = 0; i < 2; i++) {
|
|
if (deck[i].length() > 0) {
|
|
DeckUtils.loadAndSetPlayerDeck(deck[i], players[i]);
|
|
} else {
|
|
DeckGenerators.setRandomDeck(players[i]);
|
|
}
|
|
}
|
|
|
|
return testDuel;
|
|
}
|
|
|
|
public static void main(final String[] args) {
|
|
|
|
Thread.setDefaultUncaughtExceptionHandler(new ConsoleExceptionHandler());
|
|
|
|
if (!parseArguments(args)) {
|
|
System.err.println("Usage: java -cp <path to Magarena.jar/exe> magic.DeckStrCal --deck1 <.dec file> --deck2 <.dec file> [options]");
|
|
System.err.println("Options:");
|
|
System.err.println("--ai1 [MMAB|MMABC|MCTS|RND] (AI for player 1, default MMAB)");
|
|
System.err.println("--ai2 [MMAB|MMABC|MCTS|RND] (AI for player 2, default MMAB)");
|
|
System.err.println("--strength <1-8> (level of AI, default 6)");
|
|
System.err.println("--games <1-*> (number of games to play, default 10)");
|
|
System.err.println("--deckpool <dir> (directory from where to read deck lists)");
|
|
System.err.println("--verify true (verify the hands of players are equal after flip)");
|
|
System.exit(1);
|
|
}
|
|
|
|
MagicSystem.initialize(new ProgressReporter());
|
|
ArrayList<String> reversePool = new ArrayList<String>(deckPool);
|
|
Collections.reverse(reversePool);
|
|
for (int i = 0; i < repeat; i++) {
|
|
if(deckPool == null) {
|
|
runDuel();
|
|
}else{
|
|
for(String deck1: reversePool){
|
|
for(String deck2: deckPool){
|
|
deck[0] = deck1;
|
|
deck[1] = deck2;
|
|
runDuel();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void compareHands(String expected, String actual){
|
|
if(!expected.equals(actual)){
|
|
System.err.println("Hands to not match");
|
|
System.err.println(expected);
|
|
System.err.println("----");
|
|
System.err.println(actual);
|
|
}
|
|
}
|
|
|
|
private static void runDuel() {
|
|
final MagicDuel testDuel = setupDuel();
|
|
|
|
System.out.println(
|
|
padDeckLeft("deck1") +
|
|
"\t"+padAILeft("ai1") +
|
|
"\tstr1" +
|
|
"\t"+padDeckLeft("deck2") +
|
|
"\t"+padAILeft("ai2") +
|
|
"\tstr2" +
|
|
"\tgames" +
|
|
"\td1win"+
|
|
"\td1lose"
|
|
);
|
|
|
|
int played = 0;
|
|
int p1Seed = 1234;
|
|
int p2Seed = 4321;
|
|
|
|
String hand1 ="";
|
|
String hand2 ="";
|
|
while (testDuel.getGamesPlayed() < testDuel.getGamesTotal()) {
|
|
|
|
if(played % 2 == 0){
|
|
p1Seed = MagicRandom.nextRNGInt();
|
|
p2Seed = MagicRandom.nextRNGInt();
|
|
}else{
|
|
int tmp = p1Seed;
|
|
p1Seed = p2Seed;
|
|
p2Seed = tmp;
|
|
}
|
|
final MagicGame game=testDuel.nextGame(p1Seed, p2Seed, played != 0);
|
|
if(verifyFlip) {
|
|
if (played % 2 == 0) {
|
|
hand1 = game.getPlayer(0).getHand().toString();
|
|
hand2 = game.getPlayer(1).getHand().toString();
|
|
} else {
|
|
compareHands(hand2, game.getPlayer(0).getHand().toString());
|
|
compareHands(hand1, game.getPlayer(1).getHand().toString());
|
|
}
|
|
}
|
|
game.setArtificial(true);
|
|
|
|
|
|
//maximum duration of a game is 60 minutes
|
|
final HeadlessGameController controller = new HeadlessGameController(game, 3600000);
|
|
|
|
controller.runGame();
|
|
|
|
if (testDuel.getGamesPlayed() > played) {
|
|
System.err.println(
|
|
padDeckLeft(deckName(deck[played % 2])) + "\t" +
|
|
padAILeft(ai[0].toString()) + "\t" +
|
|
str[0] + "\t" +
|
|
padDeckLeft(deckName(deck[(played+1) % 2])) + "\t" +
|
|
padAILeft(ai[1].toString()) + "\t" +
|
|
str[1] + "\t" +
|
|
testDuel.getGamesTotal() + "\t" +
|
|
testDuel.getGamesWon() + "\t" +
|
|
(testDuel.getGamesPlayed() - testDuel.getGamesWon())
|
|
);
|
|
played = testDuel.getGamesPlayed();
|
|
}
|
|
}
|
|
winTotal += testDuel.getGamesWon();
|
|
gamesTotal += testDuel.getGamesTotal();
|
|
System.out.println(
|
|
padDeckLeft("all")+ "\t" +
|
|
padAILeft(ai[0].toString()) + "\t" +
|
|
str[0] + "\t" +
|
|
padDeckLeft("all") + "\t" +
|
|
padAILeft(ai[1].toString()) + "\t" +
|
|
str[1] + "\t" +
|
|
gamesTotal + "\t" +
|
|
winTotal + "\t" +
|
|
(gamesTotal - winTotal) + "\t" +
|
|
(100*winTotal/gamesTotal)+"%"
|
|
);
|
|
}
|
|
private static String deckName(String path){
|
|
String[] bits = path.split("/");
|
|
return bits[bits.length-1];
|
|
}
|
|
|
|
public static String padAILeft(String s) {
|
|
int n = 25;
|
|
return String.format("%1$" + n + "s", s.substring(0, Math.min(s.length(), n)));
|
|
}
|
|
|
|
public static String padDeckLeft(String s) {
|
|
int n = 25;
|
|
return String.format("%1$" + n + "s", s.substring(0, Math.min(s.length(), n)));
|
|
}
|
|
}
|