source: src/main/java/agents/ai2014/group12/Group12.java@ 33

package agents.ai2014.group12;

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

import genius.core.AgentID;
import genius.core.Bid;
import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.ActionWithBid;
import genius.core.actions.DefaultAction;
import genius.core.actions.Offer;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.parties.NegotiationInfo;
import genius.core.timeline.TimeLineInfo;
import genius.core.utility.AdditiveUtilitySpace;

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

        ArrayList<Bid> previousBids = new ArrayList<Bid>();
        ArrayList<BidWithSender> previousBidsWithSender = new ArrayList<BidWithSender>();
        Preference preference;
        UtilityOracle oracle;
        int round = 0;
        HashMap<String, Preference> otherAgentsPreference = new HashMap<String, Preference>();
        TimeLineInfo timeline;
        int timeLimit;

        /**
         * 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 randomization, use this seed for it.
         */
        @Override
        public void init(NegotiationInfo info) {
                // Make sure that this constructor calls it's parent.
                super.init(info);
                preference = new Preference((AdditiveUtilitySpace) utilitySpace);

                this.timeline = info.getTimeline();
                timeLimit = (int) timeline.getTotalTime();

                double utilityValue = calculateUtilityValue(timeLimit);
                oracle = new UtilityOracle(utilityValue);

        }

        /**
         * 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) {
                double acceptingValue = oracle.getAcceptingValue(round);
                double bidValue = 0;
                if (previousBids.size() != 0) {
                        try {
                                bidValue = this.utilitySpace.getUtility(previousBids.get(previousBids.size() - 1));
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
                round++;

                if ((round == timeLimit - 2 || round == timeLimit - 2) && acceptableLastOffer(bidValue, acceptingValue)) {
                        return new Accept(getPartyId(), ((ActionWithBid) getLastReceivedAction()).getBid());
                }

                if (!validActions.contains(Accept.class) || acceptingValue >= bidValue) {
                        Bid bid = new Bid(utilitySpace.getDomain());
                        try {
                                bid = BidGenerator.generateBid(this.utilitySpace, this.preference, acceptingValue,
                                                this.otherAgentsPreference);
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        return new Offer(getPartyId(), bid);
                } else {
                        System.out.println("Accept");
                        return new Accept(getPartyId(), ((ActionWithBid) getLastReceivedAction()).getBid());
                }
        }

        /**
         * 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) {
                // Here you can listen to other parties' messages
                super.receiveMessage(sender, action);

                System.out.println(sender.toString());

                if (DefaultAction.getBidFromAction(action) != null) {
                        Bid bid = DefaultAction.getBidFromAction(action);
                        try {
                                if (!otherAgentsPreference.containsKey(sender.toString())) {
                                        Preference pref = new Preference((AdditiveUtilitySpace) this.utilitySpace, bid);
                                        otherAgentsPreference.put(sender.toString(), pref);
                                } else {
                                        ArrayList<Bid> previousbidsOfSender = getBidsOfSender(sender.toString());
                                        otherAgentsPreference.get(sender.toString()).updatePreferenceOrder(bid);
                                        otherAgentsPreference.get(sender.toString()).updateIssueWeights(previousbidsOfSender, bid);
                                }
                                Double utilityOfBid = this.utilitySpace.getUtility(bid);
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        BidWithSender bidWS = new BidWithSender(bid, sender.toString());
                        previousBidsWithSender.add(bidWS);
                        previousBids.add(bid);
                }
        }

        private ArrayList<Bid> getBidsOfSender(String sender) {
                ArrayList<Bid> previousBids = new ArrayList<Bid>();
                for (BidWithSender bidWS : previousBidsWithSender) {
                        if (bidWS.sender.equals(sender)) {
                                previousBids.add(bidWS.bid);
                        }
                }
                return previousBids;
        }

        private boolean acceptableLastOffer(double bidvalue, double acceptingValue) {
                double bidvalueBottom = bidvalue - 2 * (bidvalue / 10);

                if (bidvalueBottom > acceptingValue) {
                        return true;
                } else {
                        return false;
                }
        }

        private double calculateUtilityValue(int timeline) {
                double retUtility = 0.5 / timeline;
                return retUtility;
        }

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

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

}