source: src/test/java/boaexample/BoaPartyExample.java@ 173

package boaexample;

import java.util.List;
import java.util.Collections;
import java.util.HashMap;

import genius.core.boaframework.BoaParty;
import genius.core.parties.NegotiationInfo;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.ValueDiscrete;
import genius.core.uncertainty.AdditiveUtilitySpaceFactory;
import genius.core.utility.AbstractUtilitySpace;
import negotiator.boaframework.opponentmodel.HardHeadedFrequencyModel;

/**
 * This example shows how BOA components can be made into an independent
 * negotiation party.
 * 
 * Note that this is equivalent to adding a BOA party via the GUI by selecting
 * the components and parameters. However, this method gives more control over
 * the implementation, as the agent designer can choose to override behavior
 * (such as handling preference uncertainty).
 */
public class BoaPartyExample extends BoaParty {

        @Override
        public void init(NegotiationInfo info) {
                HashMap<String, Double> noparams = (HashMap<String, Double>) Collections.EMPTY_MAP;
                HashMap<String, Double> osParams = new HashMap<String, Double>();
                // Set the concession parameter "e" for the offering strategy to yield
                // Boulware-like behavior
                osParams.put("e", 0.2);

                configure(new AC_Next(), noparams, new TimeDependent_Offering(),
                                osParams, new HardHeadedFrequencyModel(), noparams,
                                new BestBid(), noparams);
                super.init(info);
        }

        /**
         * Specific functionality, such as the estimate of the utility space in the
         * face of preference uncertainty, can be specified by overriding the
         * default behavior.
         * 
         * This example estimator sets all weights and all evaluator values randomly.
         */
        @Override
        public AbstractUtilitySpace estimateUtilitySpace() {
                AdditiveUtilitySpaceFactory additiveUtilitySpaceFactory = new AdditiveUtilitySpaceFactory(getDomain());
                List<IssueDiscrete> issues = additiveUtilitySpaceFactory.getIssues();
                for (IssueDiscrete i : issues)
                {
                        additiveUtilitySpaceFactory.setWeight(i, rand.nextDouble());
                        for (ValueDiscrete v : i.getValues())
                                additiveUtilitySpaceFactory.setUtility(i, v, rand.nextDouble());
                }
                
                // Normalize the weights, since we picked them randomly in [0, 1]
                additiveUtilitySpaceFactory.normalizeWeights();
                
                // The factory is done with setting all parameters, now return the utility space
                return additiveUtilitySpaceFactory.getUtilitySpace();
        }
        
        // All the rest of the functionality is defined by the BOA framework

}