source: src/main/java/agents/ai2014/group4/Group4.java@ 127

package agents.ai2014.group4;

import java.util.List;

import java.util.ArrayList;
import java.util.HashMap;

import genius.core.AgentID;
import genius.core.Bid;
import genius.core.DeadlineType;
import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.DefaultAction;
import genius.core.actions.Offer;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.parties.NegotiationInfo;
import genius.core.utility.AbstractUtilitySpace;

/**
 * This is your negotiation party.
 */
public class Group4 extends AbstractNegotiationParty {

        private Double currentUtility = 0.0;
        private Double threshold;
        private Double RESERVATION_VALUE;
        private final Double STARTING_THRESHOLD = 0.9;
        private final Double COMPROMISE_RATE = 4.0; // 1 is linear, higher is slower
                                                                                                // to compromise
        private int turns;
        private int round = 0;

        private Bid highestBid;
        private Bid lastGivenBid;
        private Bid lastReceivedBid;
        private HashMap<String, Party> parties = new HashMap<String, Party>();
        private ArrayList<List<ValueDiscrete>> values = new ArrayList<List<ValueDiscrete>>();
        private BidGenerator bidGenerator;

        private HashMap<Bid, Double> possibleBids = new HashMap<Bid, Double>();
        private AbstractUtilitySpace utilitySpace;

        /**
         * Please keep this constructor. This is called by genius.
         *
         * @param utilitySpace
         *            Your utility space.
         * @param deadlines
         *            The deadlines set for this negotiation.
         * @param timeline
         *            Value counting from 0 (start) to 1 (end).
         * @param randomSeed
         *            If you use any randomisation, use this seed for it.
         */
        @Override
        public void init(NegotiationInfo info) {
                // Make sure that this constructor calls it's parent.
                super.init(info);

                for (Issue issue : utilitySpace.getDomain().getIssues()) {
                        values.add(((IssueDiscrete) issue).getValues());
                }

                // creates the generator
                generatePossibleBids(0, null);
                turns = getDeadlines().getType() == DeadlineType.ROUND ? getDeadlines().getValue() : 0; // -1
                // helps
                // with
                // very
                // low
                // deadline,
                // doesn't
                // hurt
                // large.
                bidGenerator = new BidGenerator(this, possibleBids, turns);

                RESERVATION_VALUE = utilitySpace.getReservationValue();
        }

        private void generatePossibleBids(int n, HashMap<Integer, Value> bidValues) {
                if (n >= values.size()) {
                        Bid b = null;

                        try {
                                b = new Bid(utilitySpace.getDomain(), bidValues);
                                possibleBids.put(b, getUtility(b));
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                        return;
                }
                for (Value v : values.get(n)) {
                        HashMap<Integer, Value> currentBid;

                        if (n == 0) {
                                currentBid = new HashMap<Integer, Value>();
                        } else {
                                currentBid = (HashMap<Integer, Value>) bidValues.clone();
                        }

                        currentBid.put(n + 1, v);
                        generatePossibleBids(n + 1, currentBid);
                }
        }

        /**
         * Each round this method gets called and ask you to accept or offer. The
         * first party in the first round is a bit different, it can only propose an
         * offer.
         *
         * @param validActions
         *            Either a list containing both accept and offer or only offer.
         * @return The chosen action.
         */
        @Override
        public Action chooseAction(List<Class<? extends Action>> validActions) {
                round++;
                threshold = STARTING_THRESHOLD
                                - (STARTING_THRESHOLD - RESERVATION_VALUE) * Math.pow((double) round / (double) turns, COMPROMISE_RATE);

                /*
                 * if(round >= turns){ return new Accept(); }
                 */

                if (!validActions.contains(Accept.class) || currentUtility < threshold) {
                        Bid b = null;
                        // if it's first turn, get out with best possible bid
                        if (lastGivenBid == null) {
                                try {
                                        b = utilitySpace.getMaxUtilityBid();
                                } catch (Exception e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }

                        // do something to get the bid as answer
                        else {
                                // it generates the best not used bid
                                int index = 0;
                                do {
                                        b = bidGenerator.generateBestBid();

                                        index++;
                                        if (index > 100) {
                                                index = 0;
                                                threshold = threshold - 0.01; // safety measure
                                        }
                                } while (getUtility(b) < threshold);

                        }
                        setLastGivenBid(b);
                        return new Offer(getPartyId(), b);

                } else {
                        return new Accept(getPartyId(), lastReceivedBid);
                }
        }

        /**
         * All offers proposed by the other parties will be received as a message.
         * You can use this information to your advantage, for example to predict
         * their utility.
         *
         * @param sender
         *            The party that did the action.
         * @param action
         *            The action that party did.
         */
        @Override
        public void receiveMessage(AgentID sender, Action action) {
                super.receiveMessage(sender, action);

                if (!parties.containsKey(sender.toString())) {
                        Party party = new Party(sender.toString(), utilitySpace.getDomain(), sender);
                        parties.put(sender.toString(), party);
                }

                if (lastReceivedBid != null) {
                        parties.get(sender.toString()).updateWithBid(lastReceivedBid, action);
                }

                if (action instanceof Offer) {
                        lastReceivedBid = DefaultAction.getBidFromAction(action);
                        currentUtility = getUtility(lastReceivedBid);
                        updateHighestBid(lastReceivedBid);
                } else if (action instanceof Accept) {
                }

        }

        private void updateHighestBid(Bid b) {
                // TODO it check if it is the highest and in case update it
        }

        // *******GETTER AND SETTER********

        public Double getCurrentUtility() {
                return currentUtility;
        }

        public void setCurrentUtility(Double currentUtility) {
                this.currentUtility = currentUtility;
        }

        public Double getThreshold() {
                return threshold;
        }

        public void setThreshold(Double threshold) {
                this.threshold = threshold;
        }

        public Bid getHighestBid() {
                return highestBid;
        }

        public void setHighestBid(Bid highestBid) {
                this.highestBid = highestBid;
        }

        public Bid getLastGivenBid() {
                return lastGivenBid;
        }

        public void setLastGivenBid(Bid lastGivenBid) {
                this.lastGivenBid = lastGivenBid;
        }

        public HashMap<String, Party> getParties() {
                return parties;
        }

        public void setParties(HashMap<String, Party> parties) {
                this.parties = parties;
        }

        public int getTurns() {
                return turns;
        }

        protected AgentID partyId = new AgentID("Group 4");

        @Override
        public String getDescription() {
                return "ai2014 group4";
        }

}