source: src/main/java/agents/anac/y2012/AgentLG/AgentLG.java@ 84

package agents.anac.y2012.AgentLG;

import genius.core.Agent;
import genius.core.Bid;
import genius.core.SupportedNegotiationSetting;
import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.Offer;
import genius.core.utility.AdditiveUtilitySpace;

/**
 * The Agent is most of the time stubborn but in the end it starts to
 * compromise. In the beginning it votes in the beginning its best votes. when
 * the time is 0-0.6 : it votes incrementally from its best utility to a minimum
 * of 0.75* utility and learns opponent utility. when the time is 0.6-0.9: it
 * starts to compromise and chooses better bid for the opponents that still good
 * for it only if the opponent is also comprising (the rate of compromise
 * depends on the opponent and on the discount factor). when the time over 0.9:
 * the agents starts to "panic" and compromise more frequently. when the time is
 * over(more then 0.9995 ) it chooses opponents max utility bid for it. The
 * Agent accept an offer only if it offered before by the agent or the time is
 * almost over and the bid is close enough to its worst offer.
 * 
 * @author Luba Golosman
 */
public class AgentLG extends Agent {

        private Bid myLastBid = null;
        private Bid oponnetLastBid = null;

        private BidChooser bidChooser = null;
        private OpponentBids oppenentsBid;
        private boolean bidLast = false;

        @Override
        public Action chooseAction() {

                Action currentAction = null;
                try {
                        double time = timeline.getTime();

                        // first bid -> vote the optimal bid
                        if (myLastBid == null || oponnetLastBid == null) {
                                myLastBid = this.utilitySpace.getMaxUtilityBid();
                                currentAction = new Offer(getAgentID(), myLastBid);
                        } else {
                                double opponentUtility = this.utilitySpace
                                                .getUtilityWithDiscount(oponnetLastBid, time);
                                double myUtility = this.utilitySpace
                                                .getUtilityWithDiscount(myLastBid, time);

                                // accept if opponent offer is good enough or there is no time
                                // and the offer is 'good'
                                if (opponentUtility >= myUtility * 0.99
                                                || (time > 0.999 && opponentUtility >= myUtility * 0.9)
                                                || bidChooser
                                                                .getMyBidsMinUtility(time) <= opponentUtility) {
                                        currentAction = new Accept(getAgentID(), oponnetLastBid);
                                } else if (bidLast) {
                                        currentAction = new Offer(getAgentID(), myLastBid);
                                }
                                // there is lot of time ->learn the opponent and bid the 1/4
                                // most optimal bids
                                else if (time < 0.6) {

                                        currentAction = bidChooser.getNextOptimicalBid(time);
                                } else {
                                        // the time is over -> bid the opponents max utility bid for
                                        // me
                                        if (time >= 0.9995) {
                                                myLastBid = oppenentsBid.getMaxUtilityBidForMe();
                                                if (utilitySpace.getUtilityWithDiscount(myLastBid,
                                                                time) < utilitySpace
                                                                                .getReservationValueWithDiscount(time))
                                                        myLastBid = bidChooser.getMyminBidfromBids();
                                                currentAction = new Offer(getAgentID(), myLastBid);
                                        } else {
                                                // Comprise and chose better bid for the opponents that
                                                // still good for me
                                                currentAction = bidChooser.getNextBid(time);
                                        }
                                }
                        }
                        if (currentAction instanceof Offer) {
                                myLastBid = ((Offer) currentAction).getBid();
                                if (oppenentsBid.getOpponentsBids().contains(myLastBid)) {
                                        bidLast = true;
                                }
                        }

                } catch (Exception e) {
                        currentAction = new Accept(getAgentID(), oponnetLastBid);
                }

                return currentAction;
        }

        @Override
        public String getName() {
                return "AgentLG";
        }

        @Override
        public void init() {
                oppenentsBid = new OpponentBids(utilitySpace);
                bidChooser = new BidChooser((AdditiveUtilitySpace) this.utilitySpace,
                                getAgentID(), oppenentsBid);
        }

        @Override
        public void ReceiveMessage(Action opponentAction) {
                if (opponentAction instanceof Offer) {
                        oponnetLastBid = ((Offer) opponentAction).getBid();

                        try {
                                oppenentsBid.addBid(((Offer) opponentAction).getBid());
                                oppenentsBid.getOpponentBidUtility(
                                                this.utilitySpace.getDomain(), oponnetLastBid);
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }

        }

        @Override
        public String getVersion() {
                return "1.1";
        }

        @Override
        public SupportedNegotiationSetting getSupportedNegotiationSetting() {
                return SupportedNegotiationSetting.getLinearUtilitySpaceInstance();
        }

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