source: src/main/java/agents/ai2014/group7/Group7.java@ 61

package agents.ai2014.group7;

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.DefaultAction;
import genius.core.actions.Offer;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.parties.NegotiationInfo;

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

        private Bid activeBid = null;
        private Bid maxUtilityBid = null;
        private double declineStart = 0.8;
        private double startUtility = 0.95;
        private double endUtility;

        @Override
        public void init(NegotiationInfo info) {
                super.init(info);

                endUtility = utilitySpace.getReservationValueUndiscounted();
                try {
                        maxUtilityBid = utilitySpace.getMaxUtilityBid();
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }

        /**
         * 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) {
                System.out.println(cosDiscount(scale(timeline.getTime(), declineStart, 1f, 0f, 1f), startUtility, endUtility));
                try {
                        Bid candidateBid = generateBid();
                        if (validActions.contains(Accept.class) && acceptable(activeBid))
                                return new Accept(getPartyId(), activeBid);
                        return new Offer(getPartyId(), candidateBid);
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return null;
        }

        /**
         * 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) {
                Bid bid = DefaultAction.getBidFromAction(action);
                if (bid != null)
                        activeBid = bid;
        }

        /**
         * Generate a random bid that this agent would currently find acceptable.
         * 
         * @return An acceptable bid.
         * @throws Exception
         */
        private Bid generateBid() throws Exception {
                for (int i = 0; i < 1000; i++) {
                        Bid bid = generateRandomBid();
                        if (acceptable(bid))
                                return bid;
                }
                return new Bid(maxUtilityBid);
        }

        /**
         * Determine if a bid is currently acceptable. This depends on the
         * negotiation progress. Bids with a lower utility become acceptable when
         * nearing the deadline.
         * 
         * @param bid
         * @return
         */
        private boolean acceptable(Bid bid) {
                double progress = timeline.getTime();
                return progress < declineStart ? getUtility(bid) > startUtility
                                : getUtility(bid) > cosDiscount(scale(progress, declineStart, 1f, 0f, 1f), startUtility, endUtility);
        }

        /**
         * Calculate a discount based on the cosine function. Interpolates using
         * first quarter of the cosine.
         * 
         * @param progress
         *            Value between 0.0 to 1.0.
         * @param high
         *            Return value when progress equals 0.0.
         * @param low
         *            Return value when progress equals 1.0.
         * @return Interpolated value between to and from.
         */
        private double cosDiscount(double progress, double high, double low) {
                return scale(Math.cos(progress * Math.PI / 2), 0, 1f, low, high);
        }

        private double scale(double value, double fromLow, double fromHigh, double toLow, double toHigh) {
                return toLow + (value - fromLow) / (fromHigh - fromLow) * (toHigh - toLow);
        }

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

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

}