source: src/main/java/parties/in4010/q12015/group9/Group9.java@ 3

package parties.in4010.q12015.group9;

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

import genius.core.AgentID;
import genius.core.Bid;
import genius.core.BidHistory;
import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.DefaultAction;
import genius.core.actions.Offer;
import genius.core.bidding.BidDetails;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.parties.NegotiationInfo;
import genius.core.utility.AdditiveUtilitySpace;

/**
 * This is your negotiation party.
 */
public class Group9 extends AbstractNegotiationParty {
        private Bid prevReceivedBid;
        private Bid currentConsideredBid;
        private int acceptCount;
        private OpponentModeling opponentModels;
        private AcceptStrat acceptStrat;
        private BiddingStrat biddingStrat;
        private HashMap<Object, BidHistory> previousBidsMap;

        /**
         * 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) {
                Bid ourBid = biddingStrat.createBid(previousBidsMap, opponentModels.getOpponentUtilities(), this.getTimeLine());

                if (!validActions.contains(Accept.class)) {
                        currentConsideredBid = ourBid;
                        return new Offer(getPartyId(), ourBid);
                } else {
                        if (acceptStrat.determineAcceptance(prevReceivedBid, previousBidsMap, ourBid,
                                        opponentModels.getOpponentUtilities(), this.getTimeLine())) {
                                return new Accept(getPartyId(), prevReceivedBid);
                        } else {
                                currentConsideredBid = ourBid;
                                return new Offer(getPartyId(), ourBid);
                        }
                }
        }

        /**
         * 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) {
                if (action instanceof Accept) { // .getClass().isInstance(new
                                                                                // Accept(getPartyId()))) {
                        acceptCount = acceptCount + 1;
                        updateBidhistory(sender, currentConsideredBid);
                        opponentModels.updateModel(sender, action, previousBidsMap);
                } else if (DefaultAction.getBidFromAction(action) != null) {
                        acceptCount = 0;
                        prevReceivedBid = DefaultAction.getBidFromAction(action);
                        updateBidhistory(sender, prevReceivedBid);
                        opponentModels.updateModel(sender, action, previousBidsMap);
                }
                super.receiveMessage(sender, action);
                // Here you hear other parties' messages
        }

        // Simple helper for putting a newly received bid into the history
        private void updateBidhistory(AgentID sender, Bid sendBid) {

                if (!previousBidsMap.containsKey(sender)) {
                        previousBidsMap.put(sender, new BidHistory());
                }
                BidDetails tempBidDetails = new BidDetails(sendBid, this.getUtility(sendBid),
                                this.getTimeLine().getCurrentTime());
                previousBidsMap.get(sender).add(tempBidDetails);
        }

        @Override
        public String getDescription() {
                return "example party group 9";
        }

        // Mostly initiate the super, besides that create the BOA components
        @Override
        public void init(NegotiationInfo info) {
                super.init(info);
                acceptCount = 0;
                opponentModels = new OpponentModeling((AdditiveUtilitySpace) info.getUtilitySpace());
                acceptStrat = new AcceptStrat((AdditiveUtilitySpace) info.getUtilitySpace());
                biddingStrat = new BiddingStrat((AdditiveUtilitySpace) info.getUtilitySpace());
                previousBidsMap = new HashMap<Object, BidHistory>();
        }

}