source: java/ecj/cecj/app/BoardGameProblem.java @ 660

package cecj.app;

import cecj.app.othello.OthelloBoard;
import cecj.app.othello.OthelloGame;
import cecj.app.othello.OthelloPlayer;
import cecj.interaction.InteractionResult;
import cecj.interaction.WinDrawLossResult;
import cecj.interaction.WinDrawLossResult.Result;
import cecj.problems.SymmetricTestBasedProblem;
import cecj.utils.Pair;
import ec.EvolutionState;
import ec.Individual;
import ec.util.Parameter;
import ec.vector.DoubleVectorIndividual;
import games.Player;
import games.scenarios.GameScenario;
import games.scenarios.RandomizedTwoPlayersGameScenario;
import games.scenarios.SimpleTwoPlayersGameScenario;

public class BoardGameProblem extends SymmetricTestBasedProblem {

        private static final int WPC_LENGTH = 64;
        private static final String P_RANDOMNESS = "randomness";

        private double randomness;
        private boolean randomizedPlay;

        @Override
        public void setup(EvolutionState state, Parameter base) {
                super.setup(state, base);

                Parameter randomnessParam = base.push(P_RANDOMNESS);
                if (state.parameters.exists(randomnessParam)) {
                        randomness = state.parameters.getDoubleWithDefault(randomnessParam, null, 0);
                        randomizedPlay = true;
                } else {
                        randomizedPlay = false;
                }
        }

        @Override
        public Pair<? extends InteractionResult> test(EvolutionState state, Individual candidate,
                        Individual test) {
                if (!(candidate instanceof DoubleVectorIndividual)
                                || !(test instanceof DoubleVectorIndividual)) {
                        state.output.error("Othello players should be represented by floats vectors\n");
                }

                double[] wpc1 = ((DoubleVectorIndividual) candidate).genome;
                double[] wpc2 = ((DoubleVectorIndividual) test).genome;

                if (wpc1.length != WPC_LENGTH || wpc2.length != WPC_LENGTH) {
                        state.output.error("Players WPC vectors length should be 64\n");
                }

                // TODO: should the game be repeated?
                OthelloPlayer player1 = new OthelloPlayer(wpc1);
                OthelloPlayer player2 = new OthelloPlayer(wpc2);
                OthelloGame game = new OthelloGame(new OthelloBoard());

                GameScenario scenario;
                if (randomizedPlay) {
                        scenario = new RandomizedTwoPlayersGameScenario(state.random[0], new Player[] {
                                        player1, player2 }, new double[] { randomness, randomness });
                } else {
                        scenario = new SimpleTwoPlayersGameScenario(new Player[] { player1, player2 });
                }

                int result = scenario.play(game);
                if (result > 0) {
                        return new Pair<WinDrawLossResult>(new WinDrawLossResult(Result.WIN),
                                        new WinDrawLossResult(Result.LOSS));
                } else if (result < 0) {
                        return new Pair<WinDrawLossResult>(new WinDrawLossResult(Result.LOSS),
                                        new WinDrawLossResult(Result.WIN));
                } else {
                        return new Pair<WinDrawLossResult>(new WinDrawLossResult(Result.DRAW),
                                        new WinDrawLossResult(Result.DRAW));
                }
        }

}