source: src/main/java/agents/anac/y2016/caduceus/Caduceus.java@ 3

package agents.anac.y2016.caduceus;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import agents.anac.y2016.caduceus.agents.Atlas3.Atlas3;
import agents.anac.y2016.caduceus.agents.Caduceus.UtilFunctions;
import agents.anac.y2016.caduceus.agents.ParsAgent.ParsAgent;
import agents.anac.y2016.caduceus.agents.RandomDance.RandomDance;
import agents.anac.y2016.caduceus.agents.kawaii.kawaii;
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.Offer;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.parties.NegotiationInfo;
import genius.core.parties.NegotiationParty;
import genius.core.persistent.DefaultPersistentDataContainer;
import genius.core.persistent.PersistentDataType;

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

        /**
         * 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.
         */

        public double discountFactor = 0; // if you want to keep the discount factor
        private double selfReservationValue = 0.75;
        private double percentageOfOfferingBestBid = 0.83;
        private Random random;

        public NegotiationParty[] agents = new NegotiationParty[5];
        public double[] scores = UtilFunctions
                        .normalize(new double[] { 500, 10, 5, 3, 1 });

        public double getScore(int agentIndex) {
                return scores[agentIndex];
        }

        @Override
        public void init(NegotiationInfo info) {

                super.init(info);

                random = new Random(info.getRandomSeed());

                agents[0] = new ParsAgent();
                agents[1] = new RandomDance();
                agents[2] = new kawaii();
                agents[3] = new Atlas3();
                agents[4] = new agents.anac.y2016.caduceus.agents.Caduceus.Caduceus();

                discountFactor = info.getUtilitySpace().getDiscountFactor(); // read
                                                                                                                                                // discount
                                                                                                                                                // factor
                double reservationValue = info.getUtilitySpace()
                                .getReservationValueUndiscounted();

                System.out.println("Discount Factor is " + discountFactor);
                System.out.println("Reservation Value is " + reservationValue);

                selfReservationValue = Math.max(selfReservationValue, reservationValue);
                percentageOfOfferingBestBid = percentageOfOfferingBestBid
                                * discountFactor;

                for (NegotiationParty agent : agents) {

                        agent.init(new NegotiationInfo(info.getUtilitySpace(),
                                        info.getDeadline(), info.getTimeline(),
                                        info.getRandomSeed(), info.getAgentID(),
                                        new DefaultPersistentDataContainer(null,
                                                        PersistentDataType.DISABLED)));
                }

        }

        @Override
        public Action chooseAction(List<Class<? extends Action>> validActions) {
                if (isBestOfferTime()) {
                        Bid bestBid = this.getBestBid();
                        if (bestBid != null)
                                return new Offer(getPartyId(), bestBid);
                        else
                                System.err.println("Best Bid is null?");
                }

                ArrayList<Bid> bidsFromAgents = new ArrayList<Bid>();
                ArrayList<Action> possibleActions = new ArrayList<Action>();

                for (NegotiationParty agent : agents) {
                        Action action = agent.chooseAction(validActions);
                        possibleActions.add(action);
                }

                double scoreOfAccepts = 0;
                double scoreOfBids = 0;
                ArrayList<Integer> agentsWithBids = new ArrayList<>();

                int i = 0;
                for (Action action : possibleActions) {
                        if (action instanceof Accept) {
                                scoreOfAccepts += getScore(i);
                        } else if (action instanceof Offer) {
                                scoreOfBids += getScore(i);
                                bidsFromAgents.add(((Offer) action).getBid());
                                agentsWithBids.add(i);
                        }
                        i++;
                }
                if (scoreOfAccepts > scoreOfBids) {
                        return new Accept(getPartyId(),
                                        ((ActionWithBid) getLastReceivedAction()).getBid());

                } else if (scoreOfBids > scoreOfAccepts) {
                        return new Offer(getPartyId(),
                                        getRandomizedAction(agentsWithBids, bidsFromAgents));
                }

                return new Offer(getPartyId(), getBestBid());
        }

        private Bid getRandomizedAction(ArrayList<Integer> agentsWithBids,
                        ArrayList<Bid> bidsFromAgents) {
                double[] possibilities = new double[agentsWithBids.size()];

                int i = 0;
                for (Integer agentWithBid : agentsWithBids) {
                        possibilities[i] = getScore(agentWithBid);
                        i++;
                }
                possibilities = UtilFunctions.normalize(possibilities);
                UtilFunctions.print(possibilities);
                double randomPick = random.nextDouble();

                double acc = 0;
                i = 0;
                for (double possibility : possibilities) {
                        acc += possibility;

                        if (randomPick < acc) {
                                return bidsFromAgents.get(i);
                        }

                        i++;
                }

                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. Can be null.
         * @param action
         *            The action that party did.
         */
        @Override
        public void receiveMessage(AgentID sender, Action action) {
                super.receiveMessage(sender, action);

                for (NegotiationParty agent : agents) {
                        agent.receiveMessage(sender, action);
                }

        }

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

        private Bid getBestBid() {
                try {
                        return this.utilitySpace.getMaxUtilityBid();
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return null;
        }

        private boolean isBestOfferTime() {
                return this.getTimeLine()
                                .getCurrentTime() < (this.getTimeLine().getTotalTime()
                                                * percentageOfOfferingBestBid);
        }
}